EMMA Coverage Report (generated Sat Apr 29 12:52:00 BST 2006)
[all classes][net.sourceforge.pseudoq.solver]

COVERAGE SUMMARY FOR SOURCE FILE [SmallXSolver.java]

nameclass, %method, %block, %line, %
SmallXSolver.java100% (1/1)100% (4/4)100% (1016/1016)100% (65/65)

COVERAGE BREAKDOWN BY CLASS AND METHOD

nameclass, %method, %block, %line, %
     
class SmallXSolver100% (1/1)100% (4/4)100% (1016/1016)100% (65/65)
<static initializer> 100% (1/1)100% (4/4)100% (1/1)
SmallXSolver (Puzzle): void 100% (1/1)100% (4/4)100% (2/2)
setupCounters (Puzzle): void 100% (1/1)100% (509/509)100% (34/34)
setupStrategies (Puzzle): void 100% (1/1)100% (499/499)100% (28/28)

1/*
2 * Copyright (c) 2005 The PseudoQ Project.
3 *
4 * This file is part of PseudoQ.
5 *
6 * PseudoQ is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU Lesser General Public License as published by
8 * the Free Software Foundation; either version 2.1 of the License, or
9 * (at your option) any later version.
10 *
11 * PseudoQ is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 * GNU Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public License
17 * along with PseudoQ; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
19 */
20 
21package net.sourceforge.pseudoq.solver;
22 
23import java.util.Map;
24 
25import net.sourceforge.pseudoq.model.Coordinate;
26import net.sourceforge.pseudoq.model.Puzzle;
27import net.sourceforge.pseudoq.model.Region;
28 
29/**
30 * Solver for SMALL_X type puzzles.
31 * @author <a href="http://sourceforge.net/users/stevensa">Andrew Stevens</a>
32 */
33public class SmallXSolver extends AbstractSolver {
34    /** Log4J logger */
35    private static final org.apache.log4j.Logger log =
36            org.apache.log4j.LogManager.getLogger(SmallXSolver.class);
37 
38    /**
39     * Creates a new instance of SmallSolver 
40     */
41    public SmallXSolver(Puzzle puzzle) {
42        super(puzzle);
43    }
44 
45    protected void setupCounters(Puzzle puzzle) {
46        Map<String, Region> regions = puzzle.getRegions();
47        int maxint = puzzle.getMaxInt();
48 
49        log.debug("Setting up counters");
50        for (int i = 0; i < maxint; i++) {
51            counters.put("rowValueCount-" + i,
52                    new RegionValueCounter(regions.get("row-" + i)));
53            counters.put("columnValueCount-" + i,
54                    new RegionValueCounter(regions.get("column-" + i)));
55            counters.put("boxValueCount-" + i,
56                    new RegionValueCounter(regions.get("box-" + i)));
57            counters.put("boxValueCount-" + (i + 10),
58                    new RegionValueCounter(regions.get("box-" + (i + 10))));
59            for (int j = 1; j <= maxint; j++) {
60                counters.put("rowIndicatorCount-" + i + "-" + j,
61                        new RegionValueIndicatorCounter(regions.get("row-" + i), j));
62                counters.put("columnIndicatorCount-" + i + "-" + j,
63                        new RegionValueIndicatorCounter(regions.get("column-" + i), j));
64                counters.put("boxIndicatorCount-" + i + "-" + j,
65                        new RegionValueIndicatorCounter(regions.get("box-" + i), j));
66                counters.put("boxIndicatorCount-" + (i + 10) + "-" + j,
67                        new RegionValueIndicatorCounter(regions.get("box-" + (i + 10)), j));
68            }
69        }
70        for (int i = 0; i < 2; i++) {
71            counters.put("diagonalValueCount-" + i,
72                    new RegionValueCounter(regions.get("diagonal-" + i)));
73            for (int j = 1; j <= maxint; j++) {
74                counters.put("diagonalIndicatorCount-" + i + "-" + j,
75                        new RegionValueIndicatorCounter(regions.get("diagonal-" + i), j));
76            }
77        }
78        for (int i = 0; i < 4; i++) {
79            for (int j = 1; j <= maxint; j++) {
80                Region superRow = regions.get("superRow-" + i);
81                counters.put("superRowIndicatorCount-" + i + "-" + j,
82                        new RegionValueIndicatorCounter(superRow, j));
83            }
84        }
85        for (int i = 0; i < 4; i++) {
86            for (int j = 1; j <= maxint; j++) {
87                Region superColumn = regions.get("superColumn-" + i);
88                counters.put("superColumnIndicatorCount-" + i + "-" + j,
89                        new RegionValueIndicatorCounter(superColumn, j));
90            }
91        }
92        for (Coordinate coord : grid.keySet()) {
93//            // only care about cells that aren't already filled
94//            if (Integer.valueOf(0).equals(grid.get(coord))) {
95                Region cellRegions = new Region();
96                // find all the Rows, Columns, Boxes & Diagonals that contain this cell
97                for (Region region : regions.values()) {
98                    if (region.contains(coord) && region.getName() != null &&
99                            (region.getName().startsWith("Row ") ||
100                            region.getName().startsWith("Column ") ||
101                            region.getName().startsWith("Box ") ||
102                            region.getName().startsWith("Diagonal "))) {
103                        cellRegions.addAll(region);
104                    }
105                }
106                counters.put("cellPossibilitiesCount-" + coord.getRow() + "-" + coord.getColumn(),
107                        new CellPossibilitiesCounter(coord, maxint, cellRegions));
108//            }
109        }
110    }
111 
112    protected void setupStrategies(Puzzle puzzle) {
113        Map<String, Region> regions = puzzle.getRegions();
114        int maxint = puzzle.getMaxInt();
115 
116        log.debug("Setting up strategies");
117        for (int i = 0; i < maxint; i++) {
118            strategies.add(new GapFillRegionStrategy(grid, counters.get("rowValueCount-" + i),
119                    regions.get("row-" + i), maxint));
120            strategies.add(new GapFillRegionStrategy(grid, counters.get("columnValueCount-" + i),
121                    regions.get("column-" + i), maxint));
122            strategies.add(new GapFillRegionStrategy(grid, counters.get("boxValueCount-" + i),
123                    regions.get("box-" + i), maxint));
124        }
125        strategies.add(new GapFillRegionStrategy(grid, 
126                counters.get("diagonalValueCount-0"),
127                regions.get("diagonal-0"), maxint));
128        strategies.add(new GapFillRegionStrategy(grid, 
129                counters.get("diagonalValueCount-1"),
130                regions.get("diagonal-1"), maxint));
131        for (int i = 0; i < maxint; i++) {
132            strategies.add(new ScanRowsStrategy(0, i + 1, 0, 1, grid, counters, 0, 1, 4));
133            strategies.add(new ScanRowsStrategy(1, i + 1, 2, 3, grid, counters, 2, 3, 4));
134            strategies.add(new ScanRowsStrategy(2, i + 1, 4, 5, grid, counters, 4, 5, 4));
135            strategies.add(new ScanRowsStrategy(3, i + 1, 6, 7, grid, counters, 6, 7, 4));
136            strategies.add(new ScanColumnsStrategy(0, i + 1, 0, 1, grid, counters, 10, 14, 4, 4));
137            strategies.add(new ScanColumnsStrategy(1, i + 1, 2, 3, grid, counters, 11, 15, 4, 4));
138            strategies.add(new ScanColumnsStrategy(2, i + 1, 4, 5, grid, counters, 12, 16, 4, 4));
139            strategies.add(new ScanColumnsStrategy(3, i + 1, 6, 7, grid, counters, 13, 17, 4, 4));
140        }
141        for (Coordinate coord : grid.keySet()) {
142            // only care about cells that aren't already filled
143            if (Integer.valueOf(0).equals(grid.get(coord))) {
144                strategies.add(new SingleCellStrategy(coord, grid,
145                        counters.get("cellPossibilitiesCount-" + coord.getRow() + "-" + coord.getColumn())));
146            }
147        }
148        for (int i = 0; i < maxint; i++) {
149            for (int j = 1; j <= maxint; j++) {
150                strategies.add(new ValuePossibilitiesStrategy(regions.get("row-" + i), j,
151                        (RegionValueIndicatorCounter) counters.get("rowIndicatorCount-" + i + "-" + j), counters));
152                strategies.add(new ValuePossibilitiesStrategy(regions.get("column-" + i), j,
153                        (RegionValueIndicatorCounter) counters.get("columnIndicatorCount-" + i + "-" + j), counters));
154                strategies.add(new ValuePossibilitiesStrategy(regions.get("box-" + i), j,
155                        (RegionValueIndicatorCounter) counters.get("boxIndicatorCount-" + i + "-" + j), counters));
156            }
157        }
158    }
159 
160}

[all classes][net.sourceforge.pseudoq.solver]
EMMA 2.0.5312 (C) Vladimir Roubtsov