NUCS 2.2.0__tar.gz → 2.3.0__tar.gz

{nucs-2.2.0 → nucs-2.3.0/NUCS.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: NUCS
-Version: 2.2.0
+Version: 2.3.0
 Summary: A Numpy and Numba based Python library for solving Constraint Satisfaction Problems over finite domains
 Author-email: Yan Georget <yan.georget@gmail.com>
 Project-URL: Homepage, https://github.com/yangeorget/nucs
@@ -60,11 +60,11 @@ NUMBA_CACHE_DIR=.numba/cache python -m nucs.examples.queens -n 12 --log_level=IN
 2024-11-12 17:24:49,061 - INFO - nucs.solvers.backtrack_solver - Choice points stack has a maximal height of 128
 2024-11-12 17:24:49,200 - INFO - nucs.solvers.multiprocessing_solver - MultiprocessingSolver has 1 processors
 {
-    'OPTIMIZER_SOLUTION_NB': 0,
-    'PROBLEM_FILTER_NB': 262011,
-    'PROBLEM_SHAVING_NB': 0,
-    'PROBLEM_SHAVING_CHANGE_NB': 0,
-    'PROBLEM_SHAVING_NO_CHANGE_NB': 0,
+    'ALG_BC_NB': 262011,
+    'ALG_BC_WITH_SHAVING_NB': 0,
+    'ALG_SHAVING_NB': 0,
+    'ALG_SHAVING_CHANGE_NB': 0,
+    'ALG_SHAVING_NO_CHANGE_NB': 0,
     'PROPAGATOR_ENTAILMENT_NB': 0,
     'PROPAGATOR_FILTER_NB': 2269980,
     'PROPAGATOR_FILTER_NO_CHANGE_NB': 990450,
@@ -88,11 +88,11 @@ NUMBA_CACHE_DIR=.numba/cache python -m nucs.examples.bibd -v 8 -b 14 -r 7 -k 4 -
 2024-11-12 17:26:39,734 - INFO - nucs.solvers.backtrack_solver - BacktrackSolver uses consistency algorithm 0
 2024-11-12 17:26:39,734 - INFO - nucs.solvers.backtrack_solver - Choice points stack has a maximal height of 128
 {
-    'OPTIMIZER_SOLUTION_NB': 0,
-    'PROBLEM_FILTER_NB': 1425,
-    'PROBLEM_SHAVING_NB': 0,
-    'PROBLEM_SHAVING_CHANGE_NB': 0,
-    'PROBLEM_SHAVING_NO_CHANGE_NB': 0,
+    'ALG_BC_NB': 1425,
+    'ALG_BC_WITH_SHAVING_NB': 0,
+    'ALG_SHAVING_NB': 0,
+    'ALG_SHAVING_CHANGE_NB': 0,
+    'ALG_SHAVING_NO_CHANGE_NB': 0,
     'PROPAGATOR_ENTAILMENT_NB': 4711,
     'PROPAGATOR_FILTER_NB': 104392,
     'PROPAGATOR_FILTER_NO_CHANGE_NB': 73792,
@@ -127,11 +127,11 @@ NUMBA_CACHE_DIR=.numba/cache python -m nucs.examples.golomb -n 10 --symmetry_bre
 2024-11-12 17:27:45,717 - INFO - nucs.solvers.backtrack_solver - Found a (new) solution: 60
 2024-11-12 17:27:45,977 - INFO - nucs.solvers.backtrack_solver - Found a (new) solution: 55
 {
-    'OPTIMIZER_SOLUTION_NB': 10,
-    'PROBLEM_FILTER_NB': 22652,
-    'PROBLEM_SHAVING_NB': 0,
-    'PROBLEM_SHAVING_CHANGE_NB': 0,
-    'PROBLEM_SHAVING_NO_CHANGE_NB': 0,
+    'ALG_BC_NB': 22652,
+    'ALG_BC_WITH_SHAVING_NB': 0,
+    'ALG_SHAVING_NB': 0,
+    'ALG_SHAVING_CHANGE_NB': 0,
+    'ALG_SHAVING_NO_CHANGE_NB': 0,
     'PROPAGATOR_ENTAILMENT_NB': 107911,
     'PROPAGATOR_FILTER_NB': 2813035,
     'PROPAGATOR_FILTER_NO_CHANGE_NB': 1745836,

{nucs-2.2.0 → nucs-2.3.0}/NUCS.egg-info/SOURCES.txt

@@ -11,7 +11,6 @@ nucs/__init__.py
 nucs/constants.py
 nucs/numba_helper.py
 nucs/numpy_helper.py
-nucs/statistics.py
 nucs/examples/__init__.py
 nucs/examples/alpha/__init__.py
 nucs/examples/alpha/__main__.py

{nucs-2.2.0/NUCS.egg-info → nucs-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: NUCS
-Version: 2.2.0
+Version: 2.3.0
 Summary: A Numpy and Numba based Python library for solving Constraint Satisfaction Problems over finite domains
 Author-email: Yan Georget <yan.georget@gmail.com>
 Project-URL: Homepage, https://github.com/yangeorget/nucs
@@ -60,11 +60,11 @@ NUMBA_CACHE_DIR=.numba/cache python -m nucs.examples.queens -n 12 --log_level=IN
 2024-11-12 17:24:49,061 - INFO - nucs.solvers.backtrack_solver - Choice points stack has a maximal height of 128
 2024-11-12 17:24:49,200 - INFO - nucs.solvers.multiprocessing_solver - MultiprocessingSolver has 1 processors
 {
-    'OPTIMIZER_SOLUTION_NB': 0,
-    'PROBLEM_FILTER_NB': 262011,
-    'PROBLEM_SHAVING_NB': 0,
-    'PROBLEM_SHAVING_CHANGE_NB': 0,
-    'PROBLEM_SHAVING_NO_CHANGE_NB': 0,
+    'ALG_BC_NB': 262011,
+    'ALG_BC_WITH_SHAVING_NB': 0,
+    'ALG_SHAVING_NB': 0,
+    'ALG_SHAVING_CHANGE_NB': 0,
+    'ALG_SHAVING_NO_CHANGE_NB': 0,
     'PROPAGATOR_ENTAILMENT_NB': 0,
     'PROPAGATOR_FILTER_NB': 2269980,
     'PROPAGATOR_FILTER_NO_CHANGE_NB': 990450,
@@ -88,11 +88,11 @@ NUMBA_CACHE_DIR=.numba/cache python -m nucs.examples.bibd -v 8 -b 14 -r 7 -k 4 -
 2024-11-12 17:26:39,734 - INFO - nucs.solvers.backtrack_solver - BacktrackSolver uses consistency algorithm 0
 2024-11-12 17:26:39,734 - INFO - nucs.solvers.backtrack_solver - Choice points stack has a maximal height of 128
 {
-    'OPTIMIZER_SOLUTION_NB': 0,
-    'PROBLEM_FILTER_NB': 1425,
-    'PROBLEM_SHAVING_NB': 0,
-    'PROBLEM_SHAVING_CHANGE_NB': 0,
-    'PROBLEM_SHAVING_NO_CHANGE_NB': 0,
+    'ALG_BC_NB': 1425,
+    'ALG_BC_WITH_SHAVING_NB': 0,
+    'ALG_SHAVING_NB': 0,
+    'ALG_SHAVING_CHANGE_NB': 0,
+    'ALG_SHAVING_NO_CHANGE_NB': 0,
     'PROPAGATOR_ENTAILMENT_NB': 4711,
     'PROPAGATOR_FILTER_NB': 104392,
     'PROPAGATOR_FILTER_NO_CHANGE_NB': 73792,
@@ -127,11 +127,11 @@ NUMBA_CACHE_DIR=.numba/cache python -m nucs.examples.golomb -n 10 --symmetry_bre
 2024-11-12 17:27:45,717 - INFO - nucs.solvers.backtrack_solver - Found a (new) solution: 60
 2024-11-12 17:27:45,977 - INFO - nucs.solvers.backtrack_solver - Found a (new) solution: 55
 {
-    'OPTIMIZER_SOLUTION_NB': 10,
-    'PROBLEM_FILTER_NB': 22652,
-    'PROBLEM_SHAVING_NB': 0,
-    'PROBLEM_SHAVING_CHANGE_NB': 0,
-    'PROBLEM_SHAVING_NO_CHANGE_NB': 0,
+    'ALG_BC_NB': 22652,
+    'ALG_BC_WITH_SHAVING_NB': 0,
+    'ALG_SHAVING_NB': 0,
+    'ALG_SHAVING_CHANGE_NB': 0,
+    'ALG_SHAVING_NO_CHANGE_NB': 0,
     'PROPAGATOR_ENTAILMENT_NB': 107911,
     'PROPAGATOR_FILTER_NB': 2813035,
     'PROPAGATOR_FILTER_NO_CHANGE_NB': 1745836,

{nucs-2.2.0 → nucs-2.3.0}/README.md

@@ -38,11 +38,11 @@ NUMBA_CACHE_DIR=.numba/cache python -m nucs.examples.queens -n 12 --log_level=IN
 2024-11-12 17:24:49,061 - INFO - nucs.solvers.backtrack_solver - Choice points stack has a maximal height of 128
 2024-11-12 17:24:49,200 - INFO - nucs.solvers.multiprocessing_solver - MultiprocessingSolver has 1 processors
 {
-    'OPTIMIZER_SOLUTION_NB': 0,
-    'PROBLEM_FILTER_NB': 262011,
-    'PROBLEM_SHAVING_NB': 0,
-    'PROBLEM_SHAVING_CHANGE_NB': 0,
-    'PROBLEM_SHAVING_NO_CHANGE_NB': 0,
+    'ALG_BC_NB': 262011,
+    'ALG_BC_WITH_SHAVING_NB': 0,
+    'ALG_SHAVING_NB': 0,
+    'ALG_SHAVING_CHANGE_NB': 0,
+    'ALG_SHAVING_NO_CHANGE_NB': 0,
     'PROPAGATOR_ENTAILMENT_NB': 0,
     'PROPAGATOR_FILTER_NB': 2269980,
     'PROPAGATOR_FILTER_NO_CHANGE_NB': 990450,
@@ -66,11 +66,11 @@ NUMBA_CACHE_DIR=.numba/cache python -m nucs.examples.bibd -v 8 -b 14 -r 7 -k 4 -
 2024-11-12 17:26:39,734 - INFO - nucs.solvers.backtrack_solver - BacktrackSolver uses consistency algorithm 0
 2024-11-12 17:26:39,734 - INFO - nucs.solvers.backtrack_solver - Choice points stack has a maximal height of 128
 {
-    'OPTIMIZER_SOLUTION_NB': 0,
-    'PROBLEM_FILTER_NB': 1425,
-    'PROBLEM_SHAVING_NB': 0,
-    'PROBLEM_SHAVING_CHANGE_NB': 0,
-    'PROBLEM_SHAVING_NO_CHANGE_NB': 0,
+    'ALG_BC_NB': 1425,
+    'ALG_BC_WITH_SHAVING_NB': 0,
+    'ALG_SHAVING_NB': 0,
+    'ALG_SHAVING_CHANGE_NB': 0,
+    'ALG_SHAVING_NO_CHANGE_NB': 0,
     'PROPAGATOR_ENTAILMENT_NB': 4711,
     'PROPAGATOR_FILTER_NB': 104392,
     'PROPAGATOR_FILTER_NO_CHANGE_NB': 73792,
@@ -105,11 +105,11 @@ NUMBA_CACHE_DIR=.numba/cache python -m nucs.examples.golomb -n 10 --symmetry_bre
 2024-11-12 17:27:45,717 - INFO - nucs.solvers.backtrack_solver - Found a (new) solution: 60
 2024-11-12 17:27:45,977 - INFO - nucs.solvers.backtrack_solver - Found a (new) solution: 55
 {
-    'OPTIMIZER_SOLUTION_NB': 10,
-    'PROBLEM_FILTER_NB': 22652,
-    'PROBLEM_SHAVING_NB': 0,
-    'PROBLEM_SHAVING_CHANGE_NB': 0,
-    'PROBLEM_SHAVING_NO_CHANGE_NB': 0,
+    'ALG_BC_NB': 22652,
+    'ALG_BC_WITH_SHAVING_NB': 0,
+    'ALG_SHAVING_NB': 0,
+    'ALG_SHAVING_CHANGE_NB': 0,
+    'ALG_SHAVING_NO_CHANGE_NB': 0,
     'PROPAGATOR_ENTAILMENT_NB': 107911,
     'PROPAGATOR_FILTER_NB': 2813035,
     'PROPAGATOR_FILTER_NO_CHANGE_NB': 1745836,

{nucs-2.2.0 → nucs-2.3.0}/docs/source/conf.py

@@ -6,8 +6,8 @@ project = 'NUCS'
 copyright = '2024, Yan Georget'
 author = 'Yan Georget'
 
-release = '2.2.0'
-version = '2.2.0'
+release = '2.3.0'
+version = '2.3.0'
 
 # -- General configuration
 

{nucs-2.2.0 → nucs-2.3.0}/nucs/constants.py

@@ -64,3 +64,34 @@ LOG_LEVEL_WARNING = "WARNING"
 LOG_LEVEL_ERROR = "ERROR"
 LOG_LEVEL_CRITICAL = "CRITICAL"
 LOG_LEVELS = [LOG_LEVEL_DEBUG, LOG_LEVEL_INFO, LOG_LEVEL_WARNING, LOG_LEVEL_ERROR, LOG_LEVEL_CRITICAL]
+
+STATS_MAX = 13
+(
+    STATS_IDX_ALG_BC_NB,
+    STATS_IDX_ALG_BC_WITH_SHAVING_NB,
+    STATS_IDX_ALG_SHAVING_NB,
+    STATS_IDX_ALG_SHAVING_CHANGE_NB,
+    STATS_IDX_ALG_SHAVING_NO_CHANGE_NB,
+    STATS_IDX_PROPAGATOR_ENTAILMENT_NB,
+    STATS_IDX_PROPAGATOR_FILTER_NB,
+    STATS_IDX_PROPAGATOR_FILTER_NO_CHANGE_NB,
+    STATS_IDX_PROPAGATOR_INCONSISTENCY_NB,
+    STATS_IDX_SOLVER_BACKTRACK_NB,
+    STATS_IDX_SOLVER_CHOICE_NB,
+    STATS_IDX_SOLVER_CHOICE_DEPTH,
+    STATS_IDX_SOLVER_SOLUTION_NB,
+) = tuple(range(STATS_MAX))
+
+STATS_LBL_ALG_BC_NB = "ALG_BC_NB"
+STATS_LBL_ALG_BC_WITH_SHAVING_NB = "ALG_BC_WITH_SHAVING_NB"
+STATS_LBL_ALG_SHAVING_NB = "ALG_SHAVING_NB"
+STATS_LBL_ALG_SHAVING_CHANGE_NB = "ALG_SHAVING_CHANGE_NB"
+STATS_LBL_ALG_SHAVING_NO_CHANGE_NB = "ALG_SHAVING_NO_CHANGE_NB"
+STATS_LBL_PROPAGATOR_ENTAILMENT_NB = "PROPAGATOR_ENTAILMENT_NB"
+STATS_LBL_PROPAGATOR_FILTER_NB = "PROPAGATOR_FILTER_NB"
+STATS_LBL_PROPAGATOR_FILTER_NO_CHANGE_NB = "PROPAGATOR_FILTER_NO_CHANGE_NB"
+STATS_LBL_PROPAGATOR_INCONSISTENCY_NB = "PROPAGATOR_INCONSISTENCY_NB"
+STATS_LBL_SOLVER_BACKTRACK_NB = "SOLVER_BACKTRACK_NB"
+STATS_LBL_SOLVER_CHOICE_NB = "SOLVER_CHOICE_NB"
+STATS_LBL_SOLVER_CHOICE_DEPTH = "SOLVER_CHOICE_DEPTH"
+STATS_LBL_SOLVER_SOLUTION_NB = "SOLVER_SOLUTION_NB"

{nucs-2.2.0 → nucs-2.3.0}/nucs/examples/alpha/__main__.py

@@ -18,10 +18,9 @@ from nucs.constants import LOG_LEVEL_INFO, LOG_LEVELS
 from nucs.examples.alpha.alpha_problem import AlphaProblem
 from nucs.solvers.backtrack_solver import BacktrackSolver
 from nucs.solvers.heuristics import DOM_HEURISTIC_MIN_VALUE, VAR_HEURISTIC_SMALLEST_DOMAIN
-from nucs.statistics import get_statistics
 
 # Run with the following command (the second run is much faster because the code has been compiled):
-# NUMBA_CACHE_DIR=.numba/cache PYTHONPATH=. python -m nucs.examples.alpha
+# NUMBA_CACHE_DIR=.numba/cache python -m nucs.examples.alpha
 if __name__ == "__main__":
     parser = argparse.ArgumentParser()
     parser.add_argument("--log_level", choices=LOG_LEVELS, default=LOG_LEVEL_INFO)
@@ -34,5 +33,5 @@ if __name__ == "__main__":
         log_level=args.log_level,
     )
     solutions = solver.find_all()
-    print(get_statistics(solver.statistics))
+    print(solver.get_statistics())
     print(problem.solution_as_dict(solutions[0]))

{nucs-2.2.0 → nucs-2.3.0}/nucs/examples/bibd/__main__.py

@@ -18,10 +18,9 @@ from nucs.constants import LOG_LEVEL_INFO, LOG_LEVELS
 from nucs.examples.bibd.bibd_problem import BIBDProblem
 from nucs.solvers.backtrack_solver import BacktrackSolver
 from nucs.solvers.heuristics import DOM_HEURISTIC_MAX_VALUE
-from nucs.statistics import get_statistics
 
 # Run with the following command (the second run is much faster because the code has been compiled):
-# NUMBA_CACHE_DIR=.numba/cache PYTHONPATH=. python -m nucs.examples.bibd -v 8 -b 14 -r 7 -k 4 -l 3 --symmetry_breaking
+# NUMBA_CACHE_DIR=.numba/cache python -m nucs.examples.bibd -v 8 -b 14 -r 7 -k 4 -l 3 --symmetry_breaking
 if __name__ == "__main__":
     parser = argparse.ArgumentParser()
     parser.add_argument("-v", type=int)
@@ -35,4 +34,4 @@ if __name__ == "__main__":
     problem = BIBDProblem(args.v, args.b, args.r, args.k, args.l, args.symmetry_breaking)
     solver = BacktrackSolver(problem, dom_heuristic_idx=DOM_HEURISTIC_MAX_VALUE, log_level=args.log_level)
     solver.solve_all()
-    print(get_statistics(solver.statistics))
+    print(solver.get_statistics())

{nucs-2.2.0 → nucs-2.3.0}/nucs/examples/donald/__main__.py

@@ -18,10 +18,9 @@ from nucs.constants import LOG_LEVEL_INFO, LOG_LEVELS
 from nucs.examples.donald.donald_problem import DonaldProblem
 from nucs.solvers.backtrack_solver import BacktrackSolver
 from nucs.solvers.heuristics import DOM_HEURISTIC_MIN_VALUE, VAR_HEURISTIC_SMALLEST_DOMAIN
-from nucs.statistics import get_statistics
 
 # Run with the following command (the second run is much faster because the code has been compiled):
-# NUMBA_CACHE_DIR=.numba/cache PYTHONPATH=. python -m nucs.examples.donald
+# NUMBA_CACHE_DIR=.numba/cache python -m nucs.examples.donald
 if __name__ == "__main__":
     parser = argparse.ArgumentParser()
     parser.add_argument("--log_level", choices=LOG_LEVELS, default=LOG_LEVEL_INFO)
@@ -33,6 +32,6 @@ if __name__ == "__main__":
         dom_heuristic_idx=DOM_HEURISTIC_MIN_VALUE,
         log_level=args.log_level,
     )
-    print(get_statistics(solver.statistics))
+    print(solver.get_statistics())
     for solution in solver.solve():
         print(problem.solution_as_dict(solution))

{nucs-2.2.0 → nucs-2.3.0}/nucs/examples/golomb/__main__.py

@@ -18,10 +18,9 @@ from nucs.constants import LOG_LEVEL_INFO, LOG_LEVELS
 from nucs.examples.golomb.golomb_problem import GolombProblem, golomb_consistency_algorithm
 from nucs.solvers.backtrack_solver import BacktrackSolver
 from nucs.solvers.consistency_algorithms import register_consistency_algorithm
-from nucs.statistics import get_statistics
 
 # Run with the following command (the second run is much faster because the code has been compiled):
-# NUMBA_CACHE_DIR=.numba/cache PYTHONPATH=. python -m nucs.examples.golomb -n 10 --symmetry_breaking
+# NUMBA_CACHE_DIR=.numba/cache python -m nucs.examples.golomb -n 10 --symmetry_breaking
 if __name__ == "__main__":
     parser = argparse.ArgumentParser()
     parser.add_argument("-n", type=int, default=10)
@@ -32,6 +31,6 @@ if __name__ == "__main__":
     consistency_alg_golomb = register_consistency_algorithm(golomb_consistency_algorithm)
     solver = BacktrackSolver(problem, consistency_alg_idx=consistency_alg_golomb, log_level=args.log_level)
     solution = solver.minimize(problem.length_idx)
-    print(get_statistics(solver.statistics))
+    print(solver.get_statistics())
     if solution is not None:
         print(solution[: (args.n - 1)])

{nucs-2.2.0 → nucs-2.3.0}/nucs/examples/knapsack/__main__.py

@@ -18,10 +18,9 @@ from nucs.constants import LOG_LEVEL_INFO, LOG_LEVELS
 from nucs.examples.knapsack.knapsack_problem import KnapsackProblem
 from nucs.solvers.backtrack_solver import BacktrackSolver
 from nucs.solvers.heuristics import DOM_HEURISTIC_MAX_VALUE, VAR_HEURISTIC_FIRST_NOT_INSTANTIATED
-from nucs.statistics import get_statistics
 
 # Run with the following command (the second run is much faster because the code has been compiled):
-# NUMBA_CACHE_DIR=.numba/cache PYTHONPATH=. python -m nucs.examples.knapsack
+# NUMBA_CACHE_DIR=.numba/cache python -m nucs.examples.knapsack
 if __name__ == "__main__":
     parser = argparse.ArgumentParser()
     parser.add_argument("--log_level", choices=LOG_LEVELS, default=LOG_LEVEL_INFO)
@@ -38,5 +37,5 @@ if __name__ == "__main__":
         log_level=args.log_level,
     )
     solution = solver.maximize(problem.weight)
-    print(get_statistics(solver.statistics))
+    print(solver.get_statistics())
     print(solution)

{nucs-2.2.0 → nucs-2.3.0}/nucs/examples/magic_sequence/__main__.py

@@ -18,10 +18,9 @@ from nucs.constants import LOG_LEVEL_INFO, LOG_LEVELS
 from nucs.examples.magic_sequence.magic_sequence_problem import MagicSequenceProblem
 from nucs.solvers.backtrack_solver import BacktrackSolver
 from nucs.solvers.heuristics import DOM_HEURISTIC_MIN_VALUE, VAR_HEURISTIC_LAST_NOT_INSTANTIATED
-from nucs.statistics import get_statistics
 
 # Run with the following command (the second run is much faster because the code has been compiled):
-# NUMBA_CACHE_DIR=.numba/cache PYTHONPATH=. python -m nucs.examples.magic_sequence -n 100
+# NUMBA_CACHE_DIR=.numba/cache python -m nucs.examples.magic_sequence -n 100
 if __name__ == "__main__":
     parser = argparse.ArgumentParser()
     parser.add_argument("-n", type=int, default=100)
@@ -35,4 +34,4 @@ if __name__ == "__main__":
         log_level=args.log_level,
     )
     solver.solve_all()
-    print(get_statistics(solver.statistics))
+    print(solver.get_statistics())

{nucs-2.2.0 → nucs-2.3.0}/nucs/examples/magic_square/__main__.py

@@ -18,10 +18,9 @@ from nucs.constants import LOG_LEVEL_INFO, LOG_LEVELS
 from nucs.examples.magic_square.magic_square_problem import MagicSquareProblem
 from nucs.solvers.backtrack_solver import BacktrackSolver
 from nucs.solvers.heuristics import DOM_HEURISTIC_MAX_VALUE, VAR_HEURISTIC_SMALLEST_DOMAIN
-from nucs.statistics import get_statistics
 
 # Run with the following command (the second run is much faster because the code has been compiled):
-# NUMBA_CACHE_DIR=.numba/cache PYTHONPATH=. python -m nucs.examples.magic_square -n 4 --symmetry_breaking
+# NUMBA_CACHE_DIR=.numba/cache python -m nucs.examples.magic_square -n 4 --symmetry_breaking
 if __name__ == "__main__":
     parser = argparse.ArgumentParser()
     parser.add_argument("-n", type=int)
@@ -36,4 +35,4 @@ if __name__ == "__main__":
         log_level=args.log_level,
     )
     solver.solve_all()
-    print(get_statistics(solver.statistics))
+    print(solver.get_statistics())

{nucs-2.2.0 → nucs-2.3.0}/nucs/examples/quasigroup/__main__.py

@@ -18,10 +18,9 @@ from nucs.constants import LOG_LEVEL_INFO, LOG_LEVELS
 from nucs.examples.quasigroup.quasigroup_problem import Quasigroup5Problem
 from nucs.solvers.backtrack_solver import BacktrackSolver
 from nucs.solvers.heuristics import DOM_HEURISTIC_MIN_VALUE, VAR_HEURISTIC_SMALLEST_DOMAIN
-from nucs.statistics import get_statistics
 
 # Run with the following command (the second run is much faster because the code has been compiled):
-# NUMBA_CACHE_DIR=.numba/cache PYTHONPATH=. python -m nucs.examples.quasigroup -n 10 --symmetry_breaking
+# NUMBA_CACHE_DIR=.numba/cache python -m nucs.examples.quasigroup -n 10 --symmetry_breaking
 if __name__ == "__main__":
     parser = argparse.ArgumentParser()
     parser.add_argument("-n", type=int, default=10)
@@ -36,4 +35,4 @@ if __name__ == "__main__":
         log_level=args.log_level,
     )
     solver.solve_all()
-    print(get_statistics(solver.statistics))
+    print(solver.get_statistics())

{nucs-2.2.0 → nucs-2.3.0}/nucs/examples/queens/__main__.py

@@ -20,10 +20,9 @@ from nucs.solvers.backtrack_solver import BacktrackSolver
 from nucs.solvers.consistency_algorithms import CONSISTENCY_ALG_BC, CONSISTENCY_ALG_SHAVING
 from nucs.solvers.heuristics import VAR_HEURISTIC_FIRST_NOT_INSTANTIATED, VAR_HEURISTIC_SMALLEST_DOMAIN
 from nucs.solvers.multiprocessing_solver import MultiprocessingSolver
-from nucs.statistics import get_statistics
 
 # Run with the following command (the second run is much faster because the code has been compiled):
-# NUMBA_CACHE_DIR=.numba/cache PYTHONPATH=. python -m nucs.examples.queens -n 10
+# NUMBA_CACHE_DIR=.numba/cache python -m nucs.examples.queens -n 10
 if __name__ == "__main__":
     parser = argparse.ArgumentParser()
     parser.add_argument("-n", type=int, default=10)
@@ -46,4 +45,4 @@ if __name__ == "__main__":
         ]
     )
     solver.solve_all()
-    print(get_statistics(solver.statistics))
+    print(solver.get_statistics())

{nucs-2.2.0 → nucs-2.3.0}/nucs/examples/schur_lemma/__main__.py

@@ -17,10 +17,9 @@ from rich import print
 from nucs.constants import LOG_LEVEL_INFO, LOG_LEVELS
 from nucs.examples.schur_lemma.schur_lemma_problem import SchurLemmaProblem
 from nucs.solvers.backtrack_solver import BacktrackSolver
-from nucs.statistics import get_statistics
 
 # Run with the following command (the second run is much faster because the code has been compiled):
-# NUMBA_CACHE_DIR=.numba/cache PYTHONPATH=. python -m nucs.examples.schur_lemma -n 20 --symmetry_breaking
+# NUMBA_CACHE_DIR=.numba/cache python -m nucs.examples.schur_lemma -n 20 --symmetry_breaking
 if __name__ == "__main__":
     parser = argparse.ArgumentParser()
     parser.add_argument("-n", type=int, default=20)
@@ -30,4 +29,4 @@ if __name__ == "__main__":
     problem = SchurLemmaProblem(args.n, args.symmetry_breaking)
     solver = BacktrackSolver(problem, log_level=args.log_level)
     solver.solve_all()
-    print(get_statistics(solver.statistics))
+    print(solver.get_statistics())

{nucs-2.2.0 → nucs-2.3.0}/nucs/examples/sports_tournament_scheduling/__main__.py

@@ -20,10 +20,9 @@ from nucs.examples.sports_tournament_scheduling.sports_tournament_scheduling_pro
 )
 from nucs.solvers.backtrack_solver import BacktrackSolver
 from nucs.solvers.heuristics import DOM_HEURISTIC_MIN_VALUE, VAR_HEURISTIC_SMALLEST_DOMAIN
-from nucs.statistics import get_statistics
 
 # Run with the following command (the second run is much faster because the code has been compiled):
-# NUMBA_CACHE_DIR=.numba/cache PYTHONPATH=. python -m nucs.examples.sports_tournament_scheduling -n 8
+# NUMBA_CACHE_DIR=.numba/cache python -m nucs.examples.sports_tournament_scheduling -n 8
 if __name__ == "__main__":
     parser = argparse.ArgumentParser()
     parser.add_argument("-n", type=int, default=8)
@@ -38,6 +37,6 @@ if __name__ == "__main__":
         log_level=args.log_level,
     )
     solution = next(solver.solve())
-    print(get_statistics(solver.statistics))
+    print(solver.get_statistics())
     if solution is not None:
         print(problem.solution_as_matrix(solution))

{nucs-2.2.0 → nucs-2.3.0}/nucs/solvers/backtrack_solver.py

@@ -12,7 +12,7 @@
 ###############################################################################
 import logging
 from multiprocessing import Queue
-from typing import Callable, Iterator, Optional, Tuple
+from typing import Callable, Dict, Iterator, Optional, Tuple
 
 import numpy as np
 from numba import njit  # type: ignore
@@ -28,6 +28,33 @@ from nucs.constants import (
     SIGNATURE_CONSISTENCY_ALG,
     SIGNATURE_DOM_HEURISTIC,
     SIGNATURE_VAR_HEURISTIC,
+    STATS_IDX_ALG_BC_NB,
+    STATS_IDX_ALG_BC_WITH_SHAVING_NB,
+    STATS_IDX_ALG_SHAVING_CHANGE_NB,
+    STATS_IDX_ALG_SHAVING_NB,
+    STATS_IDX_ALG_SHAVING_NO_CHANGE_NB,
+    STATS_IDX_PROPAGATOR_ENTAILMENT_NB,
+    STATS_IDX_PROPAGATOR_FILTER_NB,
+    STATS_IDX_PROPAGATOR_FILTER_NO_CHANGE_NB,
+    STATS_IDX_PROPAGATOR_INCONSISTENCY_NB,
+    STATS_IDX_SOLVER_BACKTRACK_NB,
+    STATS_IDX_SOLVER_CHOICE_DEPTH,
+    STATS_IDX_SOLVER_CHOICE_NB,
+    STATS_IDX_SOLVER_SOLUTION_NB,
+    STATS_LBL_ALG_BC_NB,
+    STATS_LBL_ALG_BC_WITH_SHAVING_NB,
+    STATS_LBL_ALG_SHAVING_CHANGE_NB,
+    STATS_LBL_ALG_SHAVING_NB,
+    STATS_LBL_ALG_SHAVING_NO_CHANGE_NB,
+    STATS_LBL_PROPAGATOR_ENTAILMENT_NB,
+    STATS_LBL_PROPAGATOR_FILTER_NB,
+    STATS_LBL_PROPAGATOR_FILTER_NO_CHANGE_NB,
+    STATS_LBL_PROPAGATOR_INCONSISTENCY_NB,
+    STATS_LBL_SOLVER_BACKTRACK_NB,
+    STATS_LBL_SOLVER_CHOICE_DEPTH,
+    STATS_LBL_SOLVER_CHOICE_NB,
+    STATS_LBL_SOLVER_SOLUTION_NB,
+    STATS_MAX,
     TYPE_CONSISTENCY_ALG,
     TYPE_DOM_HEURISTIC,
     TYPE_VAR_HEURISTIC,
@@ -44,33 +71,10 @@ from nucs.solvers.heuristics import (
     VAR_HEURISTIC_FIRST_NOT_INSTANTIATED,
 )
 from nucs.solvers.solver import Solver, decrease_max, get_solution, increase_min
-from nucs.statistics import (
-    STATS_IDX_OPTIMIZER_SOLUTION_NB,
-    STATS_IDX_SOLVER_CHOICE_DEPTH,
-    STATS_IDX_SOLVER_CHOICE_NB,
-    STATS_IDX_SOLVER_SOLUTION_NB,
-    init_statistics,
-)
 
 logger = logging.getLogger(__name__)
 
 
-def get_function_addresses() -> Tuple[NDArray, NDArray, NDArray, NDArray]:
-    """
-    Returns the addresses of the
-    compute_domains, variable heuristics, domain heuristics and consistency algorithms functions.
-    :return: a tuple of NDArrays
-    """
-    if NUMBA_DISABLE_JIT:
-        return np.empty(0), np.empty(0), np.empty(0), np.empty(0)
-    return (
-        np.array(build_function_address_list(COMPUTE_DOMAINS_FCTS, SIGNATURE_COMPUTE_DOMAINS)),
-        np.array(build_function_address_list(VAR_HEURISTIC_FCTS, SIGNATURE_VAR_HEURISTIC)),
-        np.array(build_function_address_list(DOM_HEURISTIC_FCTS, SIGNATURE_DOM_HEURISTIC)),
-        np.array(build_function_address_list(CONSISTENCY_ALG_FCTS, SIGNATURE_CONSISTENCY_ALG)),
-    )
-
-
 class BacktrackSolver(Solver):
     """
     A solver relying on a backtracking mechanism.
@@ -118,10 +122,27 @@ class BacktrackSolver(Solver):
         )
         logger.debug("Choice points initialized")
         logger.debug("Initializing statistics")
-        self.statistics = init_statistics()
+        self.statistics = np.array([0] * STATS_MAX, dtype=np.int64)
         logger.debug("Statistics initialized")
         logger.debug("BacktrackSolver initialized")
 
+    def get_statistics(self) -> Dict[str, int]:
+        return {
+            STATS_LBL_ALG_BC_NB: int(self.statistics[STATS_IDX_ALG_BC_NB]),
+            STATS_LBL_ALG_BC_WITH_SHAVING_NB: int(self.statistics[STATS_IDX_ALG_BC_WITH_SHAVING_NB]),
+            STATS_LBL_ALG_SHAVING_NB: int(self.statistics[STATS_IDX_ALG_SHAVING_NB]),
+            STATS_LBL_ALG_SHAVING_CHANGE_NB: int(self.statistics[STATS_IDX_ALG_SHAVING_CHANGE_NB]),
+            STATS_LBL_ALG_SHAVING_NO_CHANGE_NB: int(self.statistics[STATS_IDX_ALG_SHAVING_NO_CHANGE_NB]),
+            STATS_LBL_PROPAGATOR_ENTAILMENT_NB: int(self.statistics[STATS_IDX_PROPAGATOR_ENTAILMENT_NB]),
+            STATS_LBL_PROPAGATOR_FILTER_NB: int(self.statistics[STATS_IDX_PROPAGATOR_FILTER_NB]),
+            STATS_LBL_PROPAGATOR_FILTER_NO_CHANGE_NB: int(self.statistics[STATS_IDX_PROPAGATOR_FILTER_NO_CHANGE_NB]),
+            STATS_LBL_PROPAGATOR_INCONSISTENCY_NB: int(self.statistics[STATS_IDX_PROPAGATOR_INCONSISTENCY_NB]),
+            STATS_LBL_SOLVER_BACKTRACK_NB: int(self.statistics[STATS_IDX_SOLVER_BACKTRACK_NB]),
+            STATS_LBL_SOLVER_CHOICE_NB: int(self.statistics[STATS_IDX_SOLVER_CHOICE_NB]),
+            STATS_LBL_SOLVER_CHOICE_DEPTH: int(self.statistics[STATS_IDX_SOLVER_CHOICE_DEPTH]),
+            STATS_LBL_SOLVER_SOLUTION_NB: int(self.statistics[STATS_IDX_SOLVER_SOLUTION_NB]),
+        }
+
     def minimize(self, variable_idx: int) -> Optional[NDArray]:
         """
         Return the solution that minimizes a variable.
@@ -177,9 +198,8 @@ class BacktrackSolver(Solver):
                 dom_heuristic_addrs,
             )
         ) is not None:
-            logger.info(f"Found a (new) solution: {solution[variable_idx]}")
+            logger.info(f"Found a local optimum: {solution[variable_idx]}")
             best_solution = solution
-            self.statistics[STATS_IDX_OPTIMIZER_SOLUTION_NB] += 1
             reset(
                 self.problem,
                 self.shr_domains_stack,
@@ -303,8 +323,7 @@ class BacktrackSolver(Solver):
             )
             if solution is None:
                 break
-            logger.info(f"Found a (new) solution: {solution[variable_idx]}")
-            self.statistics[STATS_IDX_OPTIMIZER_SOLUTION_NB] += 1
+            logger.info(f"Found a local optimum: {solution[variable_idx]}")
             solution_queue.put((processor_idx, solution, self.statistics))
             reset(
                 self.problem,
@@ -509,3 +528,19 @@ def solve_one(
             shr_domains_propagators,
         ):
             return None
+
+
+def get_function_addresses() -> Tuple[NDArray, NDArray, NDArray, NDArray]:
+    """
+    Returns the addresses of the
+    compute_domains, variable heuristics, domain heuristics and consistency algorithms functions.
+    :return: a tuple of NDArrays
+    """
+    if NUMBA_DISABLE_JIT:
+        return np.empty(0), np.empty(0), np.empty(0), np.empty(0)
+    return (
+        np.array(build_function_address_list(COMPUTE_DOMAINS_FCTS, SIGNATURE_COMPUTE_DOMAINS)),
+        np.array(build_function_address_list(VAR_HEURISTIC_FCTS, SIGNATURE_VAR_HEURISTIC)),
+        np.array(build_function_address_list(DOM_HEURISTIC_FCTS, SIGNATURE_DOM_HEURISTIC)),
+        np.array(build_function_address_list(CONSISTENCY_ALG_FCTS, SIGNATURE_CONSISTENCY_ALG)),
+    )

{nucs-2.2.0 → nucs-2.3.0}/nucs/solvers/bound_consistency_algorithm.py

@@ -25,18 +25,16 @@ from nucs.constants import (
     PROP_ENTAILMENT,
     PROP_INCONSISTENCY,
     START,
-    TYPE_COMPUTE_DOMAINS,
-)
-from nucs.numba_helper import function_from_address
-from nucs.propagators.propagators import COMPUTE_DOMAINS_FCTS, add_propagators, pop_propagator
-from nucs.solvers.solver import is_solved
-from nucs.statistics import (
-    STATS_IDX_PROBLEM_FILTER_NB,
+    STATS_IDX_ALG_BC_NB,
     STATS_IDX_PROPAGATOR_ENTAILMENT_NB,
     STATS_IDX_PROPAGATOR_FILTER_NB,
     STATS_IDX_PROPAGATOR_FILTER_NO_CHANGE_NB,
     STATS_IDX_PROPAGATOR_INCONSISTENCY_NB,
+    TYPE_COMPUTE_DOMAINS,
 )
+from nucs.numba_helper import function_from_address
+from nucs.propagators.propagators import COMPUTE_DOMAINS_FCTS, add_propagators, pop_propagator
+from nucs.solvers.solver import is_solved
 
 
 @njit(cache=True)
@@ -81,7 +79,7 @@ def bound_consistency_algorithm(
     :param compute_domains_addrs: the addresses of the compute_domains functions
     :return: a status (consistency, inconsistency or entailment) as an integer
     """
-    statistics[STATS_IDX_PROBLEM_FILTER_NB] += 1
+    statistics[STATS_IDX_ALG_BC_NB] += 1
     prop_idx = -1
     while True:
         prop_idx = pop_propagator(triggered_propagators, prop_idx)

{nucs-2.2.0 → nucs-2.3.0}/nucs/solvers/choice_points.py

@@ -3,8 +3,8 @@ from typing import Optional
 from numba import njit  # type: ignore
 from numpy.typing import NDArray
 
+from nucs.constants import STATS_IDX_SOLVER_BACKTRACK_NB
 from nucs.propagators.propagators import add_propagators
-from nucs.statistics import STATS_IDX_SOLVER_BACKTRACK_NB
 
 
 @njit(cache=True)