/** * 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)); }