callhedgestatistics.java

金融资产定价,随机过程,MONTE CARLO 模拟 JAVA 程序和文档资料

        mainWindow.jTextField7.setText("Risk free rate ="+r); 
        mainWindow.jTextField6.setText("Time to expiration (years) = "+Tc); 
        mainWindow.jTextField5.setText("Strike K = "+K);

        
        mainWindow.setTitle("Call-Hedge statistics");
        mainWindow.setBounds(5,50,670,500);
        mainWindow.jSplitPane2.setVisible(true);
        mainWindow.show();
    }


    // Variables declaration - do not modify//GEN-BEGIN:variables
    private javax.swing.JSlider jSlider4;
    private javax.swing.JSlider jSlider3;
    private javax.swing.JSlider jSlider2;
    private javax.swing.JSlider jSlider1;
    private javax.swing.JButton jButton2;
    private javax.swing.JButton jButton1;
    private javax.swing.JSlider jSlider14;
    private javax.swing.JSlider jSlider13;
    private javax.swing.JTextArea jTextArea2;
    private javax.swing.JSlider jSlider12;
    private javax.swing.JSlider jSlider11;
    private javax.swing.JTextArea jTextArea1;
    private javax.swing.JSlider jSlider10;
    private javax.swing.JScrollPane jScrollPane2;
    private javax.swing.JScrollPane jScrollPane1;
    private javax.swing.JCheckBox jCheckBox3;
    private javax.swing.JCheckBox jCheckBox2;
    private javax.swing.JCheckBox jCheckBox1;
    private javax.swing.JTextField jTextField15;
    private javax.swing.JTextField jTextField14;
    private javax.swing.JPanel jPanel4;
    private javax.swing.JTextField jTextField13;
    private javax.swing.JPanel jPanel3;
    private javax.swing.JTextField jTextField12;
    private javax.swing.JPanel jPanel2;
    private javax.swing.JTextField jTextField11;
    private javax.swing.JPanel jPanel1;
    private javax.swing.JTextField jTextField10;
    private javax.swing.JTextField jTextField9;
    private javax.swing.JTextField jTextField8;
    private javax.swing.JTextField jTextField7;
    private javax.swing.JTextField jTextField6;
    private javax.swing.JTextField jTextField5;
    private javax.swing.JTextField jTextField4;
    private javax.swing.JTextField jTextField3;
    private javax.swing.JTextField jTextField2;
    private javax.swing.JTextField jTextField1;
    private javax.swing.JLabel jLabel9;
    private javax.swing.JLabel jLabel8;
    private javax.swing.JLabel jLabel7;
    private javax.swing.JLabel jLabel6;
    private javax.swing.JLabel jLabel5;
    private javax.swing.JLabel jLabel4;
    private javax.swing.JLabel jLabel3;
    private javax.swing.JLabel jLabel2;
    private javax.swing.JLabel jLabel1;
    private javax.swing.JSlider jSlider9;
    private javax.swing.JSlider jSlider8;
    private javax.swing.JSlider jSlider7;
    private javax.swing.JProgressBar jProgressBar1;
    private javax.swing.JSplitPane jSplitPane2;
    private javax.swing.JSlider jSlider6;
    private javax.swing.JSplitPane jSplitPane1;
    private javax.swing.JSlider jSlider5;
    // End of variables declaration//GEN-END:variables

    static int nSignChange=20,  
               nPaths,
               nBranch,
               nHedgeTrades,
               triggerPercent,
               T;
    
    //note: nSignChange is irrelevant since the hedge computes inependent
    //price paths of the underlying. But it is needed for the asset constructor.
    
    
    static double S_0,
                  K,
                  Tc,
                  r,
                  q,
                  mu,
                  sigma,
                  dt,
                  fixed_trc,
                  prop_trc;
    
    static boolean minimum_variance_deltas,
                   monte_carlo_deltas,
                   quotient_deltas;

    
    static ConstantVolatilityAsset asset;
    static BlackScholesCall call;
    static Hedge periodic_hedge_AD,
                 reactive_hedge_AD,
                 periodic_hedge_MVD,
                 reactive_hedge_MVD,
                 periodic_hedge_MCD,
                 reactive_hedge_MCD,
                 periodic_hedge_QD,
                 reactive_hedge_QD;
    
    
    private void mainComputation()
    {
        CardLayout card=(CardLayout)jPanel1.getLayout();
        card.next(jSplitPane2.getParent());
        jPanel4.update(jPanel4.getGraphics());
        
        
        minimum_variance_deltas=jCheckBox1.isSelected();
        monte_carlo_deltas=jCheckBox2.isSelected();
        quotient_deltas=jCheckBox3.isSelected();
        
        asset=new ConstantVolatilityAsset(T,dt,nSignChange,S_0,r,q,mu,sigma);
        
        call=new BlackScholesCall(K,asset); 
        
        double price=call.discountedAnalyticPrice(0);

        
        //allocate the triggers for the hedge trades:
        TriggerPeriodic 
        periodic_trigger=new TriggerPeriodic(asset,nHedgeTrades);
        
        TriggerAtPercentChange
        percent_trigger=new TriggerAtPercentChange(asset,triggerPercent);
     
        
        /* allocate all the possible hedges:
         * AD  ... analytic deltas
         * MVD ... minimum variance deltas, 
         * MCD ... Monte Carlo deltas, 
         * QD  ... Monte Carlo deltas, 
         */
        
        // Analytic deltas
        periodic_hedge_AD=new 
        DeltaHedge(asset,call,periodic_trigger,Flag.A_DELTA, 
                   nBranch,fixed_trc,prop_trc);
        
        reactive_hedge_AD=new 
        DeltaHedge(asset,call,percent_trigger,Flag.A_DELTA, 
                   nBranch,fixed_trc,prop_trc);
        

        // Minimum variance deltas
        periodic_hedge_MVD=new 
        DeltaHedge(asset,call,periodic_trigger,Flag.MV_DELTA, 
                   nBranch,fixed_trc,prop_trc);
             
        reactive_hedge_MVD=new 
        DeltaHedge(asset,call,percent_trigger,Flag.MV_DELTA, 
                   nBranch,fixed_trc,prop_trc);
        

        // Monte Carlo deltas
        periodic_hedge_MCD=new 
        DeltaHedge(asset,call,periodic_trigger,Flag.MC_DELTA, 
                   nBranch,fixed_trc,prop_trc);
             
        reactive_hedge_MCD=new 
        DeltaHedge(asset,call,percent_trigger,Flag.MC_DELTA, 
                   nBranch,fixed_trc,prop_trc);
        
        periodic_hedge_QD=new 
        DeltaHedge(asset,call,periodic_trigger,Flag.MC_DELTA, 
                   nBranch,fixed_trc,prop_trc);
             
        reactive_hedge_QD=new 
        DeltaHedge(asset,call,percent_trigger,Flag.MC_DELTA, 
                   nBranch,fixed_trc,prop_trc);

        

        // compute the statistics and report the findings
        double   gain_mean,
                 gain_stdv,
                 max_borrowing_mean,
                 max_borrowing_stdv,
                 max_drawdown_mean,
                 max_drawdown_stdv,
                 nTrades_mean,             // number of trades
                 nTrades_stdv;

        double[][] mstdv;    //mean and standard deviation
        
        
        
        String Str;
        
        double
          //price rounded to 3 decimals
          p=FinMath.round(price,3),
          //fixed transaction cost rounded to 3 decimals
          ftrc=FinMath.round(fixed_trc,3), 
          //proportional transaction cost rounded to 3 decimals
          ptrc=FinMath.round(prop_trc,3); 
          
        
        Str="CALL HEDGE MEAN AND STANDARD DEVIATION AS PERCENT OF PRICE:\n"+
            "Price: "+p+"\n"+
            "Fixed transaction costs: "+ftrc+"\n"+
            "Proportional transaction costs: "+ptrc+"\n"+
            "Periodic hedge rebalances a fixed number of equidistant times.\n"+
            "Reactive hedge rebalance is triggered by a "+triggerPercent+
            " price change in the underlying.\n\n\n";
            
        jTextArea2.append(Str);
        jTextArea2.update(jTextArea2.getGraphics());
        
        
        processHedge(price, periodic_hedge_AD,
                     "Periodic hedge, analytic deltas:\n\n",
                     "Hedging: periodic hedge, analytic deltas");
        processHedge(price, reactive_hedge_AD,
                     "Reactive hedge, analytic deltas:\n\n",
                     "Hedging: reactive hedge, analytic deltas");
        
        if(minimum_variance_deltas){
        processHedge(price, periodic_hedge_MVD,
                     "Periodic hedge, minimum variance deltas:\n\n",
                     "Hedging: periodic hedge, minimum variance deltas");
        processHedge(price, reactive_hedge_MVD,
                     "Reactive hedge, minimum variance deltas:\n\n",
                     "Hedging: reactive hedge, minimum variance deltas"); 
        } // end if
        
        
        if(quotient_deltas){
        processHedge(price, periodic_hedge_QD,
                     "Periodic hedge, quotient deltas:\n\n",
                     "Hedging: periodic hedge, quotient deltas");
        processHedge(price, reactive_hedge_QD,
                     "Reactive hedge, quotient deltas:\n\n",
                     "Hedging: reactive hedge, quotient deltas");  
        } // end if
        
        
        if(monte_carlo_deltas){
        processHedge(price, periodic_hedge_MCD,
                     "Periodic hedge, Monte Carlo deltas:\n\n",
                     "Hedging: periodic hedge, Monte Carlo deltas");
        processHedge(price, reactive_hedge_MCD,
                     "Reactive hedge, Monte Carlo deltas:\n\n",
                     "Hedging: reactive hedge, Monte Carlo deltas");
        } // end if

            
        
    } //end mainComputation
        


    
    
    
    // compute the statistic and append report to text field
    void processHedge
    (double price, Hedge hedge, String title, String message)
    {
        //progress report
        jTextField15.setText(message);
        jTextField15.update(jTextField15.getGraphics());
        
        // mstdv[0]=vector of means, mstdv[1]=vector of standard deviations
        // of the following quantities in coordinate []:
        //   gain = [0]
        //   maximum borrowing = [1]
        //   maximum drawdown = [2]
        //   number of trades = [5]
        double[][]
        mstdv=hedge.hedgeStatistics().
                    meanAndStandardDeviation(nPaths,20,jProgressBar1);
        

        // hedge statistics mean and standard deviation rounded to one decimal
        double
        gain_mean=FinMath.round(100*mstdv[0][0]/price,1),
        gain_stdv=FinMath.round(100*mstdv[1][0]/price,1),
        max_borrowing_mean=FinMath.round(mstdv[0][1],1),
        max_borrowing_stdv=FinMath.round(mstdv[1][1],1),
        max_drawdown_mean=FinMath.round(mstdv[0][2],1),
        max_drawdown_stdv=FinMath.round(mstdv[1][2],1),
        nTrades_mean=FinMath.round(mstdv[0][4],1),
        nTrades_stdv=FinMath.round(mstdv[1][4],1);

        String 
        str="\nGains: mean="+gain_mean+"% of price"+
            "\nGains: standard deviation="+gain_stdv+"% of price"+
            "\nMaximum borrowing: mean="+max_borrowing_mean+
            "\nMaximum borrowing: standard deviation="+max_borrowing_stdv+
            "\nMaximum drawdown: mean="+max_drawdown_mean+
            "\nMaximum drawdown: standard deviation="+max_drawdown_stdv+
            "\nNumber of trades: mean="+nTrades_mean+
            "\nNumber of trades: standard deviation="+nTrades_stdv+
            "\n\n\n";
            
        jTextArea2.append(title+str);
        jTextArea2.update(jTextArea2.getGraphics()); 
        
    } // end processHedge
                 
                 
} //end CallHedgeStatistics