v0.0.11 Pushed current edition to the ability to launch (a lot of additions)

Author: CameleoGrey

examples/object_oriented/nqueens/persistence/CotwinBuilder.py renamed to examples/object_oriented/nqueens/persistence/CotwinBuilderNQueens.py

@@ -1,14 +1,18 @@
+
+
+
+from greyjack.persistence.CotwinBuilderBase import CotwinBuilderBase
 from examples.object_oriented.nqueens.cotwin.NQueensCotwin import NQueensCotwin
 from examples.object_oriented.nqueens.score.NQueensScoreCalculator import NQueensScoreCalculator
 from examples.object_oriented.nqueens.cotwin.CotQueen import CotQueen
 from greyjack.variables.GJInteger import GJInteger
 
 
-class CotwinBuilder():
+class CotwinBuilderNQueens(CotwinBuilderBase):
     def __init__(self):
         pass
 
-    def build_cotwin(self, domain_model):
+    def build_cotwin(self, domain_model, is_already_initialized):
 
         n = domain_model.n
         queens = domain_model.queens
@@ -23,7 +27,7 @@ def build_cotwin(self, domain_model):
 
         nqueens_cotwin = NQueensCotwin()
         nqueens_cotwin.add_planning_entities_list( cot_queens, "queens" )
-        nqueens_cotwin.add_score_calculator( NQueensScoreCalculator(), "nqueens_score_calculator" )
+        nqueens_cotwin.set_score_calculator( NQueensScoreCalculator() )
 
         return nqueens_cotwin
 

examples/object_oriented/nqueens/persistence/DomainBuilderNQueens.py

@@ -0,0 +1,44 @@
+
+import random
+
+from greyjack.persistence.DomainBuilderBase import DomainBuilderBase
+from examples.object_oriented.nqueens.domain.ChessField import ChessField
+from examples.object_oriented.nqueens.domain.Position import Position
+from examples.object_oriented.nqueens.domain.Row import Row
+from examples.object_oriented.nqueens.domain.Column import Column
+from examples.object_oriented.nqueens.domain.Queen import Queen
+
+
+class DomainBuilderNQueens(DomainBuilderBase):
+
+    def __init__(self, n, random_seed=45):
+        super().__init__()
+
+        self.n_queens = n
+        self.random_seed = random_seed
+
+    def build_domain_from_scratch(self):
+
+        random.seed(self.random_seed)
+
+        queens = []
+        random_row_ids = list(range(self.n_queens))
+        random.shuffle( random_row_ids )
+        column_ids = list(range(self.n_queens))
+        for i in range(self.n_queens):
+            current_row_id = random_row_ids[i]
+            current_column_id = column_ids[i]
+            current_queen = Queen( Row(current_row_id), Column(current_column_id) )
+            queens.append( current_queen )
+
+        chess_field = ChessField( self.n_queens, queens )
+
+        return chess_field
+    
+    def build_from_solution(self, solution):
+        raise Exception("build_from_solution() not implemented for DomainBuilderNQueens")
+    
+    def build_from_domain(self, domain):
+        return super().build_from_domain(domain)
+
+

examples/object_oriented/nqueens/persistence/DomainGenerator.py

@@ -0,0 +1,5 @@
+
+
+
+from greyjack.persistence.DomainBuilderBase import DomainBuilderBase
+from greyjack.persistence.CotwinBuilderBase import CotwinBuilderBase

examples/object_oriented/nqueens/persistence/DomainUpdater.py

@@ -14,12 +14,13 @@ def __init__(self):
 
         super().__init__()
 
+        self.score_type = "SimpleScore"
 
-        #self.constraints["different_rows"] = self.different_rows
-        #self.constraints["different_descending_diagonals"] = self.different_descending_diagonals
-        #self.constraints["different_ascending_diagonals"] = self.different_ascending_diagonals
+        #self.add_constraint("different_rows", self.different_rows)
+        #self.add_constraint("different_descending_diagonals", self.different_descending_diagonals)
+        #self.add_constraint("different_ascending_diagonals", self.different_ascending_diagonals)
 
-        self.constraints["all_different"] = self.all_different
+        self.add_constraint("all_different", self.all_different)
 
         pass
 

examples/object_oriented/nqueens/persistence/__init__.py

@@ -11,44 +11,33 @@
 
 from copy import deepcopy
 
-from examples.object_oriented.nqueens.persistence.DomainGenerator import DomainGenerator
-from examples.object_oriented.nqueens.persistence.CotwinBuilder import CotwinBuilder
-from examples.object_oriented.nqueens.persistence.DomainUpdater import DomainUpdater
-#from greyjack.score_calculation.scores.SimpleScore import SimpleScore
-#from greyjack.agents.termination_strategies import *
-#from greyjack.agents import *
-#from greyjack.Solver import Solver
-
+from examples.object_oriented.nqueens.persistence.DomainBuilderNQueens import DomainBuilderNQueens
+from examples.object_oriented.nqueens.persistence.CotwinBuilderNQueens import CotwinBuilderNQueens
+from greyjack.score_calculation.scores.SimpleScore import SimpleScore
+from greyjack.agents.termination_strategies import *
+from greyjack.agents import *
+from greyjack.Solver import Solver
+from greyjack.agents.TabuSearch import TabuSearch
 
 if __name__ == "__main__":
-    # build domain model
-    chess_field = DomainGenerator.generate_domain( 256, random_seed=45 )
-    #print( "Chess field before solving: " )
-    #print( chess_field )
 
-    # translate human-oriented domain model to solver-oriented model (cotwin)
-    nqueens_cotwin = CotwinBuilder().build_cotwin( chess_field )
+    # build domain model
+    domain_builder = DomainBuilderNQueens(256, random_seed=45)
+    cotwin_builder = CotwinBuilderNQueens()
 
-    #termination_strategy = StepsLimit(step_count_limit=5000)
-    """termination_strategy = TimeSpentLimit(time_seconds_limit=60)
+    #termination_strategy = StepsLimit(step_count_limit=1000)
+    #termination_strategy = TimeSpentLimit(time_seconds_limit=60)
     #termination_strategy = ScoreNoImprovement(time_seconds_limit=15)
-    #termination_strategy = ScoreLimit(score_to_compare=SimpleScore(0))
-    agent = TabuSearch(neighbours_count=20, tabu_entity_rate=0.0, 
+    termination_strategy = ScoreLimit(score_to_compare=[0])
+    agent = TabuSearch(neighbours_count=128, tabu_entity_rate=0.0, 
                        mutation_rate_multiplier=None, move_probas=None, 
                        migration_frequency=1, termination_strategy=termination_strategy)
 
-
-    agents_list = [deepcopy(agent) for i in range(10)]
-    solver = Solver(agents=agents_list, score_precision=[0], logging_level="info", 
-                    parallelization_backend="processing", #processing, threading
-                    random_seed=45)
-    solution = solver.solve( model=nqueens_cotwin )
+    solver = Solver(domain_builder, cotwin_builder, agent, 
+                    n_jobs=10, parallelization_backend="processing", #processing, threading 
+                    score_precision=[0], logging_level="info")
+    solution = solver.solve()
     print( "Cotwin solution looks that: " )
     print( solution )
 
-    # updating human-oriented domain model by solved cotwin model
-    chess_field = DomainUpdater.update_domain( chess_field, solution )
-    print( "Chess field after solving: " )
-    print( chess_field )"""
-
     print( "done" )