Data Manipulating component: which provides classes for manipulating the input/output data as well as the classes required for pricing the option. The input/output data for the challenge will be provided as xml descriptors. This xml files will be generated using the schema in the "compile/config" directory. We will describe the elements in this schema below, however for better understanding you are advised to refer to the schema itself.

Option Pricing Componenet: which provides a sample source code for european option pricing algorithm and other algorithm related utilities.

Testing component: in which we demonstrate how we can manipulate the input/output data for the challenge and compute the prices for some testcases. Note : Although participants are free to develop their own system, they must comply with the input/output data patterns described in this section.

The pricing engine is an engine which churns out bags of tasks of core algorithm using the Monte carlo API available in the ProActive Grid Middleware. The monte carlo based european option pricing engine to compute the price and the greeks for the european basket options. The engine can be constructed as follows,

/**
 * Constructor for the monte carlo based european option pricing engine
 *
* @param descrFile	the deployment descriptor so that engine can launch the algorithm tasks.
* @param vn_name	the virtual node name of the worker
* @param master_vn_name	the name of virtual master node
*/
public MCEuropeanPricingEngine(final File descrFile, String vn_name, String master_vn_name)

and the monte carlo based algoritm is implemented as a bag-of-task application and constructed as follows,

/**
 * The constructor to create the instance of monte carlo based algorithm's task.
  * Such tasks are launched by the engine.
 *
 * @param basketParams	the market constants, as provided in the testcases
* @param testCase		individual test case
* @param testCaseAssetPool	the basket for the testcase
* @param correlationMatrix	the correlation matrix for the assets in the basket
* @param mciter		the number of monte carlo simulation per task, can be controlled for accurary and
 speed
*/
public MCEuropeanPricingAlgorithm(BasketParams basketParams, TestCase testCase,
       AssetPool testCaseAssetPool, Matrix correlationMatrix, long mciter)

Note that, we here provide only the source code for computing the price/premium of the basket option. However, the participants will need to write the code for computing greeks intelligently. We have provided the mathematical models for computing greeks in the problem statement which is available on the GridPlugtests website.

The monte carlo based basket option is a collection of the parameters required for the algorithms. This package provides an abstract implementation of a basket option. Each basket has an abstract pricing engine which computes its price and the other greeks. The european basket option class extends this asbtract class and assigns the monte carlo based pricing engine to itself. It can be constructed as follows.

/**
* 	The constructor takes the market constants in the basketParams, the correlation matrix for the
 assets in the
*  basket in the corMatrix, the test case parameters and the asset pool in the basket
*/
public MCEuropeanBasketOption(BasketParams basketParams, Matrix corMatrix, TestCase testCase,
       AssetPool subAssetPool)

The pricing engine can be set to the basket using this method,

/**
* Sets the pricing engine to the option
*
* @param mcEuroEngine monte carlo based pricing engine to price european options
*/
public void setPricingEngine(final MCEuropeanPricingEngine mcEuroEngine)

In the third subpackage, there are several utilities provided that can be re-used in your system

Testing component In the plugtest.test package, we provide a simple example of:

The source code of the main test case challenge is as follows,

       // load the data from testcases descriptor file
       final TestCases testCases = LoadData.loadTestCases(testCasesDescriptorFile);

       // load the asset pool from the assetpool descriptor file
       final AssetPool assetPool = LoadData.loadAssetPool(assetPoolDescriptorFile);

       // load the correlation matrix from the correlation matrix descriptor file
       final CorrelationMatrix corrMatrix =
 LoadData.loadCorrMatrix(correlationMatrixDescriptorFile);

       // get the fixed parameters from the test cases
       final BasketParams basketParams = testCases.getBasketParams();

       // get the correlation descriptor in a jama.Matrix format
       final Matrix matCorrelation = ProcessData.parseCorrelationDescriptor(corrMatrix);

       /**
        * Create a monte carlo based european option pricing engine
        * it will price an euroean/barrier option using monte carlo based methods.
        * The workers and master's virtual names can be given as arguments otherwise are assigned
        * default values.
        * Since engine deploys the application in the grid setting, we have to provide
        * the GCM deployment descriptor file to it.
        */
       MCEuropeanPricingEngine mcEngine = new MCEuropeanPricingEngine(deploymentDescriptorFile,
 vn_name,
           master_vn_name);

       long startTime = System.currentTimeMillis();

       MCEuropeanBasketOption mcEuroBsk = new MCEuropeanBasketOption(basketParams);
            // Now, lets set the monte carlo based pricing engine to the basket
       mcEuroBsk.setPricingEngine(mcEngine);

       // initiate the Monte Carlo API and hence the ProActive runtime
       mcEuroBsk.initMC();

       // process each test case
       for (int i = 0; i < testCases.getTestCaseCount(); i++) {

           /**
            * We first need to construct the basket option out of the global asset pool.
            * As the testcase includes the indices of the assets from this global pool,
            * we must extract the assets from it before processing it.
            */
           testCaseAssetPool = ProcessData.extractAssetPool(assetPool,
 testCases.getTestCase(i).getBasket());

           /**
            * We also need to extract submatrix from the global correlation matrix.
            * The same basket of indices is used to get this submatrix.
            */
           testCaseCorrMatrix = ProcessData.extractCorrelationMatrix(matCorrelation, testCases
                   .getTestCase(i).getBasket());
           /**
            * With all the paramters, market constants such as interest rate, time per interal and
 monte carlo
            * simulations in basketParams, the correlation matrix for the sub set of assets,
            * other parameters associated with testcase such as the execution type, option type,
 pay off types and time
            * to maturity and, of course, the assets in the basket,
            * we construct the baskey option using the MCEuropeanBasketOption constructor.
            */
           mcEuroBsk.set(testCaseCorrMatrix, testCases.getTestCase(i), testCaseAssetPool);

           // Fire the engine to price the option using monte carlo based algorithm
           mcEuroBsk.calculateMC();

           // Get the result for this testcase and update the final results
           results.addResult(mcEuroBsk.getResult());
       }

       long stopTime = System.currentTimeMillis();
       metrics.setStartTime(startTime);
       metrics.setStopTime(stopTime);
       metrics.setWallTime((stopTime - startTime) / 1000);

       // update the metrics for final results.
       results.setMetrics(metrics); //

       // store the final results in the out put descriptor file
       DisplayData.printResults(results, new FileOutputStream(FINAL_RESULTS_DESCRIPTOR));