Algorithms refactor (eugenp#2136)

pivovarit · web-flow · commit ef7400484c24 · 2017-06-23T10:18:04.000+02:00
diff --git a/algorithms/src/main/java/com/baeldung/algorithms/automata/FiniteStateMachine.java b/algorithms/src/main/java/com/baeldung/algorithms/automata/FiniteStateMachine.java
@@ -1,4 +1,4 @@
-package com.baeldung.automata;
+package com.baeldung.algorithms.automata;
 
 /**
  * Finite state machine.
diff --git a/algorithms/src/main/java/com/baeldung/algorithms/automata/RtFiniteStateMachine.java b/algorithms/src/main/java/com/baeldung/algorithms/automata/RtFiniteStateMachine.java
@@ -1,4 +1,4 @@
-package com.baeldung.automata;
+package com.baeldung.algorithms.automata;
 
 /**
  * Default implementation of a finite state machine.
diff --git a/algorithms/src/main/java/com/baeldung/algorithms/automata/RtState.java b/algorithms/src/main/java/com/baeldung/algorithms/automata/RtState.java
@@ -1,4 +1,4 @@
-package com.baeldung.automata;
+package com.baeldung.algorithms.automata;
 
 import java.util.ArrayList;
 import java.util.List;
diff --git a/algorithms/src/main/java/com/baeldung/algorithms/automata/RtTransition.java b/algorithms/src/main/java/com/baeldung/algorithms/automata/RtTransition.java
@@ -1,4 +1,4 @@
-package com.baeldung.automata;
+package com.baeldung.algorithms.automata;
 
 
 /**
diff --git a/algorithms/src/main/java/com/baeldung/algorithms/automata/State.java b/algorithms/src/main/java/com/baeldung/algorithms/automata/State.java
@@ -1,4 +1,4 @@
-package com.baeldung.automata;
+package com.baeldung.algorithms.automata;
 
 /**
  * State. Part of a finite state machine.
diff --git a/algorithms/src/main/java/com/baeldung/algorithms/automata/Transition.java b/algorithms/src/main/java/com/baeldung/algorithms/automata/Transition.java
@@ -1,4 +1,4 @@
-package com.baeldung.automata;
+package com.baeldung.algorithms.automata;
 
 /**
  * Transition in a finite State machine.
diff --git a/algorithms/src/main/java/com/baeldung/algorithms/mcts/montecarlo/MonteCarloTreeSearch.java b/algorithms/src/main/java/com/baeldung/algorithms/mcts/montecarlo/MonteCarloTreeSearch.java
@@ -8,9 +8,9 @@
 
 public class MonteCarloTreeSearch {
 
-    static final int WIN_SCORE = 10;
-    int level;
-    int oponent;
+    private static final int WIN_SCORE = 10;
+    private int level;
+    private int oponent;
 
     public MonteCarloTreeSearch() {
         this.level = 3;
diff --git a/algorithms/src/main/java/com/baeldung/algorithms/mcts/montecarlo/State.java b/algorithms/src/main/java/com/baeldung/algorithms/mcts/montecarlo/State.java
@@ -7,10 +7,10 @@
 import com.baeldung.algorithms.mcts.tictactoe.Position;
 
 public class State {
-    Board board;
-    int playerNo;
-    int visitCount;
-    double winScore;
+    private Board board;
+    private int playerNo;
+    private int visitCount;
+    private double winScore;
 
     public State() {
         board = new Board();
@@ -27,23 +27,23 @@ public State(Board board) {
         this.board = new Board(board);
     }
 
-    public Board getBoard() {
+    Board getBoard() {
         return board;
     }
 
-    public void setBoard(Board board) {
+    void setBoard(Board board) {
         this.board = board;
     }
 
-    public int getPlayerNo() {
+    int getPlayerNo() {
         return playerNo;
     }
 
-    public void setPlayerNo(int playerNo) {
+    void setPlayerNo(int playerNo) {
         this.playerNo = playerNo;
     }
 
-    public int getOpponent() {
+    int getOpponent() {
         return 3 - playerNo;
     }
 
@@ -55,11 +55,11 @@ public void setVisitCount(int visitCount) {
         this.visitCount = visitCount;
     }
 
-    public double getWinScore() {
+    double getWinScore() {
         return winScore;
     }
 
-    public void setWinScore(double winScore) {
+    void setWinScore(double winScore) {
         this.winScore = winScore;
     }
 
@@ -75,23 +75,23 @@ public List<State> getAllPossibleStates() {
         return possibleStates;
     }
 
-    public void incrementVisit() {
+    void incrementVisit() {
         this.visitCount++;
     }
 
-    public void addScore(double score) {
+    void addScore(double score) {
         if (this.winScore != Integer.MIN_VALUE)
             this.winScore += score;
     }
 
-    public void randomPlay() {
+    void randomPlay() {
         List<Position> availablePositions = this.board.getEmptyPositions();
         int totalPossibilities = availablePositions.size();
         int selectRandom = (int) (Math.random() * ((totalPossibilities - 1) + 1));
         this.board.performMove(this.playerNo, availablePositions.get(selectRandom));
     }
 
-    public void togglePlayer() {
+    void togglePlayer() {
         this.playerNo = 3 - this.playerNo;
     }
 }
diff --git a/algorithms/src/main/java/com/baeldung/algorithms/mcts/montecarlo/UCT.java b/algorithms/src/main/java/com/baeldung/algorithms/mcts/montecarlo/UCT.java
@@ -7,20 +7,18 @@
 import com.baeldung.algorithms.mcts.tree.Node;
 
 public class UCT {
-    final static double C = 1.41;
 
     public static double uctValue(int totalVisit, double nodeWinScore, int nodeVisit) {
-        if (nodeVisit == 0)
+        if (nodeVisit == 0) {
             return Integer.MAX_VALUE;
-        return ((double) nodeWinScore / (double) nodeVisit) + 1.41 * Math.sqrt(Math.log(totalVisit) / (double) nodeVisit);
+        }
+        return (nodeWinScore / (double) nodeVisit) + 1.41 * Math.sqrt(Math.log(totalVisit) / (double) nodeVisit);
     }
 
-    public static Node findBestNodeWithUCT(Node node) {
+    static Node findBestNodeWithUCT(Node node) {
         int parentVisit = node.getState().getVisitCount();
-        List<Node> childNodes = node.getChildArray();
-        return Collections.max(childNodes, Comparator.comparing(c -> {
-            double score = uctValue(parentVisit, c.getState().getWinScore(), c.getState().getVisitCount());
-            return score;
-        }));
+        return Collections.max(
+          node.getChildArray(),
+          Comparator.comparing(c -> uctValue(parentVisit, c.getState().getWinScore(), c.getState().getVisitCount())));
     }
 }
diff --git a/algorithms/src/test/java/algorithms/RtFiniteStateMachineLongRunningUnitTest.java b/algorithms/src/test/java/algorithms/RtFiniteStateMachineLongRunningUnitTest.java
@@ -1,6 +1,6 @@
 package algorithms;
 
-import com.baeldung.automata.*;
+import com.baeldung.algorithms.automata.*;
 import org.junit.Test;
 
 import static org.junit.Assert.assertTrue;
diff --git a/algorithms/src/test/java/algorithms/mcts/MCTSTest.java b/algorithms/src/test/java/algorithms/mcts/MCTSTest.java
@@ -1,92 +1,92 @@
-package algorithms;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-
-import java.util.List;
-
-import org.junit.Before;
-import org.junit.Test;
-
-import com.baeldung.algorithms.mcts.montecarlo.MonteCarloTreeSearch;
-import com.baeldung.algorithms.mcts.montecarlo.State;
-import com.baeldung.algorithms.mcts.montecarlo.UCT;
-import com.baeldung.algorithms.mcts.tictactoe.Board;
-import com.baeldung.algorithms.mcts.tictactoe.Position;
-import com.baeldung.algorithms.mcts.tree.Tree;
-
-public class MCTSTest {
-    Tree gameTree;
-    MonteCarloTreeSearch mcts;
-
-    @Before
-    public void initGameTree() {
-        gameTree = new Tree();
-        mcts = new MonteCarloTreeSearch();
-    }
-
-    @Test
-    public void givenStats_whenGetUCTForNode_thenUCTMatchesWithManualData() {
-        double uctValue = 15.79;
-        assertEquals(UCT.uctValue(600, 300, 20), uctValue, 0.01);
-    }
-
-    @Test
-    public void giveninitBoardState_whenGetAllPossibleStates_thenNonEmptyList() {
-        State initState = gameTree.getRoot().getState();
-        List<State> possibleStates = initState.getAllPossibleStates();
-        assertTrue(possibleStates.size() > 0);
-    }
-
-    @Test
-    public void givenEmptyBoard_whenPerformMove_thenLessAvailablePossitions() {
-        Board board = new Board();
-        int initAvailablePositions = board.getEmptyPositions().size();
-        board.performMove(Board.P1, new Position(1, 1));
-        int availablePositions = board.getEmptyPositions().size();
-        assertTrue(initAvailablePositions > availablePositions);
-    }
-
-    @Test
-    public void givenEmptyBoard_whenSimulateInterAIPlay_thenGameDraw() {
-        Board board = new Board();
-
-        int player = Board.P1;
-        int totalMoves = Board.DEFAULT_BOARD_SIZE * Board.DEFAULT_BOARD_SIZE;
-        for (int i = 0; i < totalMoves; i++) {
-            board = mcts.findNextMove(board, player);
-            if (board.checkStatus() != -1) {
-                break;
-            }
-            player = 3 - player;
-        }
-        int winStatus = board.checkStatus();
-        assertEquals(winStatus, Board.DRAW);
-    }
-
-    @Test
-    public void givenEmptyBoard_whenLevel1VsLevel3_thenLevel3WinsOrDraw() {
-        Board board = new Board();
-        MonteCarloTreeSearch mcts1 = new MonteCarloTreeSearch();
-        mcts1.setLevel(1);
-        MonteCarloTreeSearch mcts3 = new MonteCarloTreeSearch();
-        mcts3.setLevel(3);
-
-        int player = Board.P1;
-        int totalMoves = Board.DEFAULT_BOARD_SIZE * Board.DEFAULT_BOARD_SIZE;
-        for (int i = 0; i < totalMoves; i++) {
-            if (player == Board.P1)
-                board = mcts3.findNextMove(board, player);
-            else
-                board = mcts1.findNextMove(board, player);
-
-            if (board.checkStatus() != -1) {
-                break;
-            }
-            player = 3 - player;
-        }
-        int winStatus = board.checkStatus();
-        assertTrue(winStatus == Board.DRAW || winStatus == Board.P1);
-    }
-
-}
+package algorithms.mcts;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import java.util.List;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import com.baeldung.algorithms.mcts.montecarlo.MonteCarloTreeSearch;
+import com.baeldung.algorithms.mcts.montecarlo.State;
+import com.baeldung.algorithms.mcts.montecarlo.UCT;
+import com.baeldung.algorithms.mcts.tictactoe.Board;
+import com.baeldung.algorithms.mcts.tictactoe.Position;
+import com.baeldung.algorithms.mcts.tree.Tree;
+
+public class MCTSTest {
+    private Tree gameTree;
+    private MonteCarloTreeSearch mcts;
+
+    @Before
+    public void initGameTree() {
+        gameTree = new Tree();
+        mcts = new MonteCarloTreeSearch();
+    }
+
+    @Test
+    public void givenStats_whenGetUCTForNode_thenUCTMatchesWithManualData() {
+        double uctValue = 15.79;
+        assertEquals(UCT.uctValue(600, 300, 20), uctValue, 0.01);
+    }
+
+    @Test
+    public void giveninitBoardState_whenGetAllPossibleStates_thenNonEmptyList() {
+        State initState = gameTree.getRoot().getState();
+        List<State> possibleStates = initState.getAllPossibleStates();
+        assertTrue(possibleStates.size() > 0);
+    }
+
+    @Test
+    public void givenEmptyBoard_whenPerformMove_thenLessAvailablePossitions() {
+        Board board = new Board();
+        int initAvailablePositions = board.getEmptyPositions().size();
+        board.performMove(Board.P1, new Position(1, 1));
+        int availablePositions = board.getEmptyPositions().size();
+        assertTrue(initAvailablePositions > availablePositions);
+    }
+
+    @Test
+    public void givenEmptyBoard_whenSimulateInterAIPlay_thenGameDraw() {
+        Board board = new Board();
+
+        int player = Board.P1;
+        int totalMoves = Board.DEFAULT_BOARD_SIZE * Board.DEFAULT_BOARD_SIZE;
+        for (int i = 0; i < totalMoves; i++) {
+            board = mcts.findNextMove(board, player);
+            if (board.checkStatus() != -1) {
+                break;
+            }
+            player = 3 - player;
+        }
+        int winStatus = board.checkStatus();
+        assertEquals(winStatus, Board.DRAW);
+    }
+
+    @Test
+    public void givenEmptyBoard_whenLevel1VsLevel3_thenLevel3WinsOrDraw() {
+        Board board = new Board();
+        MonteCarloTreeSearch mcts1 = new MonteCarloTreeSearch();
+        mcts1.setLevel(1);
+        MonteCarloTreeSearch mcts3 = new MonteCarloTreeSearch();
+        mcts3.setLevel(3);
+
+        int player = Board.P1;
+        int totalMoves = Board.DEFAULT_BOARD_SIZE * Board.DEFAULT_BOARD_SIZE;
+        for (int i = 0; i < totalMoves; i++) {
+            if (player == Board.P1)
+                board = mcts3.findNextMove(board, player);
+            else
+                board = mcts1.findNextMove(board, player);
+
+            if (board.checkStatus() != -1) {
+                break;
+            }
+            player = 3 - player;
+        }
+        int winStatus = board.checkStatus();
+        assertTrue(winStatus == Board.DRAW || winStatus == Board.P1);
+    }
+
+}

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-package com.baeldung.automata;`
	`1`	`+package com.baeldung.algorithms.automata;`
`2`	`2`
`3`	`3`	`/**`
`4`	`4`	`* Finite state machine.`
Original file line number	Diff line number	Diff line change
`@@ -7,10 +7,10 @@`
`7`	`7`	`import com.baeldung.algorithms.mcts.tictactoe.Position;`
`8`	`8`
`9`	`9`	`public class State {`
`10`		`- Board board;`
`11`		`- int playerNo;`
`12`		`- int visitCount;`
`13`		`- double winScore;`
	`10`	`+ private Board board;`
	`11`	`+ private int playerNo;`
	`12`	`+ private int visitCount;`
	`13`	`+ private double winScore;`
`14`	`14`
`15`	`15`	`public State() {`
`16`	`16`	`board = new Board();`
`@@ -27,23 +27,23 @@ public State(Board board) {`
`27`	`27`	`this.board = new Board(board);`
`28`	`28`	`}`
`29`	`29`
`30`		`- public Board getBoard() {`
	`30`	`+ Board getBoard() {`
`31`	`31`	`return board;`
`32`	`32`	`}`
`33`	`33`
`34`		`- public void setBoard(Board board) {`
	`34`	`+ void setBoard(Board board) {`
`35`	`35`	`this.board = board;`
`36`	`36`	`}`
`37`	`37`
`38`		`- public int getPlayerNo() {`
	`38`	`+ int getPlayerNo() {`
`39`	`39`	`return playerNo;`
`40`	`40`	`}`
`41`	`41`
`42`		`- public void setPlayerNo(int playerNo) {`
	`42`	`+ void setPlayerNo(int playerNo) {`
`43`	`43`	`this.playerNo = playerNo;`
`44`	`44`	`}`
`45`	`45`
`46`		`- public int getOpponent() {`
	`46`	`+ int getOpponent() {`
`47`	`47`	`return 3 - playerNo;`
`48`	`48`	`}`
`49`	`49`
`@@ -55,11 +55,11 @@ public void setVisitCount(int visitCount) {`
`55`	`55`	`this.visitCount = visitCount;`
`56`	`56`	`}`
`57`	`57`
`58`		`- public double getWinScore() {`
	`58`	`+ double getWinScore() {`
`59`	`59`	`return winScore;`
`60`	`60`	`}`
`61`	`61`
`62`		`- public void setWinScore(double winScore) {`
	`62`	`+ void setWinScore(double winScore) {`
`63`	`63`	`this.winScore = winScore;`
`64`	`64`	`}`
`65`	`65`
`@@ -75,23 +75,23 @@ public List<State> getAllPossibleStates() {`
`75`	`75`	`return possibleStates;`
`76`	`76`	`}`
`77`	`77`
`78`		`- public void incrementVisit() {`
	`78`	`+ void incrementVisit() {`
`79`	`79`	`this.visitCount++;`
`80`	`80`	`}`
`81`	`81`
`82`		`- public void addScore(double score) {`
	`82`	`+ void addScore(double score) {`
`83`	`83`	`if (this.winScore != Integer.MIN_VALUE)`
`84`	`84`	`this.winScore += score;`
`85`	`85`	`}`
`86`	`86`
`87`		`- public void randomPlay() {`
	`87`	`+ void randomPlay() {`
`88`	`88`	`List<Position> availablePositions = this.board.getEmptyPositions();`
`89`	`89`	`int totalPossibilities = availablePositions.size();`
`90`	`90`	`int selectRandom = (int) (Math.random() * ((totalPossibilities - 1) + 1));`
`91`	`91`	`this.board.performMove(this.playerNo, availablePositions.get(selectRandom));`
`92`	`92`	`}`
`93`	`93`
`94`		`- public void togglePlayer() {`
	`94`	`+ void togglePlayer() {`
`95`	`95`	`this.playerNo = 3 - this.playerNo;`
`96`	`96`	`}`
`97`	`97`	`}`