C# Function.Evaluate方法代码示例

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