NUCS 0.1__tar.gz → 0.1.2__tar.gz

{nucs-0.1 → nucs-0.1.2}/LICENSE.md

@@ -1,6 +1,6 @@
-MIT License
+# MIT License
 
-Copyright (c) 2024 Yan Georget
+## Copyright (c) 2024 Yan Georget
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

nucs-0.1.2/NUCS.egg-info/PKG-INFO

@@ -0,0 +1,140 @@
+Metadata-Version: 2.1
+Name: NUCS
+Version: 0.1.2
+Summary: A Numpy and Numba based Python library for solving Constraint Satifaction Problems
+Author-email: Yan Georget <yan.georget@gmail.com>
+Project-URL: Homepage, https://github.com/yangeorget/nucs
+Project-URL: Issues, https://github.com/yangeorget/nucs
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: numba==0.60.0
+Requires-Dist: numpy==2.0.1
+
+# NUCS
+
+## TLDR
+NUCS is a Python library for solving Constraint Satisfaction and Optimization Problems.
+Because it is 100% written in Python, NUCS is easy to install and use.
+NUCS is also very fast because it is powered by [Numpy](https://numpy.org/) and [Numba](https://numba.pydata.org/).
+
+With NUCS, in a few seconds you can ...
+
+Compute the 92 solutions to the BIBD(8,14,7,4,3) problem:
+```python
+{
+    'OPTIMIZER_SOLUTION_NB': 0,
+    'PROBLEM_FILTERS_NB': 2797,
+    'PROPAGATOR_ENTAILMENT_NB': 36977,
+    'PROPAGATOR_FILTERS_NB': 564122,
+    'PROPAGATOR_FILTERS_NO_CHANGE_NB': 534436,
+    'PROPAGATOR_INCONSISTENCY_NB': 1307,
+    'SOLVER_BACKTRACK_NB': 1398,
+    'SOLVER_CHOICE_DEPTH': 41,
+    'SOLVER_CHOICE_NB': 1398,
+    'SOLVER_SOLUTION_NB': 92
+}
+```
+Demonstrate that the optimal 10-marks Golomb ruler length is 55:
+```python
+{
+    'OPTIMIZER_SOLUTION_NB': 10,
+    'PROBLEM_FILTERS_NB': 49623,
+    'PROPAGATOR_ENTAILMENT_NB': 855996,
+    'PROPAGATOR_FILTERS_NB': 5160649,
+    'PROPAGATOR_FILTERS_NO_CHANGE_NB': 2893864,
+    'PROPAGATOR_INCONSISTENCY_NB': 24773,
+    'SOLVER_BACKTRACK_NB': 24772,
+    'SOLVER_CHOICE_DEPTH': 9,
+    'SOLVER_CHOICE_NB': 24840,
+    'SOLVER_SOLUTION_NB': 10
+}
+```
+Find all 14200 solutions to the 12-queens problem:
+```python
+{
+    'OPTIMIZER_SOLUTION_NB': 0,
+    'PROBLEM_FILTERS_NB': 262011,
+    'PROPAGATOR_ENTAILMENT_NB': 0,
+    'PROPAGATOR_FILTERS_NB': 1910609,
+    'PROPAGATOR_FILTERS_NO_CHANGE_NB': 631079,
+    'PROPAGATOR_INCONSISTENCY_NB': 116806,
+    'SOLVER_BACKTRACK_NB': 131005,
+    'SOLVER_CHOICE_DEPTH': 10,
+    'SOLVER_CHOICE_NB': 131005,
+    'SOLVER_SOLUTION_NB': 14200
+}
+```
+
+## How to use NUCS ?
+It is very simple to get started with NUCS.
+You can either install the Pip package or install NUCS from the sources.
+
+### Install the NUCS package
+Let's install the Pip package for NUCS:
+```bash
+pip install nucs
+````
+Now we can write the following `queens.py` program, 
+refer to [the technical documentation](DOCUMENTATION.md) to better understand how NUCS works under the hood:
+```python
+from nucs.problems.problem import Problem
+from nucs.solvers.backtrack_solver import BacktrackSolver
+from nucs.propagators.propagators import ALG_ALLDIFFERENT
+
+n = 8  # the number of queens
+problem = Problem(
+    shr_domains=[(0, n - 1)] * n,  # these n domains are shared between 3n variables with different offsets
+    dom_indices=list(range(n)) * 3,  # for each variable, its domain
+    dom_offsets=[0] * n + list(range(n)) + list(range(0, -n, -1))  # for each variable, its offset
+)
+problem.set_propagators([
+    (list(range(n)), ALG_ALLDIFFERENT, []), 
+    (list(range(n, 2 * n)), ALG_ALLDIFFERENT, []), 
+    (list(range(2 * n, 3 * n)), ALG_ALLDIFFERENT, [])
+])
+print(BacktrackSolver(problem).solve_one()[:n])
+```
+Let's run this model with the following command:
+```bash
+PYTHONPATH=. python queens.py
+```
+The first solution found is:
+```bash
+[0, 4, 7, 5, 2, 6, 1, 3]
+```
+> [!TIP]
+> Note that the second run will always be much faster since the Python code will already have been compiled and cached by Numba.
+
+### Install NUCS from the sources 
+Let's install NUCS from the sources by cloning the NUCS Github repository:
+```bash
+git clone https://github.com/yangeorget/nucs.git
+pip install -r requirements.txt
+```
+From there, we will launch some NUCS examples.
+
+#### Run some examples
+Some of the examples come with a command line interface and can be run directly.
+
+Let's find all solutions to the [12-queens problem](https://www.csplib.org/Problems/prob054/):
+```bash
+NUMBA_CACHE_DIR=.numba/cache PYTHONPATH=. python tests/examples/test_queens.py -n 12
+```
+
+Let's find the optimal solution to the [Golomb ruler problem](https://www.csplib.org/Problems/prob006/) with 10 marks:
+```bash
+NUMBA_CACHE_DIR=.numba/cache PYTHONPATH=. python tests/examples/test_golomb.py -n 10
+```
+
+## Other constraint solvers in Python
+### python-constraint
+_The Python constraint module offers solvers for Constraint Solving Problems (CSPs) over finite domains in simple and pure Python._
+
+### CCPMpy
+_CPMpy is a Constraint Programming and Modeling library in Python, based on numpy, with direct solver access._
+
+### PyCSP
+_PyCSP3 is a Python library for developping models of combinatorial constrained problems in a declarative manner; you can write models of constraint satisfaction (CSP) and constraint optimization (COP) problems._

nucs-0.1.2/PKG-INFO

@@ -0,0 +1,140 @@
+Metadata-Version: 2.1
+Name: NUCS
+Version: 0.1.2
+Summary: A Numpy and Numba based Python library for solving Constraint Satifaction Problems
+Author-email: Yan Georget <yan.georget@gmail.com>
+Project-URL: Homepage, https://github.com/yangeorget/nucs
+Project-URL: Issues, https://github.com/yangeorget/nucs
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: numba==0.60.0
+Requires-Dist: numpy==2.0.1
+
+# NUCS
+
+## TLDR
+NUCS is a Python library for solving Constraint Satisfaction and Optimization Problems.
+Because it is 100% written in Python, NUCS is easy to install and use.
+NUCS is also very fast because it is powered by [Numpy](https://numpy.org/) and [Numba](https://numba.pydata.org/).
+
+With NUCS, in a few seconds you can ...
+
+Compute the 92 solutions to the BIBD(8,14,7,4,3) problem:
+```python
+{
+    'OPTIMIZER_SOLUTION_NB': 0,
+    'PROBLEM_FILTERS_NB': 2797,
+    'PROPAGATOR_ENTAILMENT_NB': 36977,
+    'PROPAGATOR_FILTERS_NB': 564122,
+    'PROPAGATOR_FILTERS_NO_CHANGE_NB': 534436,
+    'PROPAGATOR_INCONSISTENCY_NB': 1307,
+    'SOLVER_BACKTRACK_NB': 1398,
+    'SOLVER_CHOICE_DEPTH': 41,
+    'SOLVER_CHOICE_NB': 1398,
+    'SOLVER_SOLUTION_NB': 92
+}
+```
+Demonstrate that the optimal 10-marks Golomb ruler length is 55:
+```python
+{
+    'OPTIMIZER_SOLUTION_NB': 10,
+    'PROBLEM_FILTERS_NB': 49623,
+    'PROPAGATOR_ENTAILMENT_NB': 855996,
+    'PROPAGATOR_FILTERS_NB': 5160649,
+    'PROPAGATOR_FILTERS_NO_CHANGE_NB': 2893864,
+    'PROPAGATOR_INCONSISTENCY_NB': 24773,
+    'SOLVER_BACKTRACK_NB': 24772,
+    'SOLVER_CHOICE_DEPTH': 9,
+    'SOLVER_CHOICE_NB': 24840,
+    'SOLVER_SOLUTION_NB': 10
+}
+```
+Find all 14200 solutions to the 12-queens problem:
+```python
+{
+    'OPTIMIZER_SOLUTION_NB': 0,
+    'PROBLEM_FILTERS_NB': 262011,
+    'PROPAGATOR_ENTAILMENT_NB': 0,
+    'PROPAGATOR_FILTERS_NB': 1910609,
+    'PROPAGATOR_FILTERS_NO_CHANGE_NB': 631079,
+    'PROPAGATOR_INCONSISTENCY_NB': 116806,
+    'SOLVER_BACKTRACK_NB': 131005,
+    'SOLVER_CHOICE_DEPTH': 10,
+    'SOLVER_CHOICE_NB': 131005,
+    'SOLVER_SOLUTION_NB': 14200
+}
+```
+
+## How to use NUCS ?
+It is very simple to get started with NUCS.
+You can either install the Pip package or install NUCS from the sources.
+
+### Install the NUCS package
+Let's install the Pip package for NUCS:
+```bash
+pip install nucs
+````
+Now we can write the following `queens.py` program, 
+refer to [the technical documentation](DOCUMENTATION.md) to better understand how NUCS works under the hood:
+```python
+from nucs.problems.problem import Problem
+from nucs.solvers.backtrack_solver import BacktrackSolver
+from nucs.propagators.propagators import ALG_ALLDIFFERENT
+
+n = 8  # the number of queens
+problem = Problem(
+    shr_domains=[(0, n - 1)] * n,  # these n domains are shared between 3n variables with different offsets
+    dom_indices=list(range(n)) * 3,  # for each variable, its domain
+    dom_offsets=[0] * n + list(range(n)) + list(range(0, -n, -1))  # for each variable, its offset
+)
+problem.set_propagators([
+    (list(range(n)), ALG_ALLDIFFERENT, []), 
+    (list(range(n, 2 * n)), ALG_ALLDIFFERENT, []), 
+    (list(range(2 * n, 3 * n)), ALG_ALLDIFFERENT, [])
+])
+print(BacktrackSolver(problem).solve_one()[:n])
+```
+Let's run this model with the following command:
+```bash
+PYTHONPATH=. python queens.py
+```
+The first solution found is:
+```bash
+[0, 4, 7, 5, 2, 6, 1, 3]
+```
+> [!TIP]
+> Note that the second run will always be much faster since the Python code will already have been compiled and cached by Numba.
+
+### Install NUCS from the sources 
+Let's install NUCS from the sources by cloning the NUCS Github repository:
+```bash
+git clone https://github.com/yangeorget/nucs.git
+pip install -r requirements.txt
+```
+From there, we will launch some NUCS examples.
+
+#### Run some examples
+Some of the examples come with a command line interface and can be run directly.
+
+Let's find all solutions to the [12-queens problem](https://www.csplib.org/Problems/prob054/):
+```bash
+NUMBA_CACHE_DIR=.numba/cache PYTHONPATH=. python tests/examples/test_queens.py -n 12
+```
+
+Let's find the optimal solution to the [Golomb ruler problem](https://www.csplib.org/Problems/prob006/) with 10 marks:
+```bash
+NUMBA_CACHE_DIR=.numba/cache PYTHONPATH=. python tests/examples/test_golomb.py -n 10
+```
+
+## Other constraint solvers in Python
+### python-constraint
+_The Python constraint module offers solvers for Constraint Solving Problems (CSPs) over finite domains in simple and pure Python._
+
+### CCPMpy
+_CPMpy is a Constraint Programming and Modeling library in Python, based on numpy, with direct solver access._
+
+### PyCSP
+_PyCSP3 is a Python library for developping models of combinatorial constrained problems in a declarative manner; you can write models of constraint satisfaction (CSP) and constraint optimization (COP) problems._

nucs-0.1.2/README.md

@@ -0,0 +1,125 @@
+# NUCS
+
+## TLDR
+NUCS is a Python library for solving Constraint Satisfaction and Optimization Problems.
+Because it is 100% written in Python, NUCS is easy to install and use.
+NUCS is also very fast because it is powered by [Numpy](https://numpy.org/) and [Numba](https://numba.pydata.org/).
+
+With NUCS, in a few seconds you can ...
+
+Compute the 92 solutions to the BIBD(8,14,7,4,3) problem:
+```python
+{
+    'OPTIMIZER_SOLUTION_NB': 0,
+    'PROBLEM_FILTERS_NB': 2797,
+    'PROPAGATOR_ENTAILMENT_NB': 36977,
+    'PROPAGATOR_FILTERS_NB': 564122,
+    'PROPAGATOR_FILTERS_NO_CHANGE_NB': 534436,
+    'PROPAGATOR_INCONSISTENCY_NB': 1307,
+    'SOLVER_BACKTRACK_NB': 1398,
+    'SOLVER_CHOICE_DEPTH': 41,
+    'SOLVER_CHOICE_NB': 1398,
+    'SOLVER_SOLUTION_NB': 92
+}
+```
+Demonstrate that the optimal 10-marks Golomb ruler length is 55:
+```python
+{
+    'OPTIMIZER_SOLUTION_NB': 10,
+    'PROBLEM_FILTERS_NB': 49623,
+    'PROPAGATOR_ENTAILMENT_NB': 855996,
+    'PROPAGATOR_FILTERS_NB': 5160649,
+    'PROPAGATOR_FILTERS_NO_CHANGE_NB': 2893864,
+    'PROPAGATOR_INCONSISTENCY_NB': 24773,
+    'SOLVER_BACKTRACK_NB': 24772,
+    'SOLVER_CHOICE_DEPTH': 9,
+    'SOLVER_CHOICE_NB': 24840,
+    'SOLVER_SOLUTION_NB': 10
+}
+```
+Find all 14200 solutions to the 12-queens problem:
+```python
+{
+    'OPTIMIZER_SOLUTION_NB': 0,
+    'PROBLEM_FILTERS_NB': 262011,
+    'PROPAGATOR_ENTAILMENT_NB': 0,
+    'PROPAGATOR_FILTERS_NB': 1910609,
+    'PROPAGATOR_FILTERS_NO_CHANGE_NB': 631079,
+    'PROPAGATOR_INCONSISTENCY_NB': 116806,
+    'SOLVER_BACKTRACK_NB': 131005,
+    'SOLVER_CHOICE_DEPTH': 10,
+    'SOLVER_CHOICE_NB': 131005,
+    'SOLVER_SOLUTION_NB': 14200
+}
+```
+
+## How to use NUCS ?
+It is very simple to get started with NUCS.
+You can either install the Pip package or install NUCS from the sources.
+
+### Install the NUCS package
+Let's install the Pip package for NUCS:
+```bash
+pip install nucs
+````
+Now we can write the following `queens.py` program, 
+refer to [the technical documentation](DOCUMENTATION.md) to better understand how NUCS works under the hood:
+```python
+from nucs.problems.problem import Problem
+from nucs.solvers.backtrack_solver import BacktrackSolver
+from nucs.propagators.propagators import ALG_ALLDIFFERENT
+
+n = 8  # the number of queens
+problem = Problem(
+    shr_domains=[(0, n - 1)] * n,  # these n domains are shared between 3n variables with different offsets
+    dom_indices=list(range(n)) * 3,  # for each variable, its domain
+    dom_offsets=[0] * n + list(range(n)) + list(range(0, -n, -1))  # for each variable, its offset
+)
+problem.set_propagators([
+    (list(range(n)), ALG_ALLDIFFERENT, []), 
+    (list(range(n, 2 * n)), ALG_ALLDIFFERENT, []), 
+    (list(range(2 * n, 3 * n)), ALG_ALLDIFFERENT, [])
+])
+print(BacktrackSolver(problem).solve_one()[:n])
+```
+Let's run this model with the following command:
+```bash
+PYTHONPATH=. python queens.py
+```
+The first solution found is:
+```bash
+[0, 4, 7, 5, 2, 6, 1, 3]
+```
+> [!TIP]
+> Note that the second run will always be much faster since the Python code will already have been compiled and cached by Numba.
+
+### Install NUCS from the sources 
+Let's install NUCS from the sources by cloning the NUCS Github repository:
+```bash
+git clone https://github.com/yangeorget/nucs.git
+pip install -r requirements.txt
+```
+From there, we will launch some NUCS examples.
+
+#### Run some examples
+Some of the examples come with a command line interface and can be run directly.
+
+Let's find all solutions to the [12-queens problem](https://www.csplib.org/Problems/prob054/):
+```bash
+NUMBA_CACHE_DIR=.numba/cache PYTHONPATH=. python tests/examples/test_queens.py -n 12
+```
+
+Let's find the optimal solution to the [Golomb ruler problem](https://www.csplib.org/Problems/prob006/) with 10 marks:
+```bash
+NUMBA_CACHE_DIR=.numba/cache PYTHONPATH=. python tests/examples/test_golomb.py -n 10
+```
+
+## Other constraint solvers in Python
+### python-constraint
+_The Python constraint module offers solvers for Constraint Solving Problems (CSPs) over finite domains in simple and pure Python._
+
+### CCPMpy
+_CPMpy is a Constraint Programming and Modeling library in Python, based on numpy, with direct solver access._
+
+### PyCSP
+_PyCSP3 is a Python library for developping models of combinatorial constrained problems in a declarative manner; you can write models of constraint satisfaction (CSP) and constraint optimization (COP) problems._

{nucs-0.1 → nucs-0.1.2}/nucs/problems/bibd_problem.py

@@ -8,8 +8,7 @@ from nucs.propagators.propagators import (
 
 class BIBDProblem(Problem):
     """
-    A simple model for the BIBD problem.
-    See https://www.csplib.org/Problems/prob028/ for a complete description of the problem.
+    This is problem #28 on CSPLIB (https://www.csplib.org/Problems/prob028/).
     """
 
     def __init__(self, v: int, b: int, r: int, k: int, l: int):

{nucs-0.1 → nucs-0.1.2}/nucs/problems/golomb_problem.py

@@ -35,7 +35,8 @@ class GolombProblem(Problem):
     - mark_0 <...< mark_n-1,
     - for all i<j, mark_j-mark_i are different,
     - mark_n-1 is minimal.
-    Note: This is problem #6 in CSPLib.
+
+    This is problem #6 on CSPLIB (https://www.csplib.org/Problems/prob006/).
     """
 
     def __init__(self, mark_nb: int) -> None:

{nucs-0.1 → nucs-0.1.2}/nucs/problems/problem.py

@@ -36,7 +36,7 @@ from nucs.statistics import (
     STATS_PROPAGATOR_FILTER_NB,
     STATS_PROPAGATOR_FILTER_NO_CHANGE_NB,
     STATS_PROPAGATOR_INCONSISTENCY_NB,
-    statistics_init,
+    init_statistics,
 )
 
 
@@ -58,7 +58,7 @@ class Problem:
         self.shr_domains = new_domains_by_values(shr_domains)
         self.dom_indices = new_indices_by_values(dom_indices)
         self.dom_offsets = new_domain_offsets_by_values(dom_offsets)
-        self.statistics = statistics_init()
+        self.statistics = init_statistics()
 
     def reset_shr_domains(self) -> None:
         """

{nucs-0.1 → nucs-0.1.2}/nucs/problems/queens_problem.py

@@ -5,6 +5,8 @@ from nucs.propagators.propagators import ALG_ALLDIFFERENT
 class QueensProblem(Problem):
     """
     A simple model for the n-queens problem.
+
+    This is problem #54 on CSPLIB (https://www.csplib.org/Problems/prob054/).
     """
 
     def __init__(self, n: int):

{nucs-0.1 → nucs-0.1.2}/nucs/problems/schur_lemma_problem.py

@@ -8,7 +8,7 @@ from nucs.propagators.propagators import (
 
 class SchurLemmaProblem(Problem):
     """
-    See https://www.csplib.org/Problems/prob015/.
+    This is problem #15 on CSPLIB (https://www.csplib.org/Problems/prob015/).
     """
 
     def __init__(self, n: int) -> None:

nucs-0.1.2/nucs/statistics.py

@@ -0,0 +1,45 @@
+from typing import Dict
+
+import numpy as np
+from numpy.typing import NDArray
+
+
+def init_statistics() -> NDArray:
+    """
+    Inits a Numpy array for storing the statistics.
+    :return: a Numpy array
+    """
+    return np.array([0] * STATS_MAX, dtype=np.int32, order="C")
+
+
+def get_statistics(stats: NDArray) -> Dict[str, int]:
+    """
+    Returns the statistics as a dictionary.
+    :param stats: a Numpy array of statistics
+    :return: a dictionary
+    """
+    return {
+        "OPTIMIZER_SOLUTION_NB": int(stats[STATS_OPTIMIZER_SOLUTION_NB]),
+        "PROBLEM_FILTERS_NB": int(stats[STATS_PROBLEM_FILTER_NB]),
+        "PROPAGATOR_ENTAILMENT_NB": int(stats[STATS_PROPAGATOR_ENTAILMENT_NB]),
+        "PROPAGATOR_FILTERS_NB": int(stats[STATS_PROPAGATOR_FILTER_NB]),
+        "PROPAGATOR_FILTERS_NO_CHANGE_NB": int(stats[STATS_PROPAGATOR_FILTER_NO_CHANGE_NB]),
+        "PROPAGATOR_INCONSISTENCY_NB": int(stats[STATS_PROPAGATOR_INCONSISTENCY_NB]),
+        "SOLVER_BACKTRACK_NB": int(stats[STATS_SOLVER_BACKTRACK_NB]),
+        "SOLVER_CHOICE_NB": int(stats[STATS_SOLVER_CHOICE_NB]),
+        "SOLVER_CHOICE_DEPTH": int(stats[STATS_SOLVER_CHOICE_DEPTH]),
+        "SOLVER_SOLUTION_NB": int(stats[STATS_SOLVER_SOLUTION_NB]),
+    }
+
+
+STATS_MAX = 10
+STATS_OPTIMIZER_SOLUTION_NB = 0
+STATS_PROBLEM_FILTER_NB = 1
+STATS_PROPAGATOR_ENTAILMENT_NB = 2
+STATS_PROPAGATOR_FILTER_NB = 3
+STATS_PROPAGATOR_FILTER_NO_CHANGE_NB = 4
+STATS_PROPAGATOR_INCONSISTENCY_NB = 5
+STATS_SOLVER_BACKTRACK_NB = 6
+STATS_SOLVER_CHOICE_NB = 7
+STATS_SOLVER_CHOICE_DEPTH = 8
+STATS_SOLVER_SOLUTION_NB = 9

{nucs-0.1 → nucs-0.1.2}/pyproject.toml

@@ -1,12 +1,12 @@
 [project]
 name="NUCS"
-version="0.1"
+version="0.1.2"
 authors = [
   { name="Yan Georget", email="yan.georget@gmail.com" },
 ]
 description="A Numpy and Numba based Python library for solving Constraint Satifaction Problems"
 readme = "README.md"
-requires-python = ">=3.8"
+requires-python = ">=3.9"
 classifiers = [
     "Programming Language :: Python :: 3",
     "Operating System :: OS Independent",

nucs-0.1/NUCS.egg-info/PKG-INFO

@@ -1,78 +0,0 @@
-Metadata-Version: 2.1
-Name: NUCS
-Version: 0.1
-Summary: A Numpy and Numba based Python library for solving Constraint Satifaction Problems
-Author-email: Yan Georget <yan.georget@gmail.com>
-Project-URL: Homepage, https://github.com/yangeorget/nucs
-Project-URL: Issues, https://github.com/yangeorget/nucs
-Classifier: Programming Language :: Python :: 3
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE.md
-Requires-Dist: numba==0.60.0
-Requires-Dist: numpy==2.0.1
-
-# NUCS
-
-## TLDR
-NUCS is a Python library for solving Constraint Satisfaction and Optimization Problems.
-
-NUCS is powered by Numpy (https://numpy.org/) and Numba (https://numba.pydata.org/).
-
-NUCS is fast and easy to use.
-
-
-## How to use NUCS ?
-It is very simple to get started with NUCS.
-Either clone the Github repository or install the package.
-
-### Clone the NUCS Github repository
-Let's install NUCS from the source:
-```
-git clone https://github.com/yangeorget/nucs.git
-pip install -r requirements.txt
-```
-
-From there, you can launch some NUCS examples.
-Note that the second run will be much faster since the Python code will have been compiled.
-
-#### Run the NUCS tests
-```
-NUMBA_CACHE_DIR=.numba/cache PYTHONPATH=. pytest tests/
-```
-
-#### Run some examples
-Find all solutions to the 12-queens problem:
-```
-NUMBA_CACHE_DIR=.numba/cache PYTHONPATH=. python3 tests/examples/test_queens.py -n 12
-```
-
-Find the optimal solution to the Golomb ruler problem with 10 marks:
-```
-NUMBA_CACHE_DIR=.numba/cache PYTHONPATH=. python3 tests/examples/test_golomb.py -n 10
-```
-
-### Install the NUCS package
-```
-pip install nucs
-````
-
-## Why Python ?
-NUCS is a Python library leveraging Numpy and Numba.
-
-Python is a powerful and flexible programing language that allows to express complex problems in a few lines of code.
-
-Numpy brings the computational power of languages like C and Fortran to Python, a language much easier to learn and use.
-
-Numba translates Python functions to optimized machine code at runtime using the industry-standard LLVM compiler library. 
-Numba-compiled numerical algorithms in Python can approach the speeds of C or FORTRAN.
-
-## Architecture
-
-## Speed matters
-
-## Other constraint solvers in Python
-- python-constraint 
-- CCPMpy
-- PyCSP

nucs-0.1/PKG-INFO

@@ -1,78 +0,0 @@
-Metadata-Version: 2.1
-Name: NUCS
-Version: 0.1
-Summary: A Numpy and Numba based Python library for solving Constraint Satifaction Problems
-Author-email: Yan Georget <yan.georget@gmail.com>
-Project-URL: Homepage, https://github.com/yangeorget/nucs
-Project-URL: Issues, https://github.com/yangeorget/nucs
-Classifier: Programming Language :: Python :: 3
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE.md
-Requires-Dist: numba==0.60.0
-Requires-Dist: numpy==2.0.1
-
-# NUCS
-
-## TLDR
-NUCS is a Python library for solving Constraint Satisfaction and Optimization Problems.
-
-NUCS is powered by Numpy (https://numpy.org/) and Numba (https://numba.pydata.org/).
-
-NUCS is fast and easy to use.
-
-
-## How to use NUCS ?
-It is very simple to get started with NUCS.
-Either clone the Github repository or install the package.
-
-### Clone the NUCS Github repository
-Let's install NUCS from the source:
-```
-git clone https://github.com/yangeorget/nucs.git
-pip install -r requirements.txt
-```
-
-From there, you can launch some NUCS examples.
-Note that the second run will be much faster since the Python code will have been compiled.
-
-#### Run the NUCS tests
-```
-NUMBA_CACHE_DIR=.numba/cache PYTHONPATH=. pytest tests/
-```
-
-#### Run some examples
-Find all solutions to the 12-queens problem:
-```
-NUMBA_CACHE_DIR=.numba/cache PYTHONPATH=. python3 tests/examples/test_queens.py -n 12
-```
-
-Find the optimal solution to the Golomb ruler problem with 10 marks:
-```
-NUMBA_CACHE_DIR=.numba/cache PYTHONPATH=. python3 tests/examples/test_golomb.py -n 10
-```
-
-### Install the NUCS package
-```
-pip install nucs
-````
-
-## Why Python ?
-NUCS is a Python library leveraging Numpy and Numba.
-
-Python is a powerful and flexible programing language that allows to express complex problems in a few lines of code.
-
-Numpy brings the computational power of languages like C and Fortran to Python, a language much easier to learn and use.
-
-Numba translates Python functions to optimized machine code at runtime using the industry-standard LLVM compiler library. 
-Numba-compiled numerical algorithms in Python can approach the speeds of C or FORTRAN.
-
-## Architecture
-
-## Speed matters
-
-## Other constraint solvers in Python
-- python-constraint 
-- CCPMpy
-- PyCSP

nucs-0.1/README.md

@@ -1,63 +0,0 @@
-# NUCS
-
-## TLDR
-NUCS is a Python library for solving Constraint Satisfaction and Optimization Problems.
-
-NUCS is powered by Numpy (https://numpy.org/) and Numba (https://numba.pydata.org/).
-
-NUCS is fast and easy to use.
-
-
-## How to use NUCS ?
-It is very simple to get started with NUCS.
-Either clone the Github repository or install the package.
-
-### Clone the NUCS Github repository
-Let's install NUCS from the source:
-```
-git clone https://github.com/yangeorget/nucs.git
-pip install -r requirements.txt
-```
-
-From there, you can launch some NUCS examples.
-Note that the second run will be much faster since the Python code will have been compiled.
-
-#### Run the NUCS tests
-```
-NUMBA_CACHE_DIR=.numba/cache PYTHONPATH=. pytest tests/
-```
-
-#### Run some examples
-Find all solutions to the 12-queens problem:
-```
-NUMBA_CACHE_DIR=.numba/cache PYTHONPATH=. python3 tests/examples/test_queens.py -n 12
-```
-
-Find the optimal solution to the Golomb ruler problem with 10 marks:
-```
-NUMBA_CACHE_DIR=.numba/cache PYTHONPATH=. python3 tests/examples/test_golomb.py -n 10
-```
-
-### Install the NUCS package
-```
-pip install nucs
-````
-
-## Why Python ?
-NUCS is a Python library leveraging Numpy and Numba.
-
-Python is a powerful and flexible programing language that allows to express complex problems in a few lines of code.
-
-Numpy brings the computational power of languages like C and Fortran to Python, a language much easier to learn and use.
-
-Numba translates Python functions to optimized machine code at runtime using the industry-standard LLVM compiler library. 
-Numba-compiled numerical algorithms in Python can approach the speeds of C or FORTRAN.
-
-## Architecture
-
-## Speed matters
-
-## Other constraint solvers in Python
-- python-constraint 
-- CCPMpy
-- PyCSP

nucs-0.1/nucs/statistics.py

@@ -1,44 +0,0 @@
-import numpy as np
-from numpy.typing import NDArray
-
-
-def statistics_init() -> NDArray:
-    """
-    Inits a Numpy array for storing the statistics.
-    :return: a Numpy array
-    """
-    return np.array([0] * STATS_MAX, dtype=np.int32, order="C")
-
-
-def statistics_print(stats: NDArray) -> None:
-    """
-    Pretty-prints an array of statistics.
-    :param stats: a Numpy array of statistics
-    """
-    print(
-        {
-            "OPTIMIZER_SOLUTION_NB": int(stats[STATS_OPTIMIZER_SOLUTION_NB]),
-            "PROBLEM_FILTERS_NB": int(stats[STATS_PROBLEM_FILTER_NB]),
-            "PROPAGATOR_ENTAILMENT_NB": int(stats[STATS_PROPAGATOR_ENTAILMENT_NB]),
-            "PROPAGATOR_FILTERS_NB": int(stats[STATS_PROPAGATOR_FILTER_NB]),
-            "PROPAGATOR_FILTERS_NO_CHANGE_NB": int(stats[STATS_PROPAGATOR_FILTER_NO_CHANGE_NB]),
-            "PROPAGATOR_INCONSISTENCY_NB": int(stats[STATS_PROPAGATOR_INCONSISTENCY_NB]),
-            "SOLVER_BACKTRACK_NB": int(stats[STATS_SOLVER_BACKTRACK_NB]),
-            "SOLVER_CHOICE_NB": int(stats[STATS_SOLVER_CHOICE_NB]),
-            "SOLVER_CHOICE_DEPTH": int(stats[STATS_SOLVER_CHOICE_DEPTH]),
-            "SOLVER_SOLUTION_NB": int(stats[STATS_SOLVER_SOLUTION_NB]),
-        }
-    )
-
-
-STATS_MAX = 10
-STATS_OPTIMIZER_SOLUTION_NB = 0
-STATS_PROBLEM_FILTER_NB = 1
-STATS_PROPAGATOR_ENTAILMENT_NB = 2
-STATS_PROPAGATOR_FILTER_NB = 3
-STATS_PROPAGATOR_FILTER_NO_CHANGE_NB = 4
-STATS_PROPAGATOR_INCONSISTENCY_NB = 5
-STATS_SOLVER_BACKTRACK_NB = 6
-STATS_SOLVER_CHOICE_NB = 7
-STATS_SOLVER_CHOICE_DEPTH = 8
-STATS_SOLVER_SOLUTION_NB = 9