public Grid computeNextGeneration(Grid currentGeneration) { logGridDetails(currentGeneration); Grid nextGeneration = new Grid(currentGeneration.size()); for (int x = 0; x < currentGeneration.size(); x++) { for (int y = 0; y < currentGeneration.size(); y++) { Grid.Cell presentCell = currentGeneration.cellAt(x, y); Grid.Cell futureCell = nextGeneration.cellAt(x, y); int livingNeighborsCount = currentGeneration.countLivingNeighbors(x, y); logCellDetails(x, y, presentCell, livingNeighborsCount); applyRules(presentCell, futureCell, livingNeighborsCount); } } generation++; return nextGeneration; }
/** * @param args Command arguments. * @throws GridException If failed. */ public static void main(String[] args) throws GridException { // Starts grid. Grid grid = args.length == 0 ? G.start() : G.start(args[0]); try { // Create portfolio. GridCredit[] portfolio = new GridCredit[5000]; Random rnd = new Random(); // Generate some test portfolio items. for (int i = 0; i < portfolio.length; i++) { portfolio[i] = new GridCredit( 50000 * rnd.nextDouble(), // Credit amount. rnd.nextInt(1000), // Credit term in days. rnd.nextDouble() / 10, // APR. rnd.nextDouble() / 20 + 0.02 // EDF. ); } // Forecast horizon in days. int horizon = 365; // Number of Monte-Carlo iterations. int iter = 10000; // Percentile. double percentile = 0.95; // Mark the stopwatch. long start = System.currentTimeMillis(); // Calculate credit risk and print it out. // As you can see the grid enabling is completely hidden from the caller // and it is fully transparent to him. In fact, the caller is never directly // aware if method was executed just locally or on the 100s of grid nodes. // Credit risk crdRisk is the minimal amount that creditor has to have // available to cover possible defaults. double crdRisk = grid.reduce( SPREAD, closures(grid.size(), portfolio, horizon, iter, percentile), new R1<Double, Double>() { /** Collected values sum. */ private double sum; /** Collected values count. */ private int count; /** {@inheritDoc} */ @Override public boolean collect(Double e) { sum += e; count++; return true; } /** {@inheritDoc} */ @Override public Double apply() { return sum / count; } }); X.println( "Credit risk [crdRisk=" + crdRisk + ", duration=" + (System.currentTimeMillis() - start) + "ms]"); } // We specifically don't do any error handling here to // simplify the example. Real application may want to // add error handling and application specific recovery. finally { // Stops grid. G.stop(true); } }