Package org.drools.planner.benchmark.core

Examples of org.drools.planner.benchmark.core.SolverBenchmark

66
67
68
69
70
71
72
73
74
75
76
77
78
79
    // Builder methods
    // ************************************************************************

    public SolverBenchmark buildSolverBenchmark(DefaultPlannerBenchmark plannerBenchmark) {
        validate();
        SolverBenchmark solverBenchmark = new SolverBenchmark(plannerBenchmark);
        solverBenchmark.setName(name);
        solverBenchmark.setSolverConfig(solverConfig);
        solverBenchmark.setSingleBenchmarkList(new ArrayList<SingleBenchmark>());
        List<ProblemBenchmark> problemBenchmarkList = problemBenchmarksConfig
                .buildProblemBenchmarkList(plannerBenchmark, solverBenchmark);
        solverBenchmark.setProblemBenchmarkList(problemBenchmarkList);
        return solverBenchmark;
    }
View Full Code Here
197
198
199
200
201
202
203
204
205
206
207
        List<SolverBenchmark> solverBenchmarkList = new ArrayList<SolverBenchmark>(solverBenchmarkConfigList.size());
        List<ProblemBenchmark> unifiedProblemBenchmarkList = new ArrayList<ProblemBenchmark>();
        plannerBenchmark.setUnifiedProblemBenchmarkList(unifiedProblemBenchmarkList);
        for (SolverBenchmarkConfig solverBenchmarkConfig : solverBenchmarkConfigList) {
            SolverBenchmark solverBenchmark = solverBenchmarkConfig.buildSolverBenchmark(plannerBenchmark);
            solverBenchmarkList.add(solverBenchmark);
        }
        plannerBenchmark.setSolverBenchmarkList(solverBenchmarkList);
        return plannerBenchmark;
    }
View Full Code Here
199
200
201
202
203
204
205
206
207
208
209
        plannerBenchmark.setWarmUpTimeMillisSpend(calculateWarmUpTimeMillisSpendTotal());

        List<SolverBenchmark> solverBenchmarkList = new ArrayList<SolverBenchmark>(solverBenchmarkConfigList.size());
        List<ProblemBenchmark> unifiedProblemBenchmarkList = new ArrayList<ProblemBenchmark>();
        for (SolverBenchmarkConfig solverBenchmarkConfig : solverBenchmarkConfigList) {
            SolverBenchmark solverBenchmark = solverBenchmarkConfig.buildSolverBenchmark(
                    unifiedProblemBenchmarkList);
            solverBenchmarkList.add(solverBenchmark);
        }
        plannerBenchmark.setSolverBenchmarkList(solverBenchmarkList);
        plannerBenchmark.setUnifiedProblemBenchmarkList(unifiedProblemBenchmarkList);
View Full Code Here
63
64
65
66
67
68
69
70
71
72
73
74
75
76
    // ************************************************************************
    // Builder methods
    // ************************************************************************

    public SolverBenchmark buildSolverBenchmark(List<ProblemBenchmark> unifiedProblemBenchmarkList) {
        SolverBenchmark solverBenchmark = new SolverBenchmark();
        solverBenchmark.setName(name);
        solverBenchmark.setSolverConfig(solverConfig);
        solverBenchmark.setPlannerBenchmarkResultList(new ArrayList<PlannerBenchmarkResult>());
        List<ProblemBenchmark> problemBenchmarkList = problemBenchmarksConfig
                .buildProblemBenchmarkList(unifiedProblemBenchmarkList, solverBenchmark);
        solverBenchmark.setProblemBenchmarkList(problemBenchmarkList);
        return solverBenchmark;
    }
View Full Code Here
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
    @Test
    public void normal() {
        TotalRankSolverBenchmarkRankingWeightFactory factory = new TotalRankSolverBenchmarkRankingWeightFactory();
        List<SolverBenchmark> solverBenchmarkList = new ArrayList<SolverBenchmark>();
        SolverBenchmark a = new SolverBenchmark(null);
        List<SingleBenchmark> aSingleBenchmarkList = new ArrayList<SingleBenchmark>();
        addSingleBenchmark(aSingleBenchmarkList, -1000, -40, -1000);
        addSingleBenchmark(aSingleBenchmarkList, -300, -40, -1000);
        addSingleBenchmark(aSingleBenchmarkList, -40, -40, -1000);
        a.setSingleBenchmarkList(aSingleBenchmarkList);
        a.benchmarkingEnded();
        solverBenchmarkList.add(a);
        SolverBenchmark b = new SolverBenchmark(null);
        List<SingleBenchmark> bSingleBenchmarkList = new ArrayList<SingleBenchmark>();
        addSingleBenchmark(bSingleBenchmarkList, -2000, -30, -2000); // Loses vs a
        addSingleBenchmark(bSingleBenchmarkList, -200, -30, -2000); // Wins vs a
        addSingleBenchmark(bSingleBenchmarkList, -30, -30, -2000); // Wins vs a
        b.setSingleBenchmarkList(bSingleBenchmarkList);
        b.benchmarkingEnded();
        solverBenchmarkList.add(b);

        Comparable aWeight = factory.createRankingWeight(solverBenchmarkList, a);
        Comparable bWeight = factory.createRankingWeight(solverBenchmarkList, b);
View Full Code Here
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
    @Test
    public void equalCount() {
        TotalRankSolverBenchmarkRankingWeightFactory factory = new TotalRankSolverBenchmarkRankingWeightFactory();
        List<SolverBenchmark> solverBenchmarkList = new ArrayList<SolverBenchmark>();
        SolverBenchmark a = new SolverBenchmark(null);
        List<SingleBenchmark> aSingleBenchmarkList = new ArrayList<SingleBenchmark>();
        addSingleBenchmark(aSingleBenchmarkList, -5000, -90, -5000);
        addSingleBenchmark(aSingleBenchmarkList, -900, -90, -5000);
        addSingleBenchmark(aSingleBenchmarkList, -90, -90, -5000);
        a.setSingleBenchmarkList(aSingleBenchmarkList); // 0 wins - 1 equals - 5 losses
        a.benchmarkingEnded();
        solverBenchmarkList.add(a);
        SolverBenchmark b = new SolverBenchmark(null);
        List<SingleBenchmark> bSingleBenchmarkList = new ArrayList<SingleBenchmark>();
        addSingleBenchmark(bSingleBenchmarkList, -1000, -20, -1000); // Wins vs a - wins vs c
        addSingleBenchmark(bSingleBenchmarkList, -200, -20, -1000); // Wins vs a - loses vs c
        addSingleBenchmark(bSingleBenchmarkList, -20, -20, -1000); // Wins vs a - loses vs c
        b.setSingleBenchmarkList(bSingleBenchmarkList); // 4 wins - 0 equals - 2 losses
        b.benchmarkingEnded();
        solverBenchmarkList.add(b);
        SolverBenchmark c = new SolverBenchmark(null);
        List<SingleBenchmark> cSingleBenchmarkList = new ArrayList<SingleBenchmark>();
        addSingleBenchmark(cSingleBenchmarkList, -5000, -10, -5000); // Loses vs b, Equals vs a
        addSingleBenchmark(cSingleBenchmarkList, -100, -10, -5000); // Wins vs a - wins vs b
        addSingleBenchmark(cSingleBenchmarkList, -10, -10, -5000); // Wins vs a - wins vs b
        c.setSingleBenchmarkList(cSingleBenchmarkList); // 4 wins - 1 equals - 1 losses
        c.benchmarkingEnded();
        solverBenchmarkList.add(c);

        Comparable aWeight = factory.createRankingWeight(solverBenchmarkList, a);
        Comparable bWeight = factory.createRankingWeight(solverBenchmarkList, b);
        Comparable cWeight = factory.createRankingWeight(solverBenchmarkList, c);
View Full Code Here
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
public class WorstScoreSolverBenchmarkRankingComparatorTest extends AbstractRankingComparatorTest {

    @Test
    public void normal() {
        WorstScoreSolverBenchmarkRankingComparator comparator = new WorstScoreSolverBenchmarkRankingComparator();
        SolverBenchmark a = new SolverBenchmark(null);
        List<SingleBenchmark> aSingleBenchmarkList = new ArrayList<SingleBenchmark>();
        addSingleBenchmark(aSingleBenchmarkList, -100, -30, -2001);
        addSingleBenchmark(aSingleBenchmarkList, -2001, -30, -2001);
        addSingleBenchmark(aSingleBenchmarkList, -30, -30, -2001);
        a.setSingleBenchmarkList(aSingleBenchmarkList);
        a.benchmarkingEnded();
        SolverBenchmark b = new SolverBenchmark(null);
        List<SingleBenchmark> bSingleBenchmarkList = new ArrayList<SingleBenchmark>();
        addSingleBenchmark(bSingleBenchmarkList, -900, -30, -2000);
        addSingleBenchmark(bSingleBenchmarkList, -2000, -30, -2000);
        addSingleBenchmark(bSingleBenchmarkList, -30, -30, -2000);
        b.setSingleBenchmarkList(bSingleBenchmarkList);
        b.benchmarkingEnded();
        assertEquals(-1, comparator.compare(a, b));
        assertEquals(1, comparator.compare(b, a));
    }
View Full Code Here
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
    }

    @Test
    public void worstIsEqual() {
        WorstScoreSolverBenchmarkRankingComparator comparator = new WorstScoreSolverBenchmarkRankingComparator();
        SolverBenchmark a = new SolverBenchmark(null);
        List<SingleBenchmark> aSingleBenchmarkList = new ArrayList<SingleBenchmark>();
        addSingleBenchmark(aSingleBenchmarkList, -101, -30, -2000);
        addSingleBenchmark(aSingleBenchmarkList, -2000, -30, -2000);
        addSingleBenchmark(aSingleBenchmarkList, -30, -30, -2000);
        a.setSingleBenchmarkList(aSingleBenchmarkList);
        a.benchmarkingEnded();
        SolverBenchmark b = new SolverBenchmark(null);
        List<SingleBenchmark> bSingleBenchmarkList = new ArrayList<SingleBenchmark>();
        addSingleBenchmark(bSingleBenchmarkList, -100, -40, -2000);
        addSingleBenchmark(bSingleBenchmarkList, -2000, -40, -2000);
        addSingleBenchmark(bSingleBenchmarkList, -40, -40, -2000);
        b.setSingleBenchmarkList(bSingleBenchmarkList);
        b.benchmarkingEnded();
        assertEquals(-1, comparator.compare(a, b));
        assertEquals(1, comparator.compare(b, a));
    }
View Full Code Here
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
public class TotalScoreSolverBenchmarkRankingComparatorTest extends AbstractRankingComparatorTest {

    @Test
    public void normal() {
        TotalScoreSolverBenchmarkRankingComparator comparator = new TotalScoreSolverBenchmarkRankingComparator();
        SolverBenchmark a = new SolverBenchmark(null);
        List<SingleBenchmark> aSingleBenchmarkList = new ArrayList<SingleBenchmark>();
        addSingleBenchmark(aSingleBenchmarkList, -1000, -30, -1000);
        addSingleBenchmark(aSingleBenchmarkList, -400, -30, -1000);
        addSingleBenchmark(aSingleBenchmarkList, -30, -30, -1000);
        a.setSingleBenchmarkList(aSingleBenchmarkList);
        a.benchmarkingEnded();
        SolverBenchmark b = new SolverBenchmark(null);
        List<SingleBenchmark> bSingleBenchmarkList = new ArrayList<SingleBenchmark>();
        addSingleBenchmark(bSingleBenchmarkList, -1000, -50, -1000);
        addSingleBenchmark(bSingleBenchmarkList, -200, -50, -1000);
        addSingleBenchmark(bSingleBenchmarkList, -50, -50, -1000);
        b.setSingleBenchmarkList(bSingleBenchmarkList);
        b.benchmarkingEnded();
        assertEquals(-1, comparator.compare(a, b));
        assertEquals(1, comparator.compare(b, a));
    }
View Full Code Here
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
    }

    @Test
    public void totalIsEqual() {
        TotalScoreSolverBenchmarkRankingComparator comparator = new TotalScoreSolverBenchmarkRankingComparator();
        SolverBenchmark a = new SolverBenchmark(null);
        List<SingleBenchmark> aSingleBenchmarkList = new ArrayList<SingleBenchmark>();
        addSingleBenchmark(aSingleBenchmarkList, -1005, -30, -1005);
        addSingleBenchmark(aSingleBenchmarkList, -200, -30, -1005);
        addSingleBenchmark(aSingleBenchmarkList, -30, -30, -1005);
        a.setSingleBenchmarkList(aSingleBenchmarkList);
        a.benchmarkingEnded();
        SolverBenchmark b = new SolverBenchmark(null);
        List<SingleBenchmark> bSingleBenchmarkList = new ArrayList<SingleBenchmark>();
        addSingleBenchmark(bSingleBenchmarkList, -1000, -35, -1000);
        addSingleBenchmark(bSingleBenchmarkList, -200, -35, -1000);
        addSingleBenchmark(bSingleBenchmarkList, -35, -35, -1000);
        b.setSingleBenchmarkList(bSingleBenchmarkList);
        b.benchmarkingEnded();
        assertEquals(-1, comparator.compare(a, b));
        assertEquals(1, comparator.compare(b, a));
    }
View Full Code Here
TOP

Related Classes of org.drools.planner.benchmark.core.SolverBenchmark

  • com.thoughtworks.xstream.XStream
  • org.drools.planner.benchmark.config.PlannerBenchmarkConfig
  • org.drools.planner.benchmark.config.SolverBenchmarkConfig
  • org.drools.planner.benchmark.core.measurement.ScoreDifferencePercentage
  • org.drools.planner.benchmark.core.ranking.TotalRankSolverBenchmarkRankingWeightFactoryTest
  • org.drools.planner.benchmark.core.ranking.TotalScoreSolverBenchmarkRankingComparatorTest
  • org.drools.planner.benchmark.core.ranking.WorstScoreSolverBenchmarkRankingComparatorTest
    • Copyright © 2018 www.massapicom. All rights reserved.
    All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.