[jgogears commit] r66 - in trunk/jgogears/jgogears: . engine

0 views

Skip to first unread message

codesite...@google.com

unread,

Mar 19, 2008, 3:44:54 PM3/19/08

to jgog...@googlegroups.com

Author: syeates
Date: Wed Mar 19 12:44:41 2008
New Revision: 66

Added:
trunk/jgogears/jgogears/KoRuleSet.java
Modified:
trunk/jgogears/jgogears/GlobalTests.java
trunk/jgogears/jgogears/NoKoRuleSet.java
trunk/jgogears/jgogears/engine/Engine.java
trunk/jgogears/jgogears/engine/Scorer.java
trunk/jgogears/jgogears/engine/StraightVertexLineariserTest.java
trunk/jgogears/jgogears/engine/VertexLineariserTest.java

Log:
misc. updates

Modified: trunk/jgogears/jgogears/GlobalTests.java
==============================================================================
--- trunk/jgogears/jgogears/GlobalTests.java (original)
+++ trunk/jgogears/jgogears/GlobalTests.java Wed Mar 19 12:44:41 2008
@@ -27,6 +27,7 @@
suite.addTestSuite(NodeTest.class);
suite.addTestSuite(ModelTest.class);
suite.addTestSuite(StraightVertexLineariserTest.class);
+ suite.addTestSuite(VertexLineariserTest.class);
suite.addTestSuite(MoveTest.class);
suite.addTestSuite(SGFPropertyTest.class);
suite.addTestSuite(SGFNodeTest.class);

Added: trunk/jgogears/jgogears/KoRuleSet.java
==============================================================================
--- (empty file)
+++ trunk/jgogears/jgogears/KoRuleSet.java Wed Mar 19 12:44:41 2008
@@ -0,0 +1,41 @@
+/**
+ *
+ */
+package jgogears;
+
+/**
+ * TODO
+ * @author syeates
+ *
+ */
+public class KoRuleSet extends NoKoRuleSet {
+
+ /* (non-Javadoc)
+ * @see jgogears.NoKoRuleSet#getDescription()
+ */
+ @Override
+ public String getDescription() {
+ // TODO Auto-generated method stub
+throw new Error();
+ }
+
+ /* (non-Javadoc)
+ * @see jgogears.NoKoRuleSet#getName()
+ */
+ @Override
+ public String getName() {
+ // TODO Auto-generated method stub
+ throw new Error();
+
+ }
+
+ /* (non-Javadoc)
+ * @see jgogears.NoKoRuleSet#moveIsLegal(jgogears.Game,
jgogears.BoardI, jgogears.Move)
+ */
+ @Override
+ public boolean moveIsLegal(Game game, BoardI board, Move move) {
+ // TODO Auto-generated method stub
+ throw new Error();
+ }
+
+}

Modified: trunk/jgogears/jgogears/NoKoRuleSet.java
==============================================================================
--- trunk/jgogears/jgogears/NoKoRuleSet.java (original)
+++ trunk/jgogears/jgogears/NoKoRuleSet.java Wed Mar 19 12:44:41 2008
@@ -5,18 +5,17 @@

import java.util.*;

-// TODO: Auto-generated Javadoc
/**
- * The Class NoKoRuleSet.
+ * Really simple and fast ruleset
*
* @author Stuart
*/
-final public class NoKoRuleSet extends RuleSet {
+public class NoKoRuleSet extends RuleSet {

- /** The Constant DEBUG. */
+ /** Are we being verbose? */
final static boolean DEBUG = false;

- /** The Constant EMPTY. */
+ /** an empty treeset for filling from */
final static TreeSet<Vertex> EMPTY = new TreeSet<Vertex>();

/*
@@ -245,23 +244,6 @@
* @return the number of liberties through this position
*/
TreeSet<Vertex> legelsfrompos(int row, int column, short colour,
BoardI board) {
- return this.legelsfrompos((short) row, (short) column, colour, board);
- }
-
- /**
- * Helper for moveIsLegal.
- *
- * @param row
- * the row of the position that is a potential liberty
- * @param column
- * the column of the position that is a potential liberty
- * @param colour
- * the colour of the stone we want to use these liberties for
- * @param board
- * the board
- * @return the number of liberties through this position
- */
- TreeSet<Vertex> legelsfrompos(short row, short column, short colour,
BoardI board) {
TreeSet<Vertex> liberties = new TreeSet<Vertex>();
short acolour = board.getColour(row, column);
if (acolour == colour) {

Modified: trunk/jgogears/jgogears/engine/Engine.java
==============================================================================
--- trunk/jgogears/jgogears/engine/Engine.java (original)
+++ trunk/jgogears/jgogears/engine/Engine.java Wed Mar 19 12:44:41 2008
@@ -28,7 +28,8 @@
Trainer trainer = new Trainer();
trainer.setModel(model);

- trainer.train(200);
+ //trainer.train(200);
+ trainer.train();
System.out.println("model trained");
System.out.println(model.getRoot());
System.out.println(model.getRoot().size());
@@ -47,7 +48,7 @@
for (int i = 0; i < 200; i++) {
GTPState state = new GTPState();
state = two.move();
- System.out.println(state.getBoard());
+ //System.out.println(state.getBoard());
}
}

Modified: trunk/jgogears/jgogears/engine/Scorer.java
==============================================================================
--- trunk/jgogears/jgogears/engine/Scorer.java (original)
+++ trunk/jgogears/jgogears/engine/Scorer.java Wed Mar 19 12:44:41 2008
@@ -103,11 +103,11 @@
childNP = child.getNotPlayed();
estimate = estimate * 0.5 + childP / (childP + childNP) * 0.5;
}
- node = child;
if (DEBUG_BRANCH)
System.err.println("Model::getScores following a " + BoardI.colourString(colour)
+ " branch, estimate = " + estimate + ", childP = " + childP
+ ", childNP = "
+ childNP + ", combination = " + childP / (childP + childNP)
* 0.5);
+ node = child;
}

// estimate = (1 + previous.getPlayed()) / (previous.getPlayed()
+ previous.getNotPlayed()) * (1 -

Modified: trunk/jgogears/jgogears/engine/StraightVertexLineariserTest.java
==============================================================================
--- trunk/jgogears/jgogears/engine/StraightVertexLineariserTest.java (original)
+++ trunk/jgogears/jgogears/engine/StraightVertexLineariserTest.java
Wed Mar 19 12:44:41 2008
@@ -256,55 +256,130 @@
* the exception
*/
public void testDifferenetSizes13() throws Exception {
- try {
BoardI board = BoardI.newBoard();
- StraightVertexLineariser lineariser = new
StraightVertexLineariser(board, (short) 2, (short) 2, (short) 0, false);
- assertNotNull(lineariser);
+ StraightVertexLineariser linear = new
StraightVertexLineariser(board, (short) 2, (short) 2, (short) 0, false);
+ assertNotNull(linear);
board = BoardI.newBoard(13);
- lineariser = new StraightVertexLineariser(board, (short) 2, (short)
2, (short) 0, false);
- fail("shouldn't be able to linearise different sizes of board");
- } catch (IllegalArgumentException e) {
- assertNotNull(e);
- }
+ linear = new StraightVertexLineariser(board, (short) 2, (short) 2,
(short) 0, false);
+ int count = 0;
+ while (linear.hasNext()) {
+ Short s = linear.next();
+ assertNotNull(s);
+ count++;
+ }
+ int plussize = (board.getSize()+2)*(board.getSize()+2) ;
+
+ assertTrue(count + "/" + plussize+1, count == plussize+1);
}
+ /**
+ * test what happens when linearising boards of different sizes.
+ *
+ * @throws Exception
+ * the exception
+ */
+ public void testDifferenetSizes9() throws Exception {
+ BoardI board = BoardI.newBoard();
+ StraightVertexLineariser linear = new
StraightVertexLineariser(board, (short) 2, (short) 2, (short) 0, false);
+ assertNotNull(linear);
+ board = BoardI.newBoard(9);
+ linear = new StraightVertexLineariser(board, (short) 2, (short) 2,
(short) 0, false);
+ int count = 0;
+ while (linear.hasNext()) {
+ Short s = linear.next();
+ assertNotNull(s);
+ count++;
+ }
+ int plussize = (board.getSize()+2)*(board.getSize()+2) ;

+ assertTrue(count + "/" + plussize+1, count == plussize+1);
+ }
+ /**
+ * test what happens when linearising boards of different sizes.
+ *
+ * @throws Exception
+ * the exception
+ */
+ public void testDifferenetSizes11() throws Exception {
+ BoardI board = BoardI.newBoard();
+ StraightVertexLineariser linear = new
StraightVertexLineariser(board, (short) 2, (short) 2, (short) 0, false);
+ assertNotNull(linear);
+ board = BoardI.newBoard(11);
+ linear = new StraightVertexLineariser(board, (short) 2, (short) 2,
(short) 0, false);
+ int count = 0;
+ while (linear.hasNext()) {
+ Short s = linear.next();
+ assertNotNull(s);
+ count++;
+ }
+ int plussize = (board.getSize()+2)*(board.getSize()+2) ;

+ assertTrue(count + "/" + plussize+1, count == plussize+1);
+ }
/**
* test what happens when linearising boards of different sizes.
*
* @throws Exception
* the exception
*/
- public void testDifferenetSizes5() throws Exception {
- try {
- BoardI board = BoardI.newBoard(19);
- StraightVertexLineariser lineariser = new
StraightVertexLineariser(board, (short) 2, (short) 2, (short) 0, false);
- assertNotNull(lineariser);
- board = BoardI.newBoard(9);
- lineariser = new StraightVertexLineariser(board, (short) 2, (short)
2, (short) 0, false);
- fail("shouldn't be able to linearise different sizes of board");
- } catch (IllegalArgumentException e) {
- assertNotNull(e);
- }
+ public void testDifferenetSizes10() throws Exception {
+ BoardI board = BoardI.newBoard();
+ StraightVertexLineariser linear = new
StraightVertexLineariser(board, (short) 2, (short) 2, (short) 0, false);
+ assertNotNull(linear);
+ board = BoardI.newBoard(10);
+ linear = new StraightVertexLineariser(board, (short) 2, (short) 2,
(short) 0, false);
+ int count = 0;
+ while (linear.hasNext()) {
+ Short s = linear.next();
+ assertNotNull(s);
+ count++;
+ }
+ int plussize = (board.getSize()+2)*(board.getSize()+2) ;
+
+ assertTrue(count + "/" + plussize+1, count == plussize+1);
}
+ /**
+ * test what happens when linearising boards of different sizes.
+ *
+ * @throws Exception
+ * the exception
+ */
+ public void testDifferenetSizes21() throws Exception {
+ BoardI board = BoardI.newBoard();
+ StraightVertexLineariser linear = new
StraightVertexLineariser(board, (short) 2, (short) 2, (short) 0, false);
+ assertNotNull(linear);
+ board = BoardI.newBoard(21);
+ linear = new StraightVertexLineariser(board, (short) 2, (short) 2,
(short) 0, false);
+ int count = 0;
+ while (linear.hasNext()) {
+ Short s = linear.next();
+ assertNotNull(s);
+ count++;
+ }
+ int plussize = (board.getSize()+2)*(board.getSize()+2) ;

/**

Modified: trunk/jgogears/jgogears/engine/VertexLineariserTest.java
==============================================================================
--- trunk/jgogears/jgogears/engine/VertexLineariserTest.java (original)
+++ trunk/jgogears/jgogears/engine/VertexLineariserTest.java Wed Mar 19
12:44:41 2008
@@ -36,8 +36,8 @@
for (short i = 0; i < 8; i++) {
if (i != j) {
boolean differenceFound = false;
- Iterator<Short> lineara = new StraightVertexLineariser(board,
rowa, columna, j, false);
- Iterator<Short> linearb = new StraightVertexLineariser(board,
rowb, columnb, i, false);
+ Iterator<Short> lineara = new VertexLineariser(board, rowa,
columna, j, false);
+ Iterator<Short> linearb = new VertexLineariser(board, rowb,
columnb, i, false);
assertTrue(lineara != null);
assertTrue(linearb != null);
while (lineara.hasNext() && linearb.hasNext()
&& !differenceFound) {
@@ -83,8 +83,8 @@
for (short j = 0; j < 8; j++)
for (short i = 0; i < 8; i++) {
if (i != j) {
- Iterator<Short> lineara = new StraightVertexLineariser(board,
row, column, j, false);
- Iterator<Short> linearb = new StraightVertexLineariser(board,
row, column, i, false);
+ Iterator<Short> lineara = new VertexLineariser(board, row,
column, j, false);
+ Iterator<Short> linearb = new VertexLineariser(board, row,
column, i, false);
assertTrue(lineara != null);
assertTrue(linearb != null);
boolean differenceFound = false;
@@ -99,8 +99,8 @@
differenceFound = true;
}
assertTrue(i + " " + j + " " + row + " " + column + "\n"
- + new StraightVertexLineariser(board, row, column, j, false) + "\n"
- + new StraightVertexLineariser(board, row, column, i, false), differenceFound);
+ + new VertexLineariser(board, row, column, j, false) + "\n"
+ + new VertexLineariser(board, row, column, i, false), differenceFound);
}
}

@@ -118,8 +118,8 @@
for (short j = 0; j < 8; j++)
for (short i = 0; i < 8; i++) {
if (i != j) {
- Iterator<Short> lineara = new StraightVertexLineariser(board,
(short) 2, (short) 2, j, false);
- Iterator<Short> linearb = new StraightVertexLineariser(board,
(short) 2, (short) 2, i, false);
+ Iterator<Short> lineara = new VertexLineariser(board, (short) 2,
(short) 2, j, false);
+ Iterator<Short> linearb = new VertexLineariser(board, (short) 2,
(short) 2, i, false);
assertTrue(lineara != null);
assertTrue(linearb != null);
boolean differenceFound = false;
@@ -157,7 +157,7 @@
for (short column = 0; column < board.getSize(); column++) {
if (DEBUG)
for (short j = 0; j < 8; j++) {
- Iterator<Short> linear = new StraightVertexLineariser(board,
row, column, j, false);
+ Iterator<Short> linear = new VertexLineariser(board, row,
column, j, false);
assertTrue(linear != null);
while (linear.hasNext()) {
Short s = linear.next();
@@ -168,7 +168,7 @@
}
if (DEBUG)
for (short j = 0; j < 8; j++) {
- Iterator<Short> linear = new StraightVertexLineariser(board,
column, row, j, false);
+ Iterator<Short> linear = new VertexLineariser(board, column,
row, j, false);
assertTrue(linear != null);
while (linear.hasNext()) {
Short s = linear.next();
@@ -255,10 +255,10 @@
public void testDifferenetSizes13() throws Exception {
try {
BoardI board = BoardI.newBoard();
- StraightVertexLineariser lineariser = new
StraightVertexLineariser(board, (short) 2, (short) 2, (short) 0, false);
+ VertexLineariser lineariser = new VertexLineariser(board, (short)
2, (short) 2, (short) 0, false);
assertNotNull(lineariser);
board = BoardI.newBoard(13);
- lineariser = new StraightVertexLineariser(board, (short) 2, (short)
2, (short) 0, false);
+ lineariser = new VertexLineariser(board, (short) 2, (short) 2,
(short) 0, false);
fail("shouldn't be able to linearise different sizes of board");
} catch (IllegalArgumentException e) {
assertNotNull(e);
@@ -274,10 +274,10 @@
public void testDifferenetSizes25() throws Exception {
try {
BoardI board = BoardI.newBoard();
- StraightVertexLineariser lineariser = new
StraightVertexLineariser(board, (short) 2, (short) 2, (short) 0, false);
+ VertexLineariser lineariser = new VertexLineariser(board, (short)
2, (short) 2, (short) 0, false);
assertNotNull(lineariser);
board = BoardI.newBoard(25);
- lineariser = new StraightVertexLineariser(board, (short) 2, (short)
2, (short) 0, false);
+ lineariser = new VertexLineariser(board, (short) 2, (short) 2,
(short) 0, false);
fail("shouldn't be able to linearise different sizes of board");
} catch (IllegalArgumentException e) {
assertNotNull(e);
@@ -293,10 +293,10 @@
public void testDifferenetSizes5() throws Exception {
try {
BoardI board = BoardI.newBoard(19);
- StraightVertexLineariser lineariser = new
StraightVertexLineariser(board, (short) 2, (short) 2, (short) 0, false);
+ VertexLineariser lineariser = new VertexLineariser(board, (short)
2, (short) 2, (short) 0, false);
assertNotNull(lineariser);
board = BoardI.newBoard(9);
- lineariser = new StraightVertexLineariser(board, (short) 2, (short)
2, (short) 0, false);
+ lineariser = new VertexLineariser(board, (short) 2, (short) 2,
(short) 0, false);
fail("shouldn't be able to linearise different sizes of board");
} catch (IllegalArgumentException e) {
assertNotNull(e);
@@ -312,10 +312,10 @@
public void testDifferenetSizes9() throws Exception {
try {
BoardI board = BoardI.newBoard(19);
- StraightVertexLineariser lineariser = new
StraightVertexLineariser(board, (short) 2, (short) 2, (short) 0, false);
+ VertexLineariser lineariser = new VertexLineariser(board, (short)
2, (short) 2, (short) 0, false);
assertNotNull(lineariser);
board = BoardI.newBoard(9);
- lineariser = new StraightVertexLineariser(board, (short) 2, (short)
2, (short) 0, false);
+ lineariser = new VertexLineariser(board, (short) 2, (short) 2,
(short) 0, false);
fail("shouldn't be able to linearise different sizes of board");
} catch (IllegalArgumentException e) {
assertNotNull(e);
@@ -332,7 +332,7 @@
for (short row = 0; row < board.getSize(); row++)
for (short column = 0; column < board.getSize(); column++) {
for (short j = 0; j < 8; j++) {
- Iterator<Short> linear = new StraightVertexLineariser(board, row,
column, j, false);
+ Iterator<Short> linear = new VertexLineariser(board, row, column,
j, false);
while (linear.hasNext()) {
Short s = linear.next();
if (DEBUG)
@@ -344,7 +344,7 @@
if (DEBUG)
System.err.println();
for (short j = 0; j < 8; j++) {
- Iterator<Short> linear = new StraightVertexLineariser(board,
(short) (board.getSize() - row - 1),
+ Iterator<Short> linear = new VertexLineariser(board, (short)
(board.getSize() - row - 1),
(short) (board.getSize() - column - 1), j, false);
while (linear.hasNext()) {
Short s = linear.next();
@@ -393,8 +393,8 @@

for (short sym2 = 0; sym2 < 8; sym2++) {
matches[0][sym1][sym2] = true;
- Iterator<Short> lineara = new StraightVertexLineariser(board,
(short) 0, (short) 0, sym1, false);
- Iterator<Short> linearb = new StraightVertexLineariser(board,
(short) (size - 1), (short) (size - 1), sym2,
+ Iterator<Short> lineara = new VertexLineariser(board, (short) 0,
(short) 0, sym1, false);
+ Iterator<Short> linearb = new VertexLineariser(board, (short)
(size - 1), (short) (size - 1), sym2,
false);
while (lineara.hasNext()) {
assertTrue(lineara.hasNext());
@@ -409,8 +409,8 @@

for (short sym2 = 0; sym2 < 8; sym2++) {
matches[1][sym1][sym2] = true;
- Iterator<Short> lineara = new StraightVertexLineariser(board,
(short) 0, (short) 0, sym1, false);
- Iterator<Short> linearb = new StraightVertexLineariser(board,
(short) 0, (short) (size - 1), sym2, false);
+ Iterator<Short> lineara = new VertexLineariser(board, (short) 0,
(short) 0, sym1, false);
+ Iterator<Short> linearb = new VertexLineariser(board, (short) 0,
(short) (size - 1), sym2, false);
while (lineara.hasNext()) {
assertTrue(lineara.hasNext());
assertTrue(linearb.hasNext());
@@ -424,8 +424,8 @@

for (short sym2 = 0; sym2 < 8; sym2++) {
matches[2][sym1][sym2] = true;
- Iterator<Short> lineara = new StraightVertexLineariser(board,
(short) 0, (short) 0, sym1, false);
- Iterator<Short> linearb = new StraightVertexLineariser(board,
(short) (size - 1), (short) 0, sym2, false);
+ Iterator<Short> lineara = new VertexLineariser(board, (short) 0,
(short) 0, sym1, false);
+ Iterator<Short> linearb = new VertexLineariser(board, (short)
(size - 1), (short) 0, sym2, false);
while (lineara.hasNext()) {
assertTrue(lineara.hasNext());
assertTrue(linearb.hasNext());
@@ -500,7 +500,7 @@
board = iterator.next();
assertTrue(board != null);
for (short j = 0; j < 8; j++) {
- Iterator<Short> linear = new StraightVertexLineariser(board,
(short) 2, (short) 2, j, false);
+ Iterator<Short> linear = new VertexLineariser(board, (short) 2,
(short) 2, j, false);
assertTrue(linear != null);
while (linear.hasNext()) {
Short s = linear.next();
@@ -526,7 +526,7 @@
assertNotNull(board);

for (short j = 0; j < 8; j++) {
if (DEBUG)
- System.err.println("StraightVertexLineariserTest::testFirst sym="
+ j);
- Iterator<Short> lineara = new StraightVertexLineariser(board,
(short) 1, (short) 1, j, true);
+ System.err.println("VertexLineariserTest::testFirst sym=" + j);
+ Iterator<Short> lineara = new VertexLineariser(board, (short) 1,
(short) 1, j, true);
assertTrue(lineara != null);
Short a = lineara.next();
assertTrue(a != null);
@@ -572,7 +572,7 @@
assertNotNull(board);

if (DEBUG)
- System.err.print("StraightVertexLineariserTest::testFirst() Black
= " + BoardI.parseColour("black"));
+ System.err.print("VertexLineariserTest::testFirst() Black = " + BoardI.parseColour("black"));
if (DEBUG)
System.err.print(" White = " + BoardI.parseColour("white"));
if (DEBUG)
@@ -585,8 +585,8 @@
for (short column = 0; column < board.getSize(); column++)
for (short j = 0; j < 8; j++) {
if (DEBUG)
- System.err.println("StraightVertexLineariserTest::testFirst
sym=" + j);
- Iterator<Short> lineara = new StraightVertexLineariser(board,
row, column, j, true);
+ System.err.println("VertexLineariserTest::testFirst sym=" + j);
+ Iterator<Short> lineara = new VertexLineariser(board, row,
column, j, true);
assertTrue(lineara != null);
Short a = lineara.next();
assertTrue(a != null);
@@ -604,7 +604,7 @@
BoardI board = BoardI.newBoard();
assertNotNull(board);
int count = 0;
- Iterator<Short> linear = new StraightVertexLineariser(board, (short)
2, (short) 2, (short) 0, false);
+ Iterator<Short> linear = new VertexLineariser(board, (short) 2,
(short) 2, (short) 0, false);
while (linear.hasNext()) {
Short s = linear.next();
assertNotNull(s);
@@ -631,7 +631,7 @@

assertNotNull(board);
if (DEBUG)
-
System.err.print("StraightVertexLineariserTest::testStraightVertexLineariser()
Black = " + BoardI.parseColour("black"));
+ System.err.print("VertexLineariserTest::testVertexLineariser()
Black = " + BoardI.parseColour("black"));
if (DEBUG)
System.err.print(" White = " + BoardI.parseColour("white"));
if (DEBUG)
@@ -641,7 +641,7 @@
if (DEBUG)
System.err.println("");
for (short j = 0; j < 8; j++) {
- Iterator<Short> linear = new StraightVertexLineariser(board,
(short) 2, (short) 2, j, false);
+ Iterator<Short> linear = new VertexLineariser(board, (short) 2,
(short) 2, j, false);
assertTrue(linear != null);
while (linear.hasNext()) {
Short s = linear.next();

Reply all

Reply to author

Forward

0 new messages