示例#1
0
        // Series I expansion
        public double SeriesICall(double S, double K, double rf, double q, double T, double v0, double rho, double theta, double kappa, double sigma)
        {
            // The "J" integrals
            double J1 = J(rho, theta, kappa, T, v0, 1);
            double J3 = J(rho, theta, kappa, T, v0, 3);
            double J4 = J(rho, theta, kappa, T, v0, 4);

            // Time average of the deterministic volatility
            double v = theta + (v0 - theta) * (1.0 - Math.Exp(-kappa * T)) / (kappa * T);

            // X and Z required for the ratios of Black Scholes derivatives
            double X = Math.Log(S * Math.Exp((rf - q) * T) / K);
            double Z = v * T;

            // The ratios of Black Scholes derivatives
            double R20 = R(2, 0, X, Z, T);
            double R11 = R(1, 1, X, Z, T);
            double R12 = R(1, 2, X, Z, T);
            double R22 = R(2, 2, X, Z, T);

            // Black Scholes call price evaluated at v
            BlackScholes BS = new BlackScholes();
            double       c  = BS.BSC(S, K, rf, q, v, T);

            // Black Scholes vega evaluated at v
            double cv = BS.BSV(S, K, rf, q, v, T);

            // Series I volatility of volatility expansion for the implied volatility
            return(c + sigma / T * J1 * R11 * cv
                   + sigma * sigma * (J3 * R20 / T / T + J4 * R12 / T + J1 * J1 * R22 / T / T / 2) * cv);
        }
示例#2
0
        // Series II expansion
        public double[] SeriesIICall(double S, double K, double rf, double q, double T, double v0, double rho, double theta, double kappa, double sigma)
        {
            // The "J" integrals
            double J1 = J(rho, theta, kappa, T, v0, 1);
            double J3 = J(rho, theta, kappa, T, v0, 3);
            double J4 = J(rho, theta, kappa, T, v0, 4);

            // Time average of the deterministic volatility
            double v = theta + (v0 - theta) * (1.0 - Math.Exp(-kappa * T)) / (kappa * T);

            // X and Z required for the ratios of Black Scholes derivatives
            double X = Math.Log(S * Math.Exp((rf - q) * T) / K);
            double Z = v * T;

            // The ratios of Black Scholes derivatives
            double R20 = R(2, 0, X, Z, T);
            double R11 = R(1, 1, X, Z, T);
            double R12 = R(1, 2, X, Z, T);
            double R22 = R(2, 2, X, Z, T);

            // Series II volatility of volatility expansion for the implied volatility
            double iv = v + sigma / T * J1 * R11
                        + sigma * sigma * (J3 * R20 / T / T + J4 * R12 / T + 0.5 / T / T * J1 * J1 * (R22 - R11 * R11 * R20));

            // Series II call price
            BlackScholes BS    = new BlackScholes();
            double       Price = BS.BSC(S, K, rf, q, iv, T);

            // The series volatility
            double ivx = Math.Sqrt(iv);

            // Return the price and the volatility
            double[] output = new double[2] {
                Price, ivx
            };
            return(output);
        }
示例#3
0
        private void GenerateLewisTable_MouseClick(object sender, MouseEventArgs e)
        {
            double S       = 100.0;             // Spot Price
            double T       = 0.25;              // Maturity in Years
            double rf      = 0.0;               // Interest Rate
            double q       = 0.0;               // Dividend yield
            string PutCall = "C";               // "P"ut or "Call"
            int    trap    = 1;                 // 1="Little Trap" characteristic function

            OpSet opset = new OpSet();

            opset.S       = S;
            opset.T       = T;
            opset.r       = rf;
            opset.q       = q;
            opset.PutCall = PutCall;
            opset.trap    = trap;

            double kappa  = 4.0;                        // Heston Parameter
            double theta  = 0.09 / 4.0;                 // Heston Parameter
            double sigma  = 0.1;                        // Heston Parameter: Volatility of Variance
            double v0     = 0.0225;                     // Heston Parameter: Current Variance
            double rho    = -0.5;                       // Heston Parameter: Correlation
            double lambda = 0.0;                        // Heston Parameter

            HParam param = new HParam();

            param.kappa  = kappa;
            param.theta  = theta;
            param.sigma  = sigma;
            param.v0     = v0;
            param.rho    = rho;
            param.lambda = lambda;

            int NK = 7;

            double[] K = new double[7]          // Strikes
            {
                70.0, 80.0, 90.0, 100.0, 110.0, 120.0, 130.0
            };

            // Time average of the deterministic variance and volatility
            double vol = param.theta + (param.v0 - param.theta) * (1.0 - Math.Exp(-param.kappa * T)) / (param.kappa * T);
            double IV  = Math.Sqrt(vol);

            // Classes
            BlackScholes  BS = new BlackScholes();
            NewtonCotes   NC = new NewtonCotes();
            Lewis         L  = new Lewis();
            BisectionAlgo BA = new BisectionAlgo();

            // Table 3.3.1 on Page 81 of Lewis (2001)
            double[] SeriesIPrice  = new double[NK];        // Series I price and implied vol
            double[] IVI           = new double[NK];
            double[] SeriesIIPrice = new double[NK];        // Series II price and implied vol
            double[] IVII          = new double[NK];
            double[] HPrice        = new double[NK];        // Exact Heston price and implied vol
            double[] IVe           = new double[NK];
            double[] BSPrice       = new double[NK];        // Black Scholes price

            // Bisection algorithm settings
            double lo      = 0.01;
            double hi      = 2.0;
            double Tol     = 1.0e-10;
            int    MaxIter = 10000;

            // Newton Cotes settings
            int    method = 3;
            double a      = 1.0e-10;
            double b      = 100.0;
            int    N      = 10000;

            double[] SeriesII = new double[2];
            for (int k = 0; k <= NK - 1; k++)
            {
                // Generate the prices and implied vols
                opset.K          = K[k];
                SeriesIPrice[k]  = L.SeriesICall(S, K[k], rf, q, T, v0, rho, theta, kappa, sigma);
                IVI[k]           = BA.BisecBSIV(PutCall, S, K[k], rf, q, T, lo, hi, SeriesIPrice[k], Tol, MaxIter);
                SeriesII         = L.SeriesIICall(S, K[k], rf, q, T, v0, rho, theta, kappa, sigma);
                SeriesIIPrice[k] = SeriesII[0];
                IVII[k]          = SeriesII[1];
                HPrice[k]        = NC.HestonPriceNewtonCotes(param, opset, method, a, b, N);
                IVe[k]           = BA.BisecBSIV(PutCall, S, K[k], rf, q, T, lo, hi, HPrice[k], Tol, MaxIter);
                BSPrice[k]       = BS.BSC(S, K[k], rf, q, vol, T);

                // Write to the List Boxes
                Strike.Items.Add(K[k]);
                ExactPrice.Items.Add(Math.Round(HPrice[k], 6));
                IVExact.Items.Add(Math.Round(100 * IVe[k], 2));
                SeriesICall.Items.Add(Math.Round(SeriesIPrice[k], 6));
                IV1.Items.Add(Math.Round(100 * IVI[k], 2));
                SeriesIICall.Items.Add(Math.Round(SeriesIIPrice[k], 6));
                IV2.Items.Add(Math.Round(100 * IVII[k], 2));
                BlackScholesPrice.Items.Add(Math.Round(BSPrice[k], 6));
                IVBS.Items.Add(Math.Round(100 * IV, 2));
            }
        }