Beispiel #1
0
        /// <summary>
        /// Evaluates the function.
        /// </summary>
        /// <param name="context">The evaluation context instance.</param>
        /// <param name="args">The function arguments.</param>
        /// <returns>The result value of the function evaluation.</returns>
        public override EvaluationValue Evaluate(EvaluationContext context, params IFunctionParameter[] args)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }
            if (args == null)
            {
                throw new ArgumentNullException("args");
            }
            IFunction function = DataType.SubsetFunction;

            if ((function.Evaluate(
                     context,
                     new EvaluationValue(args[0], args[0].GetType(context)), new EvaluationValue(args[1], args[1].GetType(context))) == EvaluationValue.True) &&
                (function.Evaluate(
                     context,
                     new EvaluationValue(args[1], args[1].GetType(context)), new EvaluationValue(args[0], args[0].GetType(context))) == EvaluationValue.True))
            {
                return(EvaluationValue.True);
            }
            else
            {
                return(EvaluationValue.False);
            }
        }
Beispiel #2
0
        public static IFunction Integrate(IFunction func, double xMin, double xMax, int granularity)
        {
            var    points = new List <Point>();
            double xDiff  = xMax - xMin;
            double delta  = xDiff / granularity;

            double x     = xMin;
            double yPrev = 0;

            for (int i = 0; i < granularity; ++i)
            {
                double xa = x;
                double xb = x + delta;

                double ya = func.Evaluate(xa);
                double yb = func.Evaluate(xb);

                double area = delta * (ya + yb) / 2;
                double y    = yPrev + area;
                points.Add(new Point(x, y));

                x    += delta;
                yPrev = y;
            }

            return(new LinearInterpolation(points));
        }
Beispiel #3
0
        /// <summary>
        /// Evaluates the function.
        /// </summary>
        /// <param name="context">The evaluation context instance.</param>
        /// <param name="args">The function arguments.</param>
        /// <returns>The result value of the function evaluation.</returns>
        public override EvaluationValue Evaluate(EvaluationContext context, params IFunctionParameter[] args)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }
            if (args == null)
            {
                throw new ArgumentNullException("args");
            }

            var       retBag      = new BagValue(DataType);
            IFunction functionDup = DataType.IsInFunction;

            foreach (object par1 in args[0].Elements)
            {
                EvaluationValue retVal = functionDup.Evaluate(context, new EvaluationValue(par1, args[0].GetType(context)), retBag);
                if (!retVal.BoolValue)
                {
                    retBag.Add(new EvaluationValue(par1, args[0].GetType(context)));
                }
            }
            foreach (object par2 in args[1].Elements)
            {
                EvaluationValue retVal = functionDup.Evaluate(context, new EvaluationValue(par2, args[1].GetType(context)), retBag);
                if (!retVal.BoolValue)
                {
                    retBag.Add(new EvaluationValue(par2, args[1].GetType(context)));
                }
            }
            return(new EvaluationValue(retBag, DataType));
        }
Beispiel #4
0
        private double Integrate(int index, double a, double b)
        {
            IFunction function = functions[index];

            if (!IsInvalid(function.Evaluate(a)) && !IsInvalid(function.Evaluate(b)))
            {
                return(integrator.Integrate(function, a, b).value);
            }

            return(0);
        }
Beispiel #5
0
        public double Integrate(IFunction <double> fx, Range <double> range)
        {
            var x0  = range.Start;
            var sum = 0d;

            foreach (var x1 in range.All.Skip(1))
            {
                sum += TrapezoidalRule(x1, x0, fx.Evaluate(x1), fx.Evaluate(x0));
                x0   = x1;
            }
            return(sum);
        }
Beispiel #6
0
        protected override double EstimateIntegralOver(IFunction <double> fx, double x0, double x2)
        {
            // Simpson's method
            var H   = x2 - x0;
            var h   = 0.5 * H;
            var x1  = x0 + h;
            var fx0 = fx.Evaluate(x0);
            var fx1 = fx.Evaluate(x1);
            var fx2 = fx.Evaluate(x2);

            return((h / 3) * (fx0 + 4 * fx1 + fx2));
        }
Beispiel #7
0
        /// <summary>
        /// Method called by the EvaluationEngine to evaluate the function.
        /// </summary>
        /// <param name="context">The evaluation context instance.</param>
        /// <param name="args">The IFuctionParameters that will be used as arguments to the function.</param>
        /// <returns></returns>
        public override EvaluationValue Evaluate(EvaluationContext context, params IFunctionParameter[] args)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }
            if (args == null)
            {
                throw new ArgumentNullException("args");
            }
            IFunction function = args[0].GetFunction(0);

            if (!args[1].IsBag)
            {
                return(EvaluationValue.False);
            }
            var retVal = new BagValue(args[1].GetType(context));

            foreach (var par in args[1].Elements)
            {
                retVal.Add(
                    function.Evaluate(
                        context,
                        new EvaluationValue(par, args[1].GetType(context))));
            }
            return(new EvaluationValue(retVal, args[1].GetType(context)));
        }
Beispiel #8
0
        public HestonCallSimulationOptimizationProblem(EquityCalibrationData equityCalData, Vector matBound, Vector strikeBound)
            : base(equityCalData, matBound, strikeBound)
        {
            //this.dyFunc = equityCalData.dyFunc;
            this.dyFunc = CallEstimator.IstantaneousDividendYield(equityCalData);
            this.zrFunc = equityCalData.zrFunc;

            // Generates common random numbers
            I       = (int)Math.Ceiling(cpmd.Maturity[Range.End] / dt);
            epsilon = new Matrix(I, 2 * N);
            NewRandomNumbers();

            // Precalculates istantaneous growth rates
            growth = new Vector(I);
            for (int i = 0; i < I; i++)
            {
                double t    = i * dt;
                double zr_t = zrFunc.Evaluate(t);
                growth[i] = zr_t + FunctionHelper.Partial(zr_t, zrFunc, new Vector()
                {
                    t
                }, 0, dt) * t - dyFunc.Evaluate(t);
            }

            Console.WriteLine("Heston Simulation Calibration: Paths=" + N);
        }
Beispiel #9
0
        /// <summary>
        /// Method called by the EvaluationEngine to evaluate the function.
        /// </summary>
        /// <param name="context">The evaluation context instance.</param>
        /// <param name="args">The IFuctionParameters that will be used as arguments to the function.</param>
        /// <returns></returns>
        public override EvaluationValue Evaluate(EvaluationContext context, params IFunctionParameter[] args)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }
            if (args == null)
            {
                throw new ArgumentNullException("args");
            }
            IFunction function = args[0].GetFunction(0);

            if (!Equals(function.Returns, DataTypeDescriptor.Boolean))
            {
                return(EvaluationValue.Indeterminate);
            }

            foreach (var par1 in args[1].Elements)
            {
                foreach (var par2 in args[2].Elements)
                {
                    EvaluationValue retVal = function.Evaluate(
                        context,
                        new EvaluationValue(par1, args[1].GetType(context)), new EvaluationValue(par2, args[2].GetType(context)));
                    if (!retVal.BoolValue)
                    {
                        return(EvaluationValue.False);
                    }
                }
            }
            return(EvaluationValue.True);
        }
Beispiel #10
0
        /// <summary>
        /// Evaluates the function.
        /// </summary>
        /// <param name="context">The evaluation context instance.</param>
        /// <param name="args">The function arguments.</param>
        /// <returns>The result value of the function evaluation.</returns>
        public override EvaluationValue Evaluate(EvaluationContext context, params IFunctionParameter[] args)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }
            if (args == null)
            {
                throw new ArgumentNullException("args");
            }
            IFunction function = DataType.EqualFunction;

            foreach (object par1 in args[0].Elements)
            {
                foreach (object par2 in args[1].Elements)
                {
                    EvaluationValue retVal = function.Evaluate(
                        context,
                        new EvaluationValue(par1, args[0].GetType(context)),
                        new EvaluationValue(par2, args[1].GetType(context)));
                    if (retVal.BoolValue)
                    {
                        return(EvaluationValue.True);
                    }
                }
            }
            return(EvaluationValue.False);
        }
Beispiel #11
0
 /// <summary>
 /// Evaluates the function.
 /// </summary>
 /// <param name="context">The evaluation context instance.</param>
 /// <param name="args">The function arguments.</param>
 /// <returns>The result value of the function evaluation.</returns>
 public override EvaluationValue Evaluate(EvaluationContext context, params IFunctionParameter[] args)
 {
     if (context == null)
     {
         throw new ArgumentNullException("context");
     }
     if (args == null)
     {
         throw new ArgumentNullException("args");
     }
     if (args[1].IsBag)
     {
         IFunction function = DataType.EqualFunction;
         foreach (object value in args[1].Elements)
         {
             if (function.Evaluate(
                     context,
                     new EvaluationValue(args[0], args[0].GetType(context)),
                     new EvaluationValue(value, args[1].GetType(context))) == EvaluationValue.True)
             {
                 return(EvaluationValue.True);
             }
         }
     }
     return(EvaluationValue.False);
 }
Beispiel #12
0
        /// <summary>
        /// Method called by the EvaluationEngine to evaluate the function.
        /// </summary>
        /// <param name="context">The evaluation context instance.</param>
        /// <param name="args">The IFuctionParameters that will be used as arguments to the function.</param>
        /// <returns></returns>
        public override EvaluationValue Evaluate(EvaluationContext context, params IFunctionParameter[] args)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }
            if (args == null)
            {
                throw new ArgumentNullException("args");
            }
            IFunction function = args[0].GetFunction(0);

            foreach (var par1 in args[1].Elements)
            {
                bool hasFound = false;
                foreach (var par2 in args[2].Elements)
                {
                    EvaluationValue retVal = function.Evaluate(
                        context,
                        new EvaluationValue(par1, args[1].GetType(context)),
                        new EvaluationValue(par2, args[2].GetType(context)));
                    if (retVal.BoolValue)
                    {
                        hasFound = true;
                        break;
                    }
                }
                if (!hasFound)
                {
                    return(EvaluationValue.False);
                }
            }
            return(EvaluationValue.True);
        }
Beispiel #13
0
        /// <summary>
        /// Method called by the EvaluationEngine to evaluate the function.
        /// </summary>
        /// <param name="context">The evaluation context instance.</param>
        /// <param name="args">The IFuctionParameters that will be used as arguments to the function.</param>
        /// <returns></returns>
        public override EvaluationValue Evaluate(EvaluationContext context, params IFunctionParameter[] args)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }
            if (args == null)
            {
                throw new ArgumentNullException("args");
            }
            IFunction function = args[0].GetFunction(0);
            var       value    = new EvaluationValue(args[1], args[1].GetType(context));

            foreach (var par in args[2].Elements)
            {
                EvaluationValue retVal = function.Evaluate(
                    context, value,
                    new EvaluationValue(par, args[2].GetType(context)));
                if (retVal.BoolValue)
                {
                    return(retVal);
                }
            }
            return(EvaluationValue.False);
        }
Beispiel #14
0
        private bool UnsatisfiedRoot(IFunction function, double i1, double d1, double i2, double d2)
        {
            if (Math.Sign(d1) != Math.Sign(d2))
            {
                double root = EMath.Geometry.Line.Root(i1, d1, i2, d2);

                if (!((decimal)root >= (decimal)i1 && (decimal)root <= (decimal)i2 &&
                      Math.Abs(function.Evaluate(root)) < rootTolerance))
                {
                    Debug.Log(Math.Abs(function.Evaluate(root)));
                    Debug.Log("Unsatisfied Root!!!");
                    return(true);
                }
            }

            return(false);
        }
Beispiel #15
0
        public double Integrate(IFunction <double> fx, Range <double> range)
        {
            var x0  = range.Start;
            var sum = 0d;

            foreach (var x2 in range.All.Skip(1))
            {
                var h   = x2 - x0;
                var x1  = x0 + 0.5 * h;
                var fx0 = fx.Evaluate(x0);
                var fx1 = fx.Evaluate(x1);
                var fx2 = fx.Evaluate(x2);

                sum += (h / 6) * (fx0 + 4 * fx1 + fx2);
                x0   = x2;
            }
            return(sum);
        }
        private Matrix LocVolMatrixFromImpliedVol(CallPriceMarketData Hdataset, IFunction impVol, out Vector locVolMat, out Vector locVolStr)
        {
            int    nmat    = calibrationSettings.LocalVolatilityMaturities;
            int    nstrike = calibrationSettings.LocalVolatilityStrikes;
            double lastMat = Hdataset.Maturity[Range.End];
            double lastStr = Hdataset.Strike[Range.End];

            locVolMat = Vector.Linspace(Hdataset.Maturity[0], lastMat, nmat);
            locVolStr = Vector.Linspace(Hdataset.Strike[0], lastStr, nstrike);
            Matrix locVolMatrix = new Matrix(nmat, nstrike);

            Integrate integrate = new Integrate(this);
            double    sigma, dSigmadk, num, y, den, avgGrowthRate;
            Vector    x = new Vector(2);

            for (int i = 0; i < nmat; i++)
            {
                avgGrowthRate = integrate.AdaptLobatto(0.0, locVolMat[i]);

                int j = 0;
                x[0]               = locVolMat[i];
                x[1]               = locVolStr[j];
                sigma              = impVol.Evaluate(x);
                dSigmadk           = impVol.Partial(x, 1);
                num                = Math.Pow(sigma, 2) + 2.0 * sigma * x[0] * impVol.Partial(x, 0);
                den                = 1.0;
                locVolMatrix[i, j] = Math.Sqrt(num / den);

                // The rest of the cycle.
                for (j = 1; j < nstrike; j++)
                {
                    x[1]     = locVolStr[j];
                    sigma    = impVol.Evaluate(x);
                    dSigmadk = impVol.Partial(x, 1);
                    num      = Math.Pow(sigma, 2) + 2.0 * sigma * x[0] *
                               (impVol.Partial(x, 0) + avgGrowthRate * x[1] * dSigmadk);
                    y   = Math.Log(locVolStr[j] / Hdataset.S0) + avgGrowthRate;
                    den = System.Math.Pow(1.0 - x[1] * y * dSigmadk / sigma, 2) + x[1] * sigma * x[0] *
                          (dSigmadk - 0.25 * x[1] * sigma * x[0] * dSigmadk * dSigmadk + x[1] * impVol.Partial2(x, 1));
                    locVolMatrix[i, j] = Math.Sqrt(num / den);
                }
            }
            return(locVolMatrix);
        }
Beispiel #17
0
        internal void RegisterFunction(IFunction function)
        {
            this.CheckForExistingFunctionName(function.Name);

            this.registeredFunctions.Add(function.Name, (p, a) =>
            {
                function.Variables = a;

                return(function.Evaluate(p, this.options));
            });
        }
Beispiel #18
0
        private void AddFunctionLine(IFunction function, double i, double ih, double b, Material material,
                                     List <Point> points, int index)
        {
            double d = function.Evaluate(i);

            if (IsInvalid(d))
            {
                SetInvalidContinuity(points, index);

                return;
            }

            Point start = GetPoint(i, d);

            points.Add(start);

            double dh = function.Evaluate(ih);

            if (IsInvalid(dh))
            {
                SetInvalidContinuity(ih, b, points, index);

                return;
            }

            Point end = GetPoint(ih, dh);

            if ((decimal)ih >= (decimal)b)
            {
                points.Add(end);
            }

            if (UnsatisfiedRoot(function, i, d, ih, dh))
            {
                SetInvalidContinuity(ih, b, points, index);

                return;
            }

            PlotLine(start, end, material);
        }
        public double Evaluate(double x)
        {
            if (_validateDomain)
            {
                if (!_domain.IsValid(x))
                {
                    throw new ArgumentOutOfRangeException($"{x} does not fall within domain {_domain}.");
                }
            }

            return(_function.Evaluate(x));
        }
Beispiel #20
0
        /// <summary>
        /// Linear Differential Equation of the form y` = P(t)y + G(t)
        /// </summary>
        /// <param name="Pt">function of t to multiply with y</param>
        /// <param name="Gt">function of t to add to result</param>
        /// <returns>differential equation</returns>
        public static FirstOrderDE <T> Linear(IFunction <T> Pt, IFunction <T> Gt)
        {
            var calc = Pt.Calculator ?? Gt.Calculator;

            return(new FirstOrderDE <T>(
                       new NativeFunction2 <T>(calc, ((T, T)args) => {
                var x = args.Item1;
                var y = args.Item2;
                return calc.Subtract(
                    calc.Multiply(Pt.Evaluate(x), y),
                    Gt.Evaluate(x)
                    );
            })
        static double Mean(IFunction f, double a, double b)
        {
            double sum = 0;
            int    N   = 20;
            double h   = b - a;
            double dt  = h / N;

            for (int z = 0; z < N; z++)
            {
                sum += f.Evaluate(a + (dt * z)) * dt;
            }
            return(sum / h);
        }
        /* not tochable */                                     //----------------------------------------------------------------------------------
        private void Button1_Click(object sender, EventArgs e) /*plot derivative*/
        {
            if (coordinates != null)
            {
                foreach (var item in coordinates)
                {
                    coordinates.Remove(item);
                }
            }
            /*plot on the pictureBox*/
            zoomValue     = trackBar1.Value;
            orgX          = pictureBox1.Width / 2;
            orgY          = pictureBox1.Height / 2;
            derivativePen = new Pen(Brushes.Red, 2.0F);

            /* plot Newton's derivative with pen purple */
            derivativePen = new Pen(Brushes.Purple, 2.0F);
            for (float i = -orgX; i <= pictureBox1.Height / 2; i += 0.01f)
            {
                double h  = 0.01;
                double Y1 = ((root.Evaluate(i + h) - root.Evaluate(i)) / h); //f(x+h) - f(x) / h
                double Y2 = ((root.Evaluate(i + (0.01) + h) - root.Evaluate(i + (0.01))) / h);
                Y1 = ((-1) * Y1 * zoomValue) + orgY;
                Y2 = ((-1) * Y2 * zoomValue) + orgY;
                double X  = (zoomValue * i) + orgX;
                double X2 = (zoomValue * i) + orgX + 0.01f;
                if (Y1 <= pictureBox1.Height && Y2 <= pictureBox1.Height && Y1 >= 0 && Y2 >= 0)
                {
                    g.DrawLine(derivativePen, (float)X, (float)Y1, (float)X2, (float)Y2);
                }
            }
            /* plot the Analytical derivative and plotting the tree*/
            IFunction p;

            p = root.derivative();
            DrawBinaryTree(p);
            derivativePen = new Pen(Brushes.Green, 2.0F);
            for (float i = -orgX; i <= pictureBox1.Height; i += 0.01f)
            {
                double X  = (double)i;
                float  Y  = (float)p.Evaluate(X) * zoomValue;
                float  Y2 = ((float)p.Evaluate(i + 0.1) * zoomValue);
                if (Y <= pictureBox1.Height / 2 && Y2 <= pictureBox1.Height / 2 && Y >= -200 && Y2 >= -200)
                {
                    g.DrawLine(derivativePen, (float)(X * zoomValue) + orgX, orgY - Y, (float)(orgX + (X * zoomValue) + 0.1), orgY - Y2);
                }
            }
        }
Beispiel #23
0
        public DefiniteIntegral Integrate(IFunction function, double a, double b)
        {
            double c1 = (b + a) / 2.0;
            double c2 = (b - a) / 2.0;

            double sum = 0;

            for (int i = 0; i < polynomials.n; i++)
            {
                sum += polynomials.weights[i] * function.Evaluate(c1 + c2 * polynomials.roots[i]);
            }

            return(new DefiniteIntegral(c2 * sum));
        }
Beispiel #24
0
        public static IFunction Differentiate(IFunction func, double xMin, double xMax, int granularity)
        {
            var    points = new List <Point>();
            double xDiff  = xMax - xMin;
            double delta  = xDiff / granularity;

            double x = xMin;

            for (int i = 0; i < granularity; ++i)
            {
                double xa = x - delta / 2;
                double xb = x + delta / 2;

                double ya = func.Evaluate(xa);
                double yb = func.Evaluate(xb);

                double slope = (yb - ya) / (xb - xa);
                points.Add(new Point(x, slope));

                x += delta;
            }

            return(new LinearInterpolation(points));
        }
Beispiel #25
0
        protected static void SaveCsv(string name, IFunction <double> approx, IFunction <double> real, Range <double> range)
        {
            if (!Directory.Exists(".data"))
            {
                Directory.CreateDirectory(".data");
            }

            using (var writer = new StreamWriter(Path.Combine(".data", $"{name}.xy.csv"))) {
                writer.WriteLine("x, y, ~y");
                foreach (var x in range.All)
                {
                    writer.WriteLine($"{x},{real.Evaluate(x)},{approx.Evaluate(x)}");
                }
            }
        }
Beispiel #26
0
        protected static void SaveCsv(string name, IFunction <double> approx, Func <double, double> real)
        {
            if (!Directory.Exists(".data"))
            {
                Directory.CreateDirectory(".data");
            }

            using (var writer = new StreamWriter(Path.Combine(".data", $"{name}.xy.csv"))) {
                writer.WriteLine("x, y, y`");
                for (var x = -10d; x <= 10d; x += 0.1d)
                {
                    writer.WriteLine($"{x},{real(x)},{approx.Evaluate(x)}");
                }
            }
        }
Beispiel #27
0
 /// <summary>
 /// Returns the Strike vector embedded in the volatility matrix.
 /// The method manage the convention that if rates/strikes [defined in .ColumnValues fields] are equal to -1,
 /// the strike vector is ATM and must be derived from the term structure.
 /// </summary>
 /// <param name="normalVol">The matrix</param>
 /// <param name="zr">The term structure.</param>
 /// <returns>The strike vector.</returns>
 static Vector GetStrikes(MatrixMarketData normalVol, IFunction zr)
 {
     if (IsAtmMatrix(normalVol))
     {
         // builds the vector of ATM strikes
         var s = new Vector(normalVol.RowValues.Length);
         for (int j = 0; j < s.Length; j++)
         {
             s[j] = zr.Evaluate(normalVol.RowValues[j]);
         }
         return(s);
     }
     else
     {
         return(normalVol.ColumnValues);
     }
 }
Beispiel #28
0
        /// <summary>
        /// Registers the supplied <paramref name="function"/> for use within compiling and evaluating an <see cref="Expression"/>.
        /// </summary>
        /// <param name="function">The <see cref="IFunction"/> to perform the function evaluation.</param>
        /// <param name="force">Whether to forcefully override any existing function.</param>
        public void RegisterFunction(IFunction function, bool force = false)
        {
            if (function is null)
            {
                throw new ArgumentNullException(nameof(function));
            }

            this.RegisterFunction(
                function.Name,
                (p, a) =>
            {
                function.Variables = a;

                return(function.Evaluate(p, this));
            },
                force);
        }
        internal static Matrix ToMatrix(IFunction func)
        {
            int    n   = 20;
            double ub  = 5;
            var    sup = func as ISupport1D;

            if (sup != null)
            {
                ub = sup.Support[1];
            }
            var mat = new Matrix(n, 2);

            for (int i = 0; i < n; i++)
            {
                double x = i * ub / n;
                mat[i, 0] = x;
                mat[i, 1] = func.Evaluate(x);
            }
            return(mat);
        }
        public void RegisterFunction(IFunction function, bool force = false)
        {
            ExecFunction exec = new ExecFunction((p, a, c) =>
            {
                return(function.Evaluate(p, a, c));
            });


            if (force)
            {
                this[function.Name] = exec;
            }
            else if (!this.ContainsKey(function.Name))
            {
                this.Add(function.Name, exec);
            }
            else
            {
                throw new FunctionNameAlreadyRegisteredException(function.Name);
            }
        }
 static double Mean(IFunction f, double a, double b)
 {
     double sum = 0;
     int N = 20;
     double h = b - a;
     double dt = h / N;
     for (int z = 0; z < N; z++)
         sum += f.Evaluate(a + (dt * z)) * dt;
     return sum / h;
 }
Beispiel #32
0
		/// <summary>
		/// Evaluates a function and also validates it's return value and parameter data types
		/// </summary>
		/// <param name="context">The evaluation context instance.</param>
		/// <param name="functionInstance">The function to call</param>
		/// <param name="arguments">The function arguments</param>
		/// <returns>The return value of the function</returns>
		public static EvaluationValue EvaluateFunction(EvaluationContext context, IFunction functionInstance, params IFunctionParameter[] arguments)
		{
			if (context == null) throw new ArgumentNullException("context");
			// If the caller is in a missing attribute state the function should not be called
			if (context.IsMissingAttribute)
			{
				context.Trace("There's a missing attribute in the parameters"); 
				return EvaluationValue.Indeterminate;
			}
			else
			{
				// Validate function defined arguments
				int functionArgumentIdx;
				for (functionArgumentIdx = 0; functionArgumentIdx < functionInstance.Arguments.Length; functionArgumentIdx++)
				{
					// Validate the value is not an Indeterminate value
					if (arguments[functionArgumentIdx] is EvaluationValue &&
						((EvaluationValue)arguments[functionArgumentIdx]).IsIndeterminate)
					{
						if (!context.IsMissingAttribute)
						{
							context.ProcessingError = true;
						}
						context.Trace("There's a parameter with Indeterminate value");
						return EvaluationValue.Indeterminate;
					}

					// Compare the function and the value data type
					if (((functionInstance.Arguments[functionArgumentIdx] != arguments[functionArgumentIdx].GetType(context)) &&
						((functionInstance.Arguments[functionArgumentIdx] != DataTypeDescriptor.Bag) && (arguments[functionArgumentIdx] is BagValue))))
					{
						context.ProcessingError = true;
						context.Trace("There's a parameter with an invalid datatype"); 
						return EvaluationValue.Indeterminate;
					}
				}

				//If the function supports variable arguments, the last datatype is used to validate the
				//rest of the parameters
				if (functionInstance.VarArgs)
				{
					functionArgumentIdx--;
					for (int argumentValueIdx = functionArgumentIdx; argumentValueIdx < arguments.Length; argumentValueIdx++)
					{
						// Validate the value is not an Indeterminate value
						if (arguments[argumentValueIdx] is EvaluationValue && ((EvaluationValue)arguments[argumentValueIdx]).IsIndeterminate)
						{
							if (!context.IsMissingAttribute)
							{
								context.ProcessingError = true;
							}
							context.Trace("There's a parameter with Indeterminate value"); 
							return EvaluationValue.Indeterminate;
						}

						// Compare the function and the value data type
						if ((functionInstance.Arguments[functionArgumentIdx] != arguments[argumentValueIdx].GetType(context)) &&
							((arguments[argumentValueIdx] is BagValue) && (functionInstance.Arguments[functionArgumentIdx] != DataTypeDescriptor.Bag)))
						{
							context.ProcessingError = true;
							context.Trace("There's a parameter with an invalid datatype"); 
							return EvaluationValue.Indeterminate;
						}
					}
				}

				var sb = new StringBuilder();

				// Call the function in a controlled evironment to capture any exception
				try
				{
					sb.Append(functionInstance.Id);
					sb.Append("( ");
					bool isFirst = true;
					foreach (IFunctionParameter param in arguments)
					{
						if (isFirst)
						{
							isFirst = false;
						}
						else
						{
							sb.Append(", ");
						}
						sb.Append(param.ToString());
					}
					sb.Append(" )");
					sb.Append(" = ");

					EvaluationValue returnValue = functionInstance.Evaluate(context, arguments);

					sb.Append(returnValue.ToString());
					context.Trace(sb.ToString());

					return returnValue;
				}
				catch (EvaluationException e)
				{
					context.Trace(sb.ToString());
					context.ProcessingError = true;
					context.Trace("Error: {0}", e.Message); 
					return EvaluationValue.Indeterminate;
				}
			}
		}
Beispiel #33
0
 internal static Matrix ToMatrix(IFunction func)
 {
     int n = 20;
     double ub=5;
     var sup = func as ISupport1D;
     if (sup != null)
         ub = sup.Support[1];
     var mat = new Matrix(n,2);
     for (int i = 0; i < n; i++)
     {
         double x = i*ub / n;
         mat[i, 0] = x;
         mat[i, 1] = func.Evaluate(x);
     }
     return mat;
 }
        public HestonCallSimulationOptimizationProblem(EquityCalibrationData equityCalData, Vector matBound, Vector strikeBound)
            : base(equityCalData,matBound,strikeBound)
        {
            //this.dyFunc = equityCalData.dyFunc;
            this.dyFunc = CallEstimator.IstantaneousDividendYield(equityCalData);
            this.zrFunc = equityCalData.zrFunc;

            // Generates common random numbers
            I = (int)Math.Ceiling(cpmd.Maturity[Range.End] / dt);
            epsilon = new Matrix(I, 2*N);
            NewRandomNumbers();

            // Precalculates istantaneous growth rates
            growth = new Vector(I);
            for (int i = 0; i < I; i++)
            {
                double t = i * dt;
                double zr_t = zrFunc.Evaluate(t);
                growth[i] = zr_t + FunctionHelper.Partial(zr_t,zrFunc, new Vector() { t }, 0, dt) * t - dyFunc.Evaluate(t);
            }

            Console.WriteLine("Heston Simulation Calibration: Paths=" + N);
        }
Beispiel #35
0
		public static double LogAverageFactor(double y, IFunction func, Vector x)
		{
			return (y == func.Evaluate(x)) ? 0.0 : Double.NegativeInfinity;
		}
Beispiel #36
0
        private Matrix LocVolMatrixFromImpliedVol(CallPriceMarketData Hdataset, IFunction impVol, out Vector locVolMat, out Vector locVolStr)
        {
            int nmat = calibrationSettings.LocalVolatilityMaturities;
            int nstrike = calibrationSettings.LocalVolatilityStrikes;
            double lastMat = Hdataset.Maturity[Range.End];
            double lastStr = Hdataset.Strike[Range.End];
            locVolMat = Vector.Linspace(Hdataset.Maturity[0], lastMat, nmat);
            locVolStr = Vector.Linspace(Hdataset.Strike[0], lastStr, nstrike);
            Matrix locVolMatrix = new Matrix(nmat, nstrike);

            Integrate integrate = new Integrate(this);
            double sigma, dSigmadk, num, y, den, avgGrowthRate;
            Vector x = new Vector(2);
            for (int i = 0; i < nmat; i++)
            {
                avgGrowthRate = integrate.AdaptLobatto(0.0, locVolMat[i]);

                int j = 0;
                x[0] = locVolMat[i];
                x[1] = locVolStr[j];
                sigma = impVol.Evaluate(x);
                dSigmadk = impVol.Partial(x, 1);
                num = Math.Pow(sigma, 2) + 2.0 * sigma * x[0] * impVol.Partial(x, 0);
                den = 1.0;
                locVolMatrix[i, j] = Math.Sqrt(num / den);

                // The rest of the cycle.
                for (j = 1; j < nstrike; j++)
                {
                    x[1] = locVolStr[j];
                    sigma = impVol.Evaluate(x);
                    dSigmadk = impVol.Partial(x, 1);
                    num = Math.Pow(sigma, 2) + 2.0 * sigma * x[0] *
                        (impVol.Partial(x, 0) + avgGrowthRate * x[1] * dSigmadk);
                    y = Math.Log(locVolStr[j] / Hdataset.S0) + avgGrowthRate;
                    den = System.Math.Pow(1.0 - x[1] * y * dSigmadk / sigma, 2) + x[1] * sigma * x[0] *
                        (dSigmadk - 0.25 * x[1] * sigma * x[0] * dSigmadk * dSigmadk + x[1] * impVol.Partial2(x, 1));
                    locVolMatrix[i, j] = Math.Sqrt(num / den);
                }
            }
            return locVolMatrix;
        }