Esempio n. 1
0
 private List<? extends BoxAndWhiskerCategoryDataset> generateSubSingleBenchmarkScoreSummary(
     ProblemBenchmarkResult problemBenchmarkResult) {
   List<DefaultBoxAndWhiskerCategoryDataset> datasetList =
       new ArrayList<DefaultBoxAndWhiskerCategoryDataset>(CHARTED_SCORE_LEVEL_SIZE);
   for (SingleBenchmarkResult singleBenchmarkResult :
       problemBenchmarkResult.getSingleBenchmarkResultList()) {
     List<List<Double>> valueListList = new ArrayList<List<Double>>(CHARTED_SCORE_LEVEL_SIZE);
     for (SubSingleBenchmarkResult subSingleBenchmarkResult :
         singleBenchmarkResult.getSubSingleBenchmarkResultList()) {
       if (subSingleBenchmarkResult.hasAllSuccess() && subSingleBenchmarkResult.isInitialized()) {
         double[] levelValues =
             ScoreUtils.extractLevelDoubles(subSingleBenchmarkResult.getAverageScore());
         for (int i = 0; i < levelValues.length && i < CHARTED_SCORE_LEVEL_SIZE; i++) {
           if (i >= valueListList.size()) {
             valueListList.add(new ArrayList<Double>(singleBenchmarkResult.getSuccessCount()));
           }
           valueListList.get(i).add(levelValues[i]);
         }
       }
     }
     for (int i = 0; i < valueListList.size() && i < CHARTED_SCORE_LEVEL_SIZE; i++) {
       if (i >= datasetList.size()) {
         datasetList.add(new DefaultBoxAndWhiskerCategoryDataset());
       }
       SolverBenchmarkResult solverBenchmarkResult =
           singleBenchmarkResult.getSolverBenchmarkResult();
       datasetList
           .get(i)
           .add(
               valueListList.get(i),
               solverBenchmarkResult.getName(),
               solverBenchmarkResult
                   + " - "
                   + solverBenchmarkResult.getSubSingleCount()
                   + " run(s)");
     }
   }
   return datasetList;
 }
 @Override
 public void writeGraphFiles(BenchmarkReport benchmarkReport) {
   List<XYPlot> plotList = new ArrayList<XYPlot>(BenchmarkReport.CHARTED_SCORE_LEVEL_SIZE);
   int seriesIndex = 0;
   for (SingleBenchmarkResult singleBenchmarkResult :
       problemBenchmarkResult.getSingleBenchmarkResultList()) {
     List<XYSeries> seriesList = new ArrayList<XYSeries>(BenchmarkReport.CHARTED_SCORE_LEVEL_SIZE);
     // No direct ascending lines between 2 points, but a stepping line instead
     XYItemRenderer renderer = new XYStepRenderer();
     if (singleBenchmarkResult.isSuccess()) {
       BestScoreSingleStatistic singleStatistic =
           (BestScoreSingleStatistic)
               singleBenchmarkResult.getSingleStatistic(problemStatisticType);
       for (BestScoreStatisticPoint point : singleStatistic.getPointList()) {
         long timeMillisSpent = point.getTimeMillisSpent();
         double[] levelValues = ScoreUtils.extractLevelDoubles(point.getScore());
         for (int i = 0;
             i < levelValues.length && i < BenchmarkReport.CHARTED_SCORE_LEVEL_SIZE;
             i++) {
           if (i >= seriesList.size()) {
             seriesList.add(
                 new XYSeries(
                     singleBenchmarkResult
                         .getSolverBenchmarkResult()
                         .getNameWithFavoriteSuffix()));
           }
           seriesList.get(i).add(timeMillisSpent, levelValues[i]);
         }
       }
       // TODO if startingSolution is initialized and no improvement is made, a horizontal line
       // should be shown
       // Draw a horizontal line from the last new best step to how long the solver actually ran
       long timeMillisSpent = singleBenchmarkResult.getTimeMillisSpent();
       double[] bestScoreLevels = ScoreUtils.extractLevelDoubles(singleBenchmarkResult.getScore());
       for (int i = 0;
           i < bestScoreLevels.length && i < BenchmarkReport.CHARTED_SCORE_LEVEL_SIZE;
           i++) {
         if (i >= seriesList.size()) {
           seriesList.add(
               new XYSeries(
                   singleBenchmarkResult.getSolverBenchmarkResult().getNameWithFavoriteSuffix()));
         }
         seriesList.get(i).add(timeMillisSpent, bestScoreLevels[i]);
       }
       if (singleStatistic.getPointList().size() <= 1) {
         // Workaround for
         // https://sourceforge.net/tracker/?func=detail&aid=3387330&group_id=15494&atid=115494
         renderer = new StandardXYItemRenderer(StandardXYItemRenderer.SHAPES_AND_LINES);
       }
     }
     if (singleBenchmarkResult.getSolverBenchmarkResult().isFavorite()) {
       // Make the favorite more obvious
       renderer.setSeriesStroke(0, new BasicStroke(2.0f));
     }
     for (int i = 0; i < seriesList.size(); i++) {
       if (i >= plotList.size()) {
         plotList.add(createPlot(benchmarkReport, i));
       }
       plotList.get(i).setDataset(seriesIndex, new XYSeriesCollection(seriesList.get(i)));
       plotList.get(i).setRenderer(seriesIndex, renderer);
     }
     seriesIndex++;
   }
   graphFileList = new ArrayList<File>(plotList.size());
   for (int scoreLevelIndex = 0; scoreLevelIndex < plotList.size(); scoreLevelIndex++) {
     JFreeChart chart =
         new JFreeChart(
             problemBenchmarkResult.getName()
                 + " best score level "
                 + scoreLevelIndex
                 + " statistic",
             JFreeChart.DEFAULT_TITLE_FONT,
             plotList.get(scoreLevelIndex),
             true);
     graphFileList.add(
         writeChartToImageFile(
             chart,
             problemBenchmarkResult.getName() + "BestScoreStatisticLevel" + scoreLevelIndex));
   }
 }