bswpntest.java

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

/*
 * BSWPNTest.java
 *
 * Created on December 23, 2002, 8:36 PM
 */

package Libor.LiborDerivatives;

import Libor.LiborProcess.*;
import Statistics.*;
import Triggers.*;
import LinAlg.*;
import Graphics.*;


/**
 *
 * @author  java
 */
public class BSWPNTest {
    
    /** Creates a new instance of BSWPNTest */
    public BSWPNTest() {
    }

    
    
    
  
/*******************************************************************************
 *
 *                        TEST PROGRAM
 *
 ******************************************************************************/

       
     /** <p>Test program. Allocates a Libor process of dimension 
      *  <code>n=20</code> and a semiannual 10 non call 2 Bermudan swaption.
      *  Then computes the exercise boundary from the naive exercise strategy
      *  at time <code>t=8</code>.</p>
      */
     public static void main(String[] args)
     {
         // Libor process setup
         final int n=20, p=4;          
         final double kappa=0.04;   // strike rate
         boolean verbose=true;
       
         // Libor parameter sample 
         final LMM_Parameters lmmParams=new LMM_Parameters(n,LMM_Parameters.JR);
         final LiborProcess LP=new LiborProcess(lmmParams);
       
         final BermudanSwaption bswpn=new BermudanSwaption(LP,p,kappa);
         
         final int nPaths=50000;
       
         double before=System.currentTimeMillis(), after, time;
         final CvxTrigger cvx=new CvxTrigger(bswpn,nPaths/2,verbose);
         
         // grid computation at t=8
         final int t=14, nGrid=100, length=600/nGrid; 
         double min=1.0, max=0,
                a0=0.5, a1=1.0, 
                b0=0.04, b1=0.09,
                alphaMax=0, betaMax=0;
         
         final double[][] f=new double[nGrid][nGrid];
         for(int i=0;i<nGrid;i++)
         for(int j=0;j<nGrid;j++){
             
             double alpha=a0+i*(a1-a0)/nGrid,
                    beta=b0+j*(b1-b0)/nGrid;
             double[] v={alpha,beta};
             f[i][j]=-cvx.forwardExercisePayoff(t,v);
             if(f[i][j]<min)min=f[i][j];
             if(f[i][j]>max){
                 max=f[i][j]; 
                 alphaMax=alpha; betaMax=beta;
             }
         }
         
         final double mmin=min, mmax=max;
         System.out.println
         ("\nmin="+min+", max="+max+"\na="+alphaMax+", b="+betaMax);
         final
         java.awt.Color[] colors={ java.awt.Color.black,
                                   java.awt.Color.darkGray,
                                   java.awt.Color.gray,
                                   java.awt.Color.blue,
                                   java.awt.Color.green,
                                   java.awt.Color.magenta,
                                   java.awt.Color.cyan,
                                   java.awt.Color.red,
                                   java.awt.Color.orange,
                                   java.awt.Color.yellow,
                                   java.awt.Color.white
         };
         
         java.awt.Canvas canvas=new java.awt.Canvas(){
             
             public void paint(java.awt.Graphics g)
             {
                 for(int i=0;i<nGrid;i++)
                 for(int j=0;j<nGrid;j++){
                     
                     int s=0;
                     while(f[i][j]>0.07*mmin+0.93*mmax+s*0.007*(mmax-mmin))
                     s++;
                     g.setColor(colors[s]);
                     if(f[i][j]>0.9999*mmax)g.setColor(java.awt.Color.black);
                     g.fillRect(i*length,800-j*length,length,length);
                 }
             } // end paint
         }; // end canvas
         
         javax.swing.JFrame frame=new javax.swing.JFrame();
         frame.getContentPane().add(canvas);
         frame.setDefaultCloseOperation(javax.swing.JFrame.EXIT_ON_CLOSE);
         frame.setBounds(50,50,700,700);
         frame.pack();
         frame.setVisible(true);            
             
    } // end main
                   

                  
                  
} // end BermudanSwaption