/**
* Formats nicer error messages for the junit output
*/
private static double invokeInternal(Function target, ValueEval[] args, int srcCellRow, int srcCellCol)
{
ValueEval EvalResult = null;
try
{
EvalResult = target.Evaluate(args, srcCellRow, (short)srcCellCol);
}
catch (NotImplementedException e)
{
throw new NumericEvalEx("Not implemented:" + e.Message);
}
if (EvalResult == null)
{
throw new NumericEvalEx("Result object was null");
}
if (EvalResult is ErrorEval)
{
ErrorEval ee = (ErrorEval)EvalResult;
throw new NumericEvalEx(formatErrorMessage(ee));
}
if (!(EvalResult is NumericValueEval))
{
throw new NumericEvalEx("Result object type (" + EvalResult.GetType().Name
+ ") is invalid. Expected implementor of ("
+ typeof(NumericValueEval).Name + ")");
}
NumericValueEval result = (NumericValueEval)EvalResult;
return result.NumberValue;
}
public void InterpolateLinear1D()
{
IVariable<double> x = new Variable<double>("x");
IVariable<double> y = new Variable<double>("y");
var function = new Function();
function.Arguments.Add(x);
function.Components.Add(y);
var xValues = new[] {1.0, 2.0, 3.0};
var yValues = new[] {100.0, 200.0, 300.0};
function.SetValues(yValues, new VariableValueFilter<double>(x, xValues), new ComponentFilter(y));
var value = function.Evaluate<double>(new VariableValueFilter<double>(x, 1.5));
Assert.AreEqual(150.0, value);
value = function.Evaluate<double>(new VariableValueFilter<double>(x, 2.5));
Assert.AreEqual(250.0, value);
value = function.Evaluate<double>(new VariableValueFilter<double>(x, 1.75));
Assert.AreEqual(175, value);
}
public void EvaluateReturnsDefaultValueOnEmptyFunction()
{
IVariable<double> x = new Variable<double>("x");
IVariable<double> y = new Variable<double>("y");
IFunction f = new Function();
f.Arguments.Add(x);
f.Components.Add(y);
x.ExtrapolationType = ApproximationType.Constant;
y.DefaultValue = 10.0;
Assert.AreEqual(10.0, f.Evaluate<double>(x.CreateValueFilter(1.0)));
}
public void InterpolateConstant1D()
{
//defines a piece-wise-constant function. Value is always equals to the value of the neareast smaller
//argument
IVariable<double> x = new Variable<double>("x");
IVariable<double> y = new Variable<double>("y");
Function function = new Function();
function.Arguments.Add(x);
function.Components.Add(y);
var xValues = new[] { 1.0, 2.0, 3.0 };
var yValues = new[] { 100.0, 200.0, 300.0 };
function.SetValues(yValues, new VariableValueFilter<double>(x, xValues), new ComponentFilter(y));
x.InterpolationType = ApproximationType.Constant;
var value = function.Evaluate<double>(new VariableValueFilter<double>(x, 1.5));
Assert.AreEqual(100.0, value);
value = function.Evaluate<double>(new VariableValueFilter<double>(x, 2.5));
Assert.AreEqual(200.0, value);
}
public void GetExtraPolatedValueFor2dFunctionWithOnePointDefined()
{
IVariable<double> x1 = new Variable<double>("x1");
IVariable<double> x2 = new Variable<double>("x2");
IVariable<double> y = new Variable<double>("y");
IFunction function = new Function();
function.Arguments.Add(x1);
function.Arguments.Add(x2);
x2.ExtrapolationType = ExtrapolationType.Constant;
function.Components.Add(y);
function[1.0,1.0] = 2.0;
//get the value on a point that is defined in one dimension and not in the other.
Assert.AreEqual(2.0, function.Evaluate<double>(new VariableValueFilter<double>(x1, 1.0), new VariableValueFilter<double>(x2, 2.0)));
}
public void GetInterpolatedValues2ArgsFunctionDateTime()
{
IVariable<double> x = new Variable<double>("x");
IVariable t = new Variable<DateTime>("t");
IVariable<double> f1 = new Variable<double>("f1");
IFunction function = new Function("testfunction");
function.Arguments.Add(t);
function.Arguments.Add(x);
function.Components.Add(f1);
var tValue = DateTime.Now;
var tValues = new[] { tValue, tValue.AddSeconds(1), tValue.AddSeconds(2), tValue.AddSeconds(3) };
var xValues = new[] { 1.0, 2.0, 3.0 };
var fValues = new[,]
{
{100.0, 200.0, 300.0},
{1000.0, 2000.0, 3000.0},
{10000.0, 20000.0, 30000.0},
{100000.0, 200000.0, 300000.0}
};
function.SetValues(fValues,
new VariableValueFilter<DateTime>(t, tValues),
new VariableValueFilter<double>(x, xValues), new ComponentFilter(f1));
// now get interpolated value on 2d function
var value = function.Evaluate<double>(
new VariableValueFilter<double>(x, 2.5),
new VariableValueFilter<DateTime>(t, tValue.AddSeconds(1.5)));
Assert.AreEqual(13750, value);
var value1 = function.Evaluate<double>(
new VariableValueFilter<double>(x, 1.5),
new VariableValueFilter<DateTime>(t, tValue.AddSeconds(2.5)));
Assert.AreEqual(82500, value1);
var value2 = function.Evaluate<double>(
new VariableValueFilter<double>(x, 1.6),
new VariableValueFilter<DateTime>(t, tValue.AddSeconds(2.5)));
Assert.AreEqual(88000, value2);
}
private static ValueEval invoke(Function function, ValueEval xArray, ValueEval yArray)
{
ValueEval[] args = new ValueEval[] { xArray, yArray, };
return function.Evaluate(args, -1, (short)-1);
}
private static ValueEval Evaluate(Function instance, params double[] dArgs)
{
ValueEval[] evalArgs;
evalArgs = new ValueEval[dArgs.Length];
for (int i = 0; i < evalArgs.Length; i++)
{
evalArgs[i] = new NumberEval(dArgs[i]);
}
ValueEval r = instance.Evaluate(evalArgs, -1, (short)-1);
return r;
}
private static ValueEval Evaluate(Function oper, ValueEval[] args, int srcRowIx, int srcColIx)
{
return oper.Evaluate(args, srcRowIx, (short)srcColIx);
}
public void ThrowCorrectExceptionWhenVariableIsNotInArgumentsOfFunction()
{
var argument = new Variable<int>("x") { Values = { 0, 10, 20 } };
var component = new Variable<int>("y") { Values = { 3, 4, 5 } };
var function = new Function{ Name = "Pietje",Arguments = { argument }, Components = { component}};
//try to filter on an unknown argument. This is a common mistake
//should give a nice exception.
function.Evaluate<int>(new VariableValueFilter<double>(new Variable<double>{Name = "Kees"}, 2.0));
}
public void GetExtrapolatedValuesLinear1D()
{
IVariable<double> x = new Variable<double>("x");
IVariable<double> y = new Variable<double>("y");
IFunction function = new Function();
function.Arguments.Add(x);
function.Components.Add(y);
// set (fx, fy) values to (100.0, 200.0) for a combination of x and y values.
function.SetValues(
new[] { 100.0, 200.0, 300.0 },
new VariableValueFilter<double>(x, new[] { 1.0, 2.0, 3.0 }));
//Extrapolate linear
x.ExtrapolationType = ApproximationType.Linear;
//before the 1st argument value
Assert.AreEqual(50, function.Evaluate<double>(new VariableValueFilter<double>(x, 0.5)));
//after the las
Assert.AreEqual(350, function.Evaluate<double>(new VariableValueFilter<double>(x, 3.5)));
}
public void GetExtrapolatedValuesConstant1D()
{
IVariable<double> x = new Variable<double>("x");
IVariable<double> y = new Variable<double>("y");
IFunction function = new Function();
function.Arguments.Add(x);
function.Components.Add(y);
// set (fx, fy) values to (100.0, 200.0) for a combination of x and y values.
function.SetValues(
new[] { 100.0, 200.0, 300.0 },
new VariableValueFilter<double>(x, new[] { 1.0, 2.0, 3.0 }));
//No extrapolation
x.ExtrapolationType = ApproximationType.Constant;
//x0 < f.Arguments[0], extrapolation at begin is set to true
var value = function.Evaluate<double>(new VariableValueFilter<double>(x, 0.5));
Assert.AreEqual(100, value);
value = function.Evaluate<double>(new VariableValueFilter<double>(x, 3.5));
Assert.AreEqual(300, value);
}
/// <summary>
/// Calculates the integral of alpha function to be used in the A() method.
/// </summary>
/// <param name="t">Lower value defining integration interval.</param>
/// <param name="T">Upper value defining integration interval.</param>
/// <param name="alpha">Hull-White alpha parameter.</param>
/// <param name="sigma">Hull-White sigma parameter.</param>
/// <param name="zeroRateCurve">Zero rate curve.</param>
/// <returns>The integral of alpha function between t and T.</returns>
private static double AlphaInt(double t, double T, double alpha, double sigma, Function zeroRateCurve)
{
double firstTerm = zeroRateCurve.Evaluate(T) * T - zeroRateCurve.Evaluate(t) * t;
return firstTerm + sigma * sigma * (alpha * (T - t) - 2.0 * (Math.Exp(-alpha * t) - Math.Exp(-alpha * T))
+ 0.5 * (Math.Exp(-2.0 * alpha * t) - Math.Exp(-2.0 * alpha * T))) / (2.0 * Math.Pow(alpha, 3.0));
}
