Inheritance: QLNet.StochasticProcess
        // ProcessArr 생성용 //외부사용함.
        public static StochasticProcessArray buildProcess(UnderlyingInfo underInfo)
        {
            Date today = Settings.evaluationDate();

            List<Handle<Quote>> underlyingH = new List<Handle<Quote>>(); 

            // bootstrap the yield/dividend/vol curves

            CorrelationSetting corrSetting = new CorrelationSetting();

            List<Underlying> underlyings = underInfo.underlyings();

            Matrix CorrMatrix = corrSetting.correlationMatrix(today);

            List<StochasticProcess1D> process1DList = new List<StochasticProcess1D>();

            for (int i = 0; i < underlyings.Count ; i++)
            {
                process1DList.Add(ProcessFactory.buildProcess1D(underlyings[i]));
                
            }

            StochasticProcessArray processArr = new StochasticProcessArray(process1DList, CorrMatrix);

            return processArr;

        }
Beispiel #2
0
        public void testMultiPathGenerator()
        {
            //("Testing n-D path generation against cached values...");

            //SavedSettings backup;

            Settings.setEvaluationDate(new Date(26,4,2005));

            Handle<Quote> x0=new Handle<Quote> (new SimpleQuote(100.0));
            Handle<YieldTermStructure> r =new Handle<YieldTermStructure> (Utilities.flatRate(0.05, new Actual360()));
            Handle<YieldTermStructure> q=new Handle<YieldTermStructure> (Utilities.flatRate(0.02, new Actual360()));
            Handle<BlackVolTermStructure> sigma=new Handle<BlackVolTermStructure> (Utilities.flatVol(0.20, new Actual360()));

            Matrix correlation=new Matrix(3,3);
            correlation[0,0] = 1.0; correlation[0,1] = 0.9; correlation[0,2] = 0.7;
            correlation[1,0] = 0.9; correlation[1,1] = 1.0; correlation[1,2] = 0.4;
            correlation[2,0] = 0.7; correlation[2,1] = 0.4; correlation[2,2] = 1.0;

            List<StochasticProcess1D>  processes = new List<StochasticProcess1D>(3);
            StochasticProcess process;

            processes.Add(new BlackScholesMertonProcess(x0,q,r,sigma));
            processes.Add(new BlackScholesMertonProcess(x0,q,r,sigma));
            processes.Add(new BlackScholesMertonProcess(x0,q,r,sigma));
            process = new StochasticProcessArray(processes,correlation);
            // commented values must be used when Halley's correction is enabled
            double[] result1 = {
                188.2235868185,
                270.6713069569,
                113.0431145652 };
            // Real result1[] = {
            //     188.2235869273,
            //     270.6713071508,
            //     113.0431145652 };
            double[] result1a = {
                64.89105742957,
                45.12494404804,
                108.0475146914 };
            // Real result1a[] = {
            //     64.89105739157,
            //     45.12494401537,
            //     108.0475146914 };
            testMultiple(process, "Black-Scholes", result1, result1a);

            processes[0] = new GeometricBrownianMotionProcess(100.0, 0.03, 0.20);
            processes[1] = new GeometricBrownianMotionProcess(100.0, 0.03, 0.20);
            processes[2] = new GeometricBrownianMotionProcess(100.0, 0.03, 0.20);
            process = new StochasticProcessArray(processes,correlation);
            double[] result2 = {
                174.8266131680,
                237.2692443633,
                119.1168555440 };
            // Real result2[] = {
            //     174.8266132344,
            //     237.2692444869,
            //     119.1168555605 };
            double[] result2a = {
                57.69082393020,
                38.50016862915,
                116.4056510107 };
            // Real result2a[] = {
            //     57.69082387657,
            //     38.50016858691,
            //     116.4056510107 };
            testMultiple(process, "geometric Brownian", result2, result2a);

            processes[0] = new OrnsteinUhlenbeckProcess(0.1, 0.20);
            processes[1] = new OrnsteinUhlenbeckProcess(0.1, 0.20);
            processes[2] = new OrnsteinUhlenbeckProcess(0.1, 0.20);
            process = new StochasticProcessArray(processes,correlation);
            double[] result3 = {
                0.2942058437284,
                0.5525006418386,
                0.02650931054575 };
            double[] result3a = {
                -0.2942058437284,
                -0.5525006418386,
                -0.02650931054575 };
            testMultiple(process, "Ornstein-Uhlenbeck", result3, result3a);

            processes[0] = new SquareRootProcess(0.1, 0.1, 0.20, 10.0);
            processes[1] = new SquareRootProcess(0.1, 0.1, 0.20, 10.0);
            processes[2] = new SquareRootProcess(0.1, 0.1, 0.20, 10.0);
            process = new StochasticProcessArray(processes,correlation);
            double[] result4 = {
                4.279510844897,
                4.943783503533,
                3.590930385958 };
            double[] result4a = {
                2.763967737724,
                2.226487196647,
                3.503859264341 };
            testMultiple(process, "square-root", result4, result4a);
        }
 public void setUnderlying(UnderlyingInfo under)
 {
     this.processArr_ = ProcessFactory.buildProcess(under);
     this.pathGenerator(under);
 }