/// <summary>
/// Gets the value.
/// </summary>
/// <param name="pt">The pt.</param>
/// <param name="interpolationType">The interpolation.</param>
/// <param name="extrapolation">if set to <c>true</c> [extrapolation].</param>
/// <param name="times">A vertical array of times.</param>
/// <param name="values">A vertical array of values.</param>
/// <returns>The value at that point.</returns>
public static Double GetValue(Double pt, string interpolationType, bool extrapolation, Double[] times, Double[] values)
{
var curve = new InterpolatedCurve(new DiscreteCurve(times, values), InterpolationFactory.Create(interpolationType), extrapolation);
IPoint point = new Point1D(pt);
return(curve.Value(point));
}
public void TestAllInterpolations()
{
Random r = new Random(Environment.TickCount);
foreach (string interp in _linearInterpolations)
{
TearDown();
var interpolation = InterpolationFactory.Create(interp);
interpolation.Initialize(_times, _rates);
Debug.WriteLine($"interpolationType : {interp}");
for (int i = 1; i < 100; ++i)
{
double time = (i + r.Next(-10000, 10000) / 10000) / 10.0;
double interpRate = interpolation.ValueAt(time, true);
Debug.WriteLine($"interpolatedRate : {interpRate} Time: {time}");
}
int index = 0;
foreach (double time in _times)
{
if (time != 0.0)
{
double interpRate = interpolation.ValueAt(time, true);
double interpValue = _rates[index];
Assert.AreEqual(interpRate, interpValue, 10 - 8);
}
index++;
}
}
foreach (string interp in _logLinearInterpolations)
{
TearDown();
double[] exp = SetUp();
double[] temp = new double[exp.Length];
exp.CopyTo(temp, 0);
var interpolation = InterpolationFactory.Create(interp);
interpolation.Initialize(_times, temp);
Debug.WriteLine($"interpolationType : {interp}");
for (int i = 1; i < 100; ++i)
{
double time = (i + r.Next(-10000, 10000) / 10000) / 10.0;
double interpRate = interpolation.ValueAt(time, true);
Debug.WriteLine($"interpolatedRate : {interpRate} Time: {time}");
}
int index = 0;
foreach (double time in _times)
{
if (time != 0.0)
{
double interpRate = interpolation.ValueAt(time, true);
double interpValue = exp[index];
Assert.AreEqual(interpRate, interpValue, 10 - 8);
}
index++;
}
}
}
/// <summary>
/// Gets the df.
/// </summary>
/// <param name="days">The days.</param>
/// <returns></returns>
public decimal GetDf(int days)
{
var rateCurve = new InterpolatedCurve(new DiscreteCurve(GetYearsArray(),
RateArray), InterpolationFactory.Create(InterpolationType), false);
double maturityYrs = days / 365.0;
IPoint point = new Point1D(maturityYrs);
double rate = rateCurve.Value(point);
double df = RateAnalytics.ZeroRateToDiscountFactor(rate, maturityYrs, RateType);
decimal df0 = Convert.ToDecimal(df);
return(df0);
}
/// <summary>
/// Gets the rate lin365.
/// </summary>
/// <param name="yearFraction1">The year fraction1.</param>
/// <param name="yearFraction2">The year fraction2.</param>
/// <param name="ratedays">The ratedays.</param>
/// <param name="rateamts">The rateamts.</param>
/// <param name="daybasis">The daybasis.</param>
/// <returns></returns>
public static double GetRateCCLin365(double yearFraction1, double yearFraction2, int[] ratedays, double[] rateamts)
{
DiscreteCurve rc = CreateCurve(ratedays, rateamts, 365);
var rateCurve = new InterpolatedCurve(rc, InterpolationFactory.Create("LinearInterpolation"), false);
IPoint pt1 = new Point1D(yearFraction1);
IPoint pt2 = new Point1D(yearFraction2);
double rt1 = rateCurve.Value(pt1);
double rt2 = rateCurve.Value(pt2);
if (yearFraction1 != yearFraction2)
{
return((rt2 * yearFraction2 - rt1 * yearFraction1) / (yearFraction2 - yearFraction1));
}
return(0);
}
private void buttonInterpolate_Click(object sender, EventArgs e)
{
if (comboBoxInterpolationType.SelectedIndex < 0)
{
MessageBox.Show("Не выбран тип интерполяции.");
return;
}
InterpolationType interpolationType = (InterpolationType)Enum.Parse(typeof(InterpolationType), comboBoxInterpolationType.SelectedItem.ToString());
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
Interpolation.Interpolation instance = InterpolationFactory.GetInterpolationProvider(interpolationType, this.RemainedPoints.ToArray());
if (checkBoxParallelMode.Checked)
{
List<Task> tasks = new List<Task>();
foreach (var item in this.RemovedPoints)
{
Task task = new Task(() =>
{
item.Y = instance.GetInterpolatedValue(item.X);
});
task.Start();
tasks.Add(task);
}
Task.WaitAll(tasks.ToArray());
}
else
{
foreach (var item in this.RemovedPoints)
{
item.Y = checked(instance.GetInterpolatedValue(item.X));
}
}
stopwatch.Stop();
this.DrawGraphic(
2,
System.Windows.Forms.DataVisualization.Charting.SeriesChartType.Point,
this.RemovedPoints,
"Interpolated");
this.label9.Text = this.defaultTimeInfo + (stopwatch.ElapsedMilliseconds / 1000.0).ToString();
}
public void TestAllInterpolatedCurves()
{
foreach (string interp in _linearInterpolations)
{
TearDown();
IInterpolation interpolation = InterpolationFactory.Create(interp);
DiscreteCurve curve = new DiscreteCurve(_times, _rates);
IInterpolatedSpace interpCurve = new InterpolatedCurve(curve, interpolation, true);
Debug.WriteLine($"interpolationType : {interp}");
foreach (double point in _testPointArray)
{
IPoint p = new Point1D(point);
Console.WriteLine(interpCurve.Value(p));
}
}
foreach (string interp in _specialInterpolations)
{
TearDown();
var interpolation = (WingModelInterpolation)InterpolationFactory.Create(interp);
interpolation.Forward = 1.0;
interpolation.Spot = 1.0;
var curve = new DiscreteCurve(Strikes, Vols);
IInterpolatedSpace interpCurve = new InterpolatedCurve(curve, interpolation, true);
Debug.WriteLine($"interpolationType : {interp}");
foreach (double point in _testPointArray)
{
IPoint p = new Point1D(point);
Console.WriteLine(interpCurve.Value(p));
}
}
foreach (string interp in _logLinearInterpolations)
{
TearDown();
double[] exp = SetUp();
IInterpolation interpolation = InterpolationFactory.Create(interp);
DiscreteCurve curve = new DiscreteCurve(_times, exp);
IInterpolatedSpace interpCurve = new InterpolatedCurve(curve, interpolation, true);
Debug.WriteLine($"interpolationType : {interp}");
foreach (double point in _testPointArray)
{
IPoint p = new Point1D(point);
Console.WriteLine(interpCurve.Value(p));
}
}
}
/// <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>
/// Builds a raw volatility surface from basic data types.
/// </summary>
/// <param name="rows"></param>
/// <param name="columns"></param>
/// <param name="volData"></param>
/// <param name="interpolation"></param>
/// <param name="allowExtrapolation"></param>
public VolSurfaceInterpolator(double[] rows, double[] columns, Matrix volData, InterpolationMethod interpolation, bool allowExtrapolation)
: base(new DiscreteSurface(rows, columns, volData), InterpolationFactory.Create(interpolation.Value), allowExtrapolation)
{
}
/// <summary>
/// Builds a raw volatility surface from basic data types.
/// </summary>
/// <param name="data"></param>
/// <param name="interpolation"></param>
/// <param name="allowExtrapolation"></param>
/// <param name="baseDate"></param>
public VolSurfaceInterpolator(MultiDimensionalPricingData data, InterpolationMethod interpolation, bool allowExtrapolation, DateTime baseDate)
: base(ProcessMultiDimensionalPricingData(data, baseDate), InterpolationFactory.Create(interpolation.Value), allowExtrapolation)
{
}
/// <summary>
/// VolSurfaceInterpolator
/// </summary>
/// <param name="discreteCurve"></param>
/// <param name="interpolation"></param>
/// <param name="allowExtrapolation"></param>
public VolSurfaceInterpolator(IDiscreteSpace discreteCurve, InterpolationMethod interpolation, bool allowExtrapolation)
: base(discreteCurve, InterpolationFactory.Create(interpolation.Value), allowExtrapolation)
{
}
/// <summary>
/// SimpleDiscountFactorCurve
/// </summary>
/// <param name="baseDate"></param>
/// <param name="interpolation"></param>
/// <param name="extrapolation"></param>
/// <param name="dates"></param>
/// <param name="dfs"></param>
public SimpleDiscountFactorCurve(DateTime baseDate, InterpolationMethod interpolation, bool extrapolation,
DateTime[] dates, Decimal[] dfs)
: base(new DiscreteCurve(PointCurveHelper(baseDate, dates), Converter(dfs)), InterpolationFactory.Create(interpolation.Value), extrapolation)
{
BaseDate = baseDate;
}
/// <summary>
/// SimpleFxCurve
/// </summary>
/// <param name="baseDate"></param>
/// <param name="interpolation"></param>
/// <param name="extrapolation"></param>
/// <param name="times"></param>
/// <param name="dfs"></param>
public SimpleEquityCurve(DateTime baseDate, InterpolationMethod interpolation, bool extrapolation, //TODO add a curve id.
IList <double> times, IList <double> dfs)
: base(new DiscreteCurve(times, dfs), InterpolationFactory.Create(interpolation.Value), extrapolation)
{
BaseDate = baseDate;
}
public float Update(float dt, InterpolationMode i)
{
return(Update(ref this, dt, InterpolationFactory.GetInterpolation(i)));
}
/// <summary>
/// Builds a raw volatility surface from basic data types.
/// </summary>
/// <param name="data"></param>
/// <param name="forwards"></param>
/// <param name="xInterpolation"></param>
/// <param name="yInterpolation"></param>
public ExtendedVolatilitySurfaceInterpolator(MultiDimensionalPricingData data, ParametricAdjustmentPoint[] forwards, string xInterpolation, string yInterpolation)
: base(ProcessMultiDimensionalPricingData(data), forwards, InterpolationFactory.Create(xInterpolation), InterpolationFactory.Create(yInterpolation), true)
{
}
/// <summary>
/// SimpleCommodityCurve
/// </summary>
/// <param name="baseDate"></param>
/// <param name="interpolation"></param>
/// <param name="extrapolation"></param>
/// <param name="dfs"></param>
public SimpleBondCurve(DateTime baseDate, InterpolationMethod interpolation, bool extrapolation,
IDictionary <DateTime, double> dfs)
: base(new DiscreteCurve(PointCurveHelper(baseDate, dfs.Keys), dfs.Values.ToList()), InterpolationFactory.Create(interpolation.Value), extrapolation)
{
BaseDate = baseDate;
}
///<summary>
///</summary>
///<param name="termCurve"></param>
///<param name="baseDate"></param>
///<param name="dayCounter"></param>
public FxCurveInterpolator(TermCurve termCurve, DateTime baseDate, IDayCounter dayCounter)
: base(CurveHelper.Converter(termCurve, baseDate, dayCounter), InterpolationFactory.Create(termCurve), CurveHelper.IsExtrapolationPermitted(termCurve))
{
}
/// <summary>
/// SimpleVolatilitySurface
/// </summary>
/// <param name="baseDate"></param>
/// <param name="interpolation"></param>
/// <param name="extrapolation"></param>
/// <param name="times"></param>
/// <param name="strikes"></param>
/// <param name="vols"></param>
public SimpleVolatilitySurface(DateTime baseDate, InterpolationMethod interpolation, bool extrapolation, //TODO add a curve id.
double[] times, double[] strikes, double[,] vols)
: base(times, strikes, new Matrix(vols), InterpolationFactory.Create(interpolation.Value), extrapolation)
{
_baseDate = baseDate;
}
/// <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);
}
public float Interpolate(float v0, float v1, float t)
{
return(InterpolationFactory.Linear(v0, v1, t));
}
public float Interpolate(float v0, float v1, float t)
{
return(InterpolationFactory.EaseInQuad(v0, v1, t));
}
/// <summary>
/// Initializes a new instance of the <see cref="SimpleZeroRateCurve"/> class.
/// </summary>
/// <param name="interpolation">The interpolation.</param>
/// <param name="extrapolation">if set to <c>true</c> [extrapolation].</param>
/// <param name="times">The times.</param>
/// <param name="rates">The rates.</param>
public SimpleZeroInflationRateCurve(InterpolationMethod interpolation, bool extrapolation, double[] times, double[] rates)
: base(new DiscreteCurve(times, rates), InterpolationFactory.Create(interpolation.Value), extrapolation)
{
}
/// <summary>
/// SimpleCapletCurve
/// </summary>
/// <param name="baseDate"></param>
/// <param name="interpolation"></param>
/// <param name="extrapolation"></param>
/// <param name="vols"></param>
public SimpleCapletCurve(DateTime baseDate, InterpolationMethod interpolation, bool extrapolation,
IDictionary <DateTime, Decimal> vols)
: base(new DiscreteCurve(PointCurveHelper(baseDate, vols.Keys), Converter(vols.Values)), InterpolationFactory.Create(interpolation.Value), extrapolation)
{
BaseDate = baseDate;
}
/// <summary>
/// SimpleInflationCurve
/// </summary>
/// <param name="baseDate"></param>
/// <param name="interpolation"></param>
/// <param name="extrapolation"></param>
/// <param name="times"></param>
/// <param name="dfs"></param>
public SimpleInflationCurve(DateTime baseDate, InterpolationMethod interpolation, bool extrapolation, //TODO add a curve id.
double[] times, double[] dfs)
: base(new DiscreteCurve(times, dfs), InterpolationFactory.Create(interpolation.Value), extrapolation)
{
BaseDate = baseDate;
}
/// <summary>
/// SimpleDiscountFactorCurve
/// </summary>
/// <param name="referenceCurve"></param>
/// <param name="baseDate"></param>
/// <param name="extrapolation"></param>
/// <param name="times"></param>
/// <param name="dfs"></param>
public SimpleSpreadDiscountFactorCurve(IRateCurve referenceCurve, DateTime baseDate, bool extrapolation,
double[] times, double[] dfs)
: base(new DiscreteCurve(times, dfs), InterpolationFactory.CreateRateSpread(referenceCurve), extrapolation)
{
BaseDate = baseDate;
}
/// <summary>
/// Builds a raw volatility surface from basic data types.
/// </summary>
/// <param name="rows"></param>
/// <param name="columns"></param>
/// <param name="forwards"></param>
/// <param name="volData"></param>
/// <param name="xInterpolation"></param>
/// <param name="yInterpolation"></param>
public ExtendedVolatilitySurfaceInterpolator(double[] rows, double[] columns, double[] forwards, Matrix volData, string xInterpolation, string yInterpolation)
: base(rows, columns, forwards, volData, InterpolationFactory.Create(xInterpolation), InterpolationFactory.Create(yInterpolation))
{
}
/// <summary>
/// SimpleDiscountFactorCurve
/// </summary>
/// <param name="referenceCurve"></param>
/// <param name="baseDate"></param>
/// <param name="extrapolation"></param>
/// <param name="dfs"></param>
public SimpleSpreadDiscountFactorCurve(ICommodityCurve referenceCurve, DateTime baseDate, bool extrapolation,
IDictionary <DateTime, double> dfs)
: base(new DiscreteCurve(PointCurveHelper(baseDate, dfs.Keys), dfs.Values.ToList()), InterpolationFactory.CreateCommoditySpread(referenceCurve), extrapolation)
{
BaseDate = baseDate;
}
/// <summary>
/// SimpleFxCurve
/// </summary>
/// <param name="baseDate"></param>
/// <param name="interpolation"></param>
/// <param name="extrapolation"></param>
/// <param name="dates"></param>
/// <param name="dfs"></param>
public SimpleEquityCurve(DateTime baseDate, InterpolationMethod interpolation, bool extrapolation, //TODO add a curve id.
IEnumerable <DateTime> dates, IList <double> dfs)
: base(new DiscreteCurve(PointCurveHelper(baseDate, dates), dfs), InterpolationFactory.Create(interpolation.Value), extrapolation)
{
BaseDate = baseDate;
}
/// <summary>
/// SimpleDiscountFactorCurve
/// </summary>
/// <param name="referenceCurve"></param>
/// <param name="baseDate"></param>
/// <param name="extrapolation"></param>
/// <param name="dates"></param>
/// <param name="dfs"></param>
public SimpleSpreadDiscountFactorCurve(IRateCurve referenceCurve, DateTime baseDate, bool extrapolation,
IEnumerable <DateTime> dates, IEnumerable <decimal> dfs)
: base(new DiscreteCurve(PointCurveHelper(baseDate, dates), ConvertDecimals(dfs)), InterpolationFactory.CreateRateSpread(referenceCurve), extrapolation)
{
BaseDate = baseDate;
}
/// <summary>
/// SimpleCommodityCurve
/// </summary>
public SimpleBondCurve(DateTime baseDate, InterpolationMethod interpolation, bool extrapolation,
IEnumerable <DateTime> dates, double[] dfs)
: base(new DiscreteCurve(PointCurveHelper(baseDate, dates), dfs), InterpolationFactory.Create(interpolation.Value), extrapolation)
{
BaseDate = baseDate;
}
public float Interpolate(float v0, float v1, float t)
{
return(InterpolationFactory.EaseOutCubic(v0, v1, t));
}
