public void CubicPolynomialFunctionValueTest()
{
Func<double, double> f = x => 3 * Math.Pow(x, 3) + 2 * x - 6;
var current = f(2);
var df = new NumericalDerivative(3, 0);
Assert.AreEqual(38, df.EvaluateDerivative(f, 2, 1, current), 1e-8);
}
public void ExponentialFunctionPartialDerivativeTest()
{
//Test Function
Func <double[], double> f = (x) => Math.Sin(x[0] * x[1]) + Math.Exp(-x[0] / 2) + x[1] / x[0];
//Analytical partial dfdx
Func <double[], double> dfdx =
(x) => Math.Cos(x[0] * x[1]) * x[1] - Math.Exp(-x[0] / 2) / 2 - x[1] / Math.Pow(x[0], 2);
//Analytical partial dfdy
Func <double[], double> dfdy = (x) => Math.Cos(x[0] * x[1]) * x[0] + 1 / x[0];
var df = new NumericalDerivative(3, 1);
var x1 = new double[] { 3, 3 };
Assert.AreEqual(dfdx(x1), df.EvaluatePartialDerivative(f, x1, 0, 1), 1e-8);
Assert.AreEqual(dfdy(x1), df.EvaluatePartialDerivative(f, x1, 1, 1), 1e-8);
var x2 = new double[] { 300, -50 };
df.StepType = StepType.Absolute;
Assert.AreEqual(dfdx(x2), df.EvaluatePartialDerivative(f, x2, 0, 1), 1e-5);
Assert.AreEqual(dfdy(x2), df.EvaluatePartialDerivative(f, x2, 1, 1), 1e-2);
}
public void SinFirstDerivativeAtZeroTest()
{
Func <double, double> f = Math.Sin;
var df = new NumericalDerivative();
Assert.AreEqual(1, df.EvaluateDerivative(f, 0, 1), 1e-10);
}
public double T, K, S; // Parameters needed for path
public GeneratePath(SSVIparametrisasion ssvi)
{
numericalDerivative = new MathNet.Numerics.Differentiation.NumericalDerivative(); //to approximate derivaties with the finite diff method.
this.ssvi = ssvi; //The surface we are working with
this.S = ssvi.S;
this.T = ssvi.T;
}
public static Func <double, double> Derive(Func <double, double> f, int deriveRank)
{
//Func<double, double> f = x => 3 * Math.Pow(x, 3) + 2 * x - 6;
var n = new NumericalDerivative(5, 2);
var df = n.CreateDerivativeFunctionHandle(f, deriveRank);
return(df);
}
public void CubicPolynomialFunctionValueTest()
{
Func <double, double> f = x => 3 * Math.Pow(x, 3) + 2 * x - 6;
var current = f(2);
var df = new NumericalDerivative(3, 0);
Assert.AreEqual(38, df.EvaluateDerivative(f, 2, 1, current), 1e-8);
}
static public Func <double, double> FindDerivative(Func <double, double> function)
{
NumericalDerivative derivative = new NumericalDerivative();
Func <double, double> derivativeFunction;
derivativeFunction = derivative.CreateDerivativeFunctionHandle(function, 1);
return(derivativeFunction);
}
public void CubicPolynomialFunctionValueTest()
{
double Func(double x) => 3 * Math.Pow(x, 3) + 2 * x - 6;
var current = Func(2);
var df = new NumericalDerivative(3, 0);//CentredFiniteDifferenceDerivative(3, 0);
Assert.AreEqual(38, df.EvaluateDerivative(Func, 2, 1, current), 1e-8);
}
public static void GetError(Double fromInterval, Double toInterval, int n)
{
var derivative = new NumericalDerivative((n + 2), 0);
var M = derivative.EvaluateDerivative(Constants.Function, Math.Abs(fromInterval), n + 1);
var R = (M * Math.Pow(Math.Abs(fromInterval) - 0, n + 1)) / SpecialFunctions.Factorial(n + 1);
Console.WriteLine("Kai x priklauso intervalui [{0}, {1}], tai R{2}={3}", fromInterval, toInterval, n, R);
}
public void RosenbrockFunctionMixedDerivativeTwoVariableSecondOrderTest()
{
Func <double[], double> f = x => Math.Pow(1 - x[0], 2) + 100 * Math.Pow(x[1] - Math.Pow(x[0], 2), 2);
var df = new NumericalDerivative();
var x0 = new double[] { 2, 2 };
var parameterIndex = new[] { 0, 1 };
Assert.AreEqual(-800, df.EvaluateMixedPartialDerivative(f, x0, parameterIndex, 2));
}
/// <summary>
/// Evaluating Bucketed Delta
/// </summary>
/// <returns>The bucketed delta</returns>
public Decimal GetBucketedDelta1(decimal forwardRate)
{
//var realFunction = new RealFunction(BucketedDeltaTargetFunction);
var rate = forwardRate;
var dRate = Decimal.ToDouble(rate);
var numerical = new NumericalDerivative();
var delta = (Decimal)numerical.EvaluateDerivative(BucketedDeltaTargetFunction, dRate, 1);
return(delta / 10000);
}
/// <summary>
///
/// </summary>
/// <param name="td"></param>
/// <param name="cd"></param>
/// <param name="skinFactor"></param>
/// <returns></returns>
public static double PwdRDerivative(double td, double cd, double skinFactor)
{
Condition.Requires(td, nameof(td)).IsGreaterOrEqual(0.0);
Condition.Requires(cd, nameof(cd)).IsGreaterOrEqual(0.0);
var nd = new NumericalDerivative();
var d = nd.EvaluateDerivative(c => PwdR(c, cd, skinFactor), td, 1);
return(d * td);
}
/// <summary>
/// Evaluating Bucketed Delta
/// </summary>
/// <returns>The bucketed delta</returns>
protected virtual Decimal EvaluateBucketedDelta1()
{
var solution = new NumericalDerivative();
Func <double, double> f = BucketedDeltaTargetFunction;
var rate = FloatingIndex;
var dRate = Decimal.ToDouble(rate);
var delta = (Decimal)solution.EvaluateDerivative(f, dRate, 1);
return(delta / BasisPoint);
}
/// <summary>
///
/// </summary>
/// <param name="td"></param>
/// <param name="Ld"></param>
/// <returns></returns>
public static double PwDbLinearSealingFaultDerivative(double td, double Ld)
{
Condition.Requires(td, nameof(td)).IsGreaterOrEqual(0.0);
Condition.Requires(Ld, nameof(Ld)).IsGreaterThan(0.0);
var nd = new NumericalDerivative();
var d = nd.EvaluateDerivative(c => PwDbLinearSealingFault(c, Ld), td, 1);
return(d * td);
}
public void RosenbrockFunctionMixedDerivativeOneVariableSecondOrderTest()
{
Func <double[], double> f = x => Math.Pow(1 - x[0], 2) + 100 * Math.Pow(x[1] - Math.Pow(x[0], 2), 2);
var df = new NumericalDerivative();
var x0 = new double[] { 2, 2 };
var parameterindex = new int[] { 0, 0 };
Assert.AreEqual(1602, df.EvaluatePartialDerivative(f, x0, 0, 1), 1e-6);
Assert.AreEqual(4002, df.EvaluateMixedPartialDerivative(f, x0, parameterindex, 2));
}
/// <summary>
/// PTA derivative: dP * time
/// </summary>
/// <param name="time">elapsed time, hours</param>
/// <param name="q">flow rate at surface, [STB/D]</param>
/// <returns></returns>
public double PressureDropDerivative(double time, double q)
{
var nd = new NumericalDerivative();
if (time > 0.01)
{
nd.StepType = StepType.Relative;
nd.Epsilon = 1e-6;
}
var dP = nd.EvaluateDerivative(x => PressureDrop(x, q), time, 1);
return(dP * time);
}
public double CountIntegralForCore(int kindOfCore)
{
Func <double, double> core;
NumericalDerivative derivative = new NumericalDerivative(10, 5);
Func <double, double> fourthDerivative = derivative.CreateDerivativeFunctionHandle(Func, 4); //CountDerivative(func, 4);
Func <double, double> thirdDerivative = derivative.CreateDerivativeFunctionHandle(Func, 3); //CountDerivative(func, 3);
Func <double, double> secondDerivative = derivative.CreateDerivativeFunctionHandle(Func, 2); //CountDerivative(func, 2);
//Console.WriteLine("fourthDerivative = " + fourthDerivative(1.57));
//Console.WriteLine("thirdDerivative = " + thirdDerivative(1.57));
//Console.WriteLine("secondDerivative = " + secondDerivative(1.57));
if (kindOfCore == 1)
{
core = (x) => { return(fourthDerivative(x) - ((Math.Pow(thirdDerivative(x), 2)) / (secondDerivative(x + 0.00001)))); }
}
;
else
{
core = (x) => { return(fourthDerivative(x)); }
};
// Console.WriteLine("core = " + core(1));
Func <double, double> underIntegralFunc = (x) => { return(Math.Pow(Math.Abs((core(x))), 0.25)); };
double integralValue = CountIntegral(LeftLimit, RightLimit, underIntegralFunc, Precision);
return(integralValue);
}
//public double Factorial(double number)
//{
// double res = 1;
// double n = number;
// while (n != 1)
// {
// res *= n;
// n--;
// }
// return res;
//}
//public double ErrorCount(double integralValue, int parametersAmount, double r)
//{
// double error = 0;
// // double integralValue = CountIntegral();
// error = ((Math.Pow(integralValue, parametersAmount)) / (Math.Pow(2, parametersAmount) * Factorial(parametersAmount) * Math.Pow(r, parametersAmount)));
// return error;
//}
}
public void VectorFunctionMixedPartialDerivativeTest()
{
Func <double[], double>[] f =
{
(x) => Math.Pow(x[0], 2) - 3 * x[1],
(x) => x[1] * x[1] + 2 * x[0] * x[1]
};
var x0 = new double[] { 2, 2 };
var df = new NumericalDerivative();
Assert.AreEqual(new double[] { 0, 2 }, df.EvaluateMixedPartialDerivative(f, x0, new int[] { 0, 1 }, 2));
Assert.AreEqual(new double[] { 0, 2 }, df.EvaluateMixedPartialDerivative(f, x0, new int[] { 1, 0 }, 2));
}
public void CreateDerivativeFunctionHandleTest()
{
Func <double, double> f = x => 3 * Math.Pow(x, 3) + 2 * x - 6;
var nd = new NumericalDerivative(5, 2);
var df = nd.CreateDerivativeFunctionHandle(f, 3);
Assert.AreEqual(18, df(0));
// Test new function with same nd class
Func <double, double> f2 = x => 2 * Math.Pow(x, 3) + 2 * x - 6;
var df2 = nd.CreateDerivativeFunctionHandle(f2, 3);
Assert.AreEqual(12, df2(0));
// Original delegate not changed
Assert.AreEqual(18, df(0));
}
public void CreateDerivativeFunctionHandleTest()
{
Func<double, double> f = x => 3 * Math.Pow(x, 3) + 2 * x - 6;
var nd = new NumericalDerivative(5, 2);
var df = nd.CreateDerivativeFunctionHandle(f, 3);
Assert.AreEqual(18, df(0));
// Test new function with same nd class
Func<double, double> f2 = x => 2 * Math.Pow(x, 3) + 2 * x - 6;
var df2 = nd.CreateDerivativeFunctionHandle(f2, 3);
Assert.AreEqual(12, df2(0));
// Original delegate not changed
Assert.AreEqual(18, df(0));
}
public void VectorFunction1PartialDerivativeTest()
{
Func <double[], double>[] f =
{
(x) => Math.Pow(x[0], 2) - 3 * x[1],
(x) => x[1] * x[1] + 2 * x[0] * x[1]
};
var x0 = new double[] { 2, 2 };
var g = new double[] { 4, 4 };
var df = new NumericalDerivative();
Assert.AreEqual(g, df.EvaluatePartialDerivative(f, x0, 0, 1));
Assert.AreEqual(new double[] { 2, 0 }, df.EvaluatePartialDerivative(f, x0, 0, 2));
Assert.AreEqual(new double[] { -3, 8 }, df.EvaluatePartialDerivative(f, x0, 1, 1));
}
public Func <double, double> CountCoreFunc(Func <double, double> func, int kindOfCore)
{
NumericalDerivative derivative = new NumericalDerivative(6, 3);
Func <double, double> fourthDerivative = derivative.CreateDerivativeFunctionHandle(func, 4); //CountDerivative(func, 4);
Func <double, double> thirdDerivative = derivative.CreateDerivativeFunctionHandle(func, 3); //CountDerivative(func, 3);
Func <double, double> secondDerivative = derivative.CreateDerivativeFunctionHandle(func, 2); //CountDerivative(func, 2);
switch (kindOfCore)
{
case 1: { return((x) => { return (fourthDerivative(x) - Math.Pow(thirdDerivative(x), 2) / (secondDerivative(x))); }); }
case 2: { return((x) => { return fourthDerivative(x); }); };
default: break;
}
return(null);
}
private Vector3 getNormalNumeric(Vector3 r)
{
List <DefinedCommonFunction> derivativesU = new List <DefinedCommonFunction>();
List <DefinedCommonFunction> derivativesV = new List <DefinedCommonFunction>();
NumericalDerivative derivative = new NumericalDerivative();
derivativesU.Add(new DefinedCommonFunction(derivative.CreatePartialDerivativeFunctionHandle(r.X.Invoke, 0, 1), "null"));
derivativesV.Add(new DefinedCommonFunction(derivative.CreatePartialDerivativeFunctionHandle(r.X.Invoke, 1, 1), "null"));
derivativesU.Add(new DefinedCommonFunction(derivative.CreatePartialDerivativeFunctionHandle(r.Y.Invoke, 0, 1), "null"));
derivativesV.Add(new DefinedCommonFunction(derivative.CreatePartialDerivativeFunctionHandle(r.Y.Invoke, 1, 1), "null"));
derivativesU.Add(new DefinedCommonFunction(derivative.CreatePartialDerivativeFunctionHandle(r.Z.Invoke, 0, 1), "null"));
derivativesV.Add(new DefinedCommonFunction(derivative.CreatePartialDerivativeFunctionHandle(r.Z.Invoke, 1, 1), "null"));
Vector3 v1 = new Vector3(derivativesU);
Vector3 v2 = new Vector3(derivativesV);
var normalNotNormalized = (v1 ^ v2);
var len = new OneVarFunction(Math.Sqrt, normalNotNormalized * normalNotNormalized, null);
return(normalNotNormalized / len);
}
public void CubicPolynomialThirdDerivativeAtAnyValTest()
{
Func<double, double> f = x => 3 * Math.Pow(x, 3) + 2 * x - 6;
var df = new NumericalDerivative(5, 2);
Assert.AreEqual(18, df.EvaluateDerivative(f, 0, 3));
Assert.AreEqual(18, df.EvaluateDerivative(f, 10, 3));
df.Center = 0;
Assert.AreEqual(18, df.EvaluateDerivative(f, 0, 3));
Assert.AreEqual(18, df.EvaluateDerivative(f, 10, 3));
df.Center = 1;
Assert.AreEqual(18, df.EvaluateDerivative(f, 0, 3));
Assert.AreEqual(18, df.EvaluateDerivative(f, 10, 3));
df.Center = 2;
Assert.AreEqual(18, df.EvaluateDerivative(f, 0, 3));
Assert.AreEqual(18, df.EvaluateDerivative(f, 10, 3));
df.Center = 3;
Assert.AreEqual(18, df.EvaluateDerivative(f, 0, 3));
Assert.AreEqual(18, df.EvaluateDerivative(f, 10, 3));
df.Center = 4;
Assert.AreEqual(18, df.EvaluateDerivative(f, 0, 3));
Assert.AreEqual(18, df.EvaluateDerivative(f, 10, 3));
}
public void ExponentialFunctionPartialDerivativeCurrentValueTest()
{
//Test Function
Func <double[], double> f = (x) => Math.Sin(x[0] * x[1]) + Math.Exp(-x[0] / 2) + x[1] / x[0];
//Analytical partial dfdx
Func <double[], double> dfdx =
(x) => Math.Cos(x[0] * x[1]) * x[1] - Math.Exp(-x[0] / 2) / 2 - x[1] / Math.Pow(x[0], 2);
//Analytical partial dfdy
Func <double[], double> dfdy = (x) => Math.Cos(x[0] * x[1]) * x[0] + 1 / x[0];
// Current value
var x1 = new double[] { 3, 3 };
var current = f(x1);
var df = new NumericalDerivative(5, 2);
Assert.AreEqual(dfdx(x1), df.EvaluatePartialDerivative(f, x1, 0, 1, current), 1e-8);
Assert.AreEqual(dfdy(x1), df.EvaluatePartialDerivative(f, x1, 1, 1, current), 1e-8);
}
public void CubicPolynomialThirdDerivativeAtAnyValTest()
{
Func <double, double> f = x => 3 * Math.Pow(x, 3) + 2 * x - 6;
var df = new NumericalDerivative(5, 2);
Assert.AreEqual(18, df.EvaluateDerivative(f, 0, 3));
Assert.AreEqual(18, df.EvaluateDerivative(f, 10, 3));
df.Center = 0;
Assert.AreEqual(18, df.EvaluateDerivative(f, 0, 3));
Assert.AreEqual(18, df.EvaluateDerivative(f, 10, 3));
df.Center = 1;
Assert.AreEqual(18, df.EvaluateDerivative(f, 0, 3));
Assert.AreEqual(18, df.EvaluateDerivative(f, 10, 3));
df.Center = 2;
Assert.AreEqual(18, df.EvaluateDerivative(f, 0, 3));
Assert.AreEqual(18, df.EvaluateDerivative(f, 10, 3));
df.Center = 3;
Assert.AreEqual(18, df.EvaluateDerivative(f, 0, 3));
Assert.AreEqual(18, df.EvaluateDerivative(f, 10, 3));
df.Center = 4;
Assert.AreEqual(18, df.EvaluateDerivative(f, 0, 3));
Assert.AreEqual(18, df.EvaluateDerivative(f, 10, 3));
}
/// <summary>
/// Evaluating the vector of Bucketed Delta
/// </summary>
/// <returns>The vector of bucketed delta</returns>
protected override Decimal[] EvaluateBucketedDeltaVector()
{
Func <double, double> f = BucketedDeltaTargetFunction;
var df = new NumericalDerivative();
var bucketedRates = EvaluatedBucketedRates();
var bucketedDeltaVector = new decimal[bucketedRates.Length];
const Decimal cDefault = 0.0m;
if (bucketedRates.Length == 0 && bucketedRates[0] == cDefault)
{
bucketedDeltaVector[0] = cDefault;
}
else
{
for (var index = bucketedRates.Length - 1; index >= 0; index--)
{
var rate = bucketedRates[index];
var dRate = Decimal.ToDouble(rate);
var temp = (Decimal)df.EvaluateDerivative(f, dRate, 1);
bucketedDeltaVector[index] = temp / BasisPoint;
}
}
return(bucketedDeltaVector);
}
public void CubicPolynomialThirdDerivativeAtAnyValTest()
{
double Func(double x) => 3 * Math.Pow(x, 3) + 2 * x - 6;
var df = new NumericalDerivative(5, 2);//CentredFiniteDifferenceDerivative(5, 2)
Assert.AreEqual(18, df.EvaluateDerivative(Func, 0, 3));
Assert.AreEqual(18, df.EvaluateDerivative(Func, 10, 3));
df.Center = 0;
Assert.AreEqual(18, df.EvaluateDerivative(Func, 0, 3));
Assert.AreEqual(18, df.EvaluateDerivative(Func, 10, 3));
df.Center = 1;
Assert.AreEqual(18, df.EvaluateDerivative(Func, 0, 3));
Assert.AreEqual(18, df.EvaluateDerivative(Func, 10, 3));
df.Center = 2;
Assert.AreEqual(18, df.EvaluateDerivative(Func, 0, 3));
Assert.AreEqual(18, df.EvaluateDerivative(Func, 10, 3));
df.Center = 3;
Assert.AreEqual(18, df.EvaluateDerivative(Func, 0, 3));
Assert.AreEqual(18, df.EvaluateDerivative(Func, 10, 3));
df.Center = 4;
Assert.AreEqual(18, df.EvaluateDerivative(Func, 0, 3));
Assert.AreEqual(18, df.EvaluateDerivative(Func, 10, 3));
}
/// <summary>
/// Bootstraps the specified priceable assets.
/// </summary>
/// <param name="priceableAssets">The priceable assets.</param>
/// <param name="baseZeroCurve">The base Zero Curve</param>
/// <param name="algorithmHolder">The algorithmHolder</param>
/// <returns></returns>
public TermPoint[] Bootstrap(List <IPriceableRateAssetController> priceableAssets,
IRateCurve baseZeroCurve, PricingStructureAlgorithmsHolder algorithmHolder)
{
var items = new SortedDictionary <DateTime, Pair <string, decimal> >();
DateTime baseDate = baseZeroCurve.GetBaseDate();
items.Add(baseDate, new Pair <string, decimal>(null, 1m));
bool firstTime = true;
const double compoundingPeriod = 0.25;
IPriceableRateAssetController previousAsset = null;
IEnumerable <TermPoint> basePillars = baseZeroCurve.GetTermCurve().point;
IDayCounter dayCounter = null;
foreach (IPriceableRateAssetController priceableAsset in priceableAssets)
{
List <DateTime> assetDates;
if (priceableAsset is PriceableSwapRateAsset swap)
{
dayCounter = DayCounterHelper.Parse(swap.DayCountFraction.Value);
assetDates = swap.AdjustedPeriodDates;
}
else
{
PriceableDeposit deposit = priceableAsset as PriceableDeposit;
if (deposit == null)
{
throw new ArgumentException(
$"PriceableAsset must be a PriceableSwapRateAsset or PriceableDeposit, '{priceableAsset.GetType()}' is not implemented.");
}
dayCounter = DayCounterHelper.Parse(deposit.Deposit.dayCountFraction.Value);
assetDates = new List <DateTime> {
deposit.AdjustedStartDate, deposit.GetRiskMaturityDate()
};
}
DateTime maturityDate = priceableAsset.GetRiskMaturityDate();
if (items.Keys.Contains(maturityDate))
{
throw new ArgumentException(
$"Duplicate priceable asset on '{maturityDate:yyyy-MM-dd}'", nameof(priceableAssets));
}
//The min and max values to use with the solver.
const int xmin = -1;
const int xmax = 1;
var accuracy = 10 ^ -12;
if (firstTime)
{
firstTime = false;
// Solve to find the quarterly compounded zero rate spread
var solverFunctions
= new NewtonRaphsonSolverFunctions(priceableAsset, null, algorithmHolder, baseZeroCurve,
baseDate, items, compoundingPeriod, ZeroRateSpreads, dayCounter, assetDates);
var solver = new Newton();
var initialGuess = (double)priceableAsset.MarketQuote.value;
//var solution = new CenteredFiniteDifferenceDerivative();
Func <double, double> f = solverFunctions.ShortEndTargetFunction;
var derivativeOfTargetFunction = new NumericalDerivative().CreateDerivativeFunctionHandle(f, 1);
double zeroRateSpread = solver.Solve(f, derivativeOfTargetFunction, accuracy, initialGuess, xmin, xmax);
// add first point
DateTime startDate = assetDates.First();
decimal df = (decimal)GetAdjustedDiscountFactor(baseDate, startDate, dayCounter, zeroRateSpread, baseZeroCurve);
if (startDate != baseDate)
{
items.Add(startDate, new Pair <string, decimal>(null, df));
}
ZeroRateSpreads.Add(maturityDate, zeroRateSpread);
// add extra points
IEnumerable <TermPoint> extraPoints = basePillars.Where(b => (DateTime)b.term.Items[0] > startDate && (DateTime)b.term.Items[0] < maturityDate);
// Extrapolate the preceding extra points
foreach (TermPoint extraPoint in extraPoints)
{
DateTime date = (DateTime)extraPoint.term.Items[0];
df = (decimal)GetAdjustedDiscountFactor(baseDate, date, dayCounter, zeroRateSpread, baseZeroCurve);
items.Add(date, new Pair <string, decimal>(extraPoint.id, df));
}
// add final point
df = (decimal)GetAdjustedDiscountFactor(baseDate, maturityDate, dayCounter, zeroRateSpread, baseZeroCurve);
items.Add(maturityDate, new Pair <string, decimal>(priceableAsset.Id, df));
}
else
{
items.Add(maturityDate, new Pair <string, decimal>(priceableAsset.Id, 0));
ZeroRateSpreads.Add(maturityDate, (double)priceableAsset.MarketQuote.value);
// Solve to find the quarterly compounded zero rate spread
var solverFunctions
= new NewtonRaphsonSolverFunctions(priceableAsset, previousAsset, algorithmHolder, baseZeroCurve,
baseDate, items, compoundingPeriod, ZeroRateSpreads, dayCounter, assetDates);
Func <double, double> f = solverFunctions.LongEndTargetFunction;
var solver = new Newton();
var initialGuess = (double)priceableAsset.MarketQuote.value;
var derivativeOfTargetFunction = new NumericalDerivative().CreateDerivativeFunctionHandle(f, 1);
double zeroRateSpread = solver.Solve(f, derivativeOfTargetFunction, accuracy, initialGuess, xmin, xmax);
// Update discount factor value
decimal df = (decimal)GetAdjustedDiscountFactor(baseDate, maturityDate, dayCounter, zeroRateSpread, baseZeroCurve);
items[maturityDate].Second = df;
ZeroRateSpreads[maturityDate] = zeroRateSpread;
solverFunctions.UpdateDiscountFactors(baseDate);
}
previousAsset = priceableAsset;
}
// Extrapolate the following extra points
IEnumerable <TermPoint> finalPoints = basePillars.Where(b => (DateTime)b.term.Items[0] > items.Last().Key);
KeyValuePair <DateTime, double> zeroRateSpreadFinal = ZeroRateSpreads.Last();
foreach (TermPoint extraPoint in finalPoints)
{
DateTime date = (DateTime)extraPoint.term.Items[0];
decimal df = (decimal)GetAdjustedDiscountFactor(baseDate, date, dayCounter, zeroRateSpreadFinal.Value, baseZeroCurve);
items.Add(date, new Pair <string, decimal>(extraPoint.id, df));
}
return(TermPointsFactory.Create(items));
}
public static double GetNthOrderDerivativeValueAt0(int n)
{
var derivative = new NumericalDerivative(6, 0);
return derivative.EvaluateDerivative(Constants.Function, 0, n);
}
public void ExponentialFunctionPartialDerivativeTest()
{
//Test Function
Func<double[], double> f = (x) => Math.Sin(x[0] * x[1]) + Math.Exp(-x[0] / 2) + x[1] / x[0];
//Analytical partial dfdx
Func<double[], double> dfdx =
(x) => Math.Cos(x[0] * x[1]) * x[1] - Math.Exp(-x[0] / 2) / 2 - x[1] / Math.Pow(x[0], 2);
//Analytical partial dfdy
Func<double[], double> dfdy = (x) => Math.Cos(x[0] * x[1]) * x[0] + 1 / x[0];
var df = new NumericalDerivative(3, 1);
var x1 = new double[] { 3, 3 };
Assert.AreEqual(dfdx(x1), df.EvaluatePartialDerivative(f, x1, 0, 1), 1e-8);
Assert.AreEqual(dfdy(x1), df.EvaluatePartialDerivative(f, x1, 1, 1), 1e-8);
var x2 = new double[] { 300, -50 };
df.StepType = StepType.Absolute;
Assert.AreEqual(dfdx(x2), df.EvaluatePartialDerivative(f, x2, 0, 1), 1e-5);
Assert.AreEqual(dfdy(x2), df.EvaluatePartialDerivative(f, x2, 1, 1), 1e-2);
}
public void RosenbrockFunctionMixedDerivativeOneVariableSecondOrderTest()
{
Func<double[], double> f = x => Math.Pow(1 - x[0], 2) + 100 * Math.Pow(x[1] - Math.Pow(x[0], 2), 2);
var df = new NumericalDerivative();
var x0 = new double[] { 2, 2 };
var parameterindex = new int[] { 0, 0 };
Assert.AreEqual(1602, df.EvaluatePartialDerivative(f, x0, 0, 1), 1e-6);
Assert.AreEqual(4002, df.EvaluateMixedPartialDerivative(f, x0, parameterindex, 2));
}
public void RosenbrockFunctionMixedDerivativeTwoVariableSecondOrderTest()
{
Func<double[], double> f = x => Math.Pow(1 - x[0], 2) + 100 * Math.Pow(x[1] - Math.Pow(x[0], 2), 2);
var df = new NumericalDerivative();
var x0 = new double[] { 2, 2 };
var parameterIndex = new[] { 0, 1 };
Assert.AreEqual(-800, df.EvaluateMixedPartialDerivative(f, x0, parameterIndex, 2));
}
public void SinFirstDerivativeAtZeroTest()
{
Func<double, double> f = Math.Sin;
var df = new NumericalDerivative();
Assert.AreEqual(1, df.EvaluateDerivative(f, 0, 1), 1e-10);
}
public void VectorFunction1PartialDerivativeTest()
{
Func<double[], double>[] f =
{
(x) => Math.Pow(x[0],2) - 3*x[1],
(x) => x[1]*x[1] + 2*x[0]*x[1]
};
var x0 = new double[] { 2, 2 };
var g = new double[] { 4, 4 };
var df = new NumericalDerivative();
Assert.AreEqual(g, df.EvaluatePartialDerivative(f, x0, 0, 1));
Assert.AreEqual(new double[] { 2, 0 }, df.EvaluatePartialDerivative(f, x0, 0, 2));
Assert.AreEqual(new double[] { -3, 8 }, df.EvaluatePartialDerivative(f, x0, 1, 1));
}
public void VectorFunctionMixedPartialDerivativeTest()
{
Func<double[], double>[] f =
{
(x) => Math.Pow(x[0],2) - 3*x[1],
(x) => x[1]*x[1] + 2*x[0]*x[1]
};
var x0 = new double[] { 2, 2 };
var df = new NumericalDerivative();
Assert.AreEqual(new double[] { 0, 2 }, df.EvaluateMixedPartialDerivative(f, x0, new int[] { 0, 1 }, 2));
Assert.AreEqual(new double[] { 0, 2 }, df.EvaluateMixedPartialDerivative(f, x0, new int[] { 1, 0 }, 2));
}
public void ExponentialFunctionPartialDerivativeCurrentValueTest()
{
//Test Function
Func<double[], double> f = (x) => Math.Sin(x[0] * x[1]) + Math.Exp(-x[0] / 2) + x[1] / x[0];
//Analytical partial dfdx
Func<double[], double> dfdx =
(x) => Math.Cos(x[0] * x[1]) * x[1] - Math.Exp(-x[0] / 2) / 2 - x[1] / Math.Pow(x[0], 2);
//Analytical partial dfdy
Func<double[], double> dfdy = (x) => Math.Cos(x[0] * x[1]) * x[0] + 1 / x[0];
// Current value
var x1 = new double[] { 3, 3 };
var current = f(x1);
var df = new NumericalDerivative(5, 2);
Assert.AreEqual(dfdx(x1), df.EvaluatePartialDerivative(f, x1, 0, 1, current), 1e-8);
Assert.AreEqual(dfdy(x1), df.EvaluatePartialDerivative(f, x1, 1, 1, current), 1e-8);
}
