dega2 0.1.0__tar.gz

dega2-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ali Zaidi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

dega2-0.1.0/PKG-INFO

@@ -0,0 +1,122 @@
+Metadata-Version: 2.4
+Name: dega2
+Version: 0.1.0
+Summary: DEGA-2: A optimization a function over the efficient set of  multi-objective  integer variables using the genetics algorithms
+Author-email: Ali Zaidi <a.zaidi@crlca.dz>
+License-Expression: MIT
+Keywords: optimization,genetic algorithm,multi-objective,integer programming
+Classifier: Programming Language :: Python :: 3
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: tqdm
+Provides-Extra: plot
+Requires-Dist: matplotlib; extra == "plot"
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Dynamic: license-file
+
+# DEGA-2
+
+A optimisation of function over the efficient set of multi-objective  integer variables using a genetics algorithms, by Ali Zaidi.
+
+It minimizes a function `phi·x` subject to linear constraints `a·x <= b`
+(`x` integer, and `x >= 0` by default), using `p` objectives `c·x` for the
+non-dominance test.
+
+## Installation
+
+```bash
+pip install dega2
+# with the convergence plot:
+pip install "dega2[plot]"
+```
+
+## Entering your problem and parameters
+
+### 1. Interactive assistant
+
+```bash
+dega2
+```
+
+The assistant asks for the problem (file, keyboard entry, or a random example),
+then for the parameters (population size, alpha, number of explored variables,
+iterations, `x >= 0` constraints). Press Enter to accept the suggested value.
+
+### 2. `.json` file
+
+```bash
+dega2 --exemple my_problem.json     # writes a template to edit
+dega2 -f my_problem.json            # runs the computation
+```
+
+File format:
+
+```json
+{
+  "a": [[2, 3, 1], [1, 1, 2]],
+  "b": [20, 15],
+  "c": [[3, -1, 2], [-2, 4, 1]],
+  "phi": [-3, -2, -4],
+  "parametres": {
+    "n_population": 20, "alpha": 4, "explor": 3,
+    "iterations": 10, "positivity": true
+  }
+}
+```
+
+- `a`: constraint matrix (m rows, n columns); `b`: right-hand side (m values)
+- `c`: objectives matrix (p rows, n columns); `phi`: function to minimize (n values)
+- `parametres` is optional. Command-line options (`--population`, `--alpha`,
+  `--explor`, `-T`, `--sans-positivite`, `--seed`, `--no-plot`) take precedence over
+  the file. A `.npz` file (keys `a`, `b`, `c`, `phi`) is also accepted.
+
+### 3. In Python code
+
+```python
+import numpy as np
+import dega2
+
+a   = np.array([[2, 3, 1], [1, 1, 2]])
+b   = np.array([20, 15])
+c   = np.array([[3, -1, 2], [-2, 4, 1]])
+phi = np.array([-3, -2, -4])
+
+res = dega2.solve(a, b, c, phi, n_population=20, explor=3, iterations=10, seed=0)
+
+print(res.phi)      # best value of phi
+print(res.x)        # best solution
+res.plot()          # convergence curve (requires matplotlib)
+
+# or from a file:
+a, b, c, phi, params = dega2.charger_probleme("my_problem.json")
+res = dega2.solve(a, b, c, phi, **params)
+```
+
+`solve` parameters: `n_population=80`, `alpha=4`, `explor=3`,
+`iterations=None` (2·n by default), `positivity=True`, `seed=None`, `verbose=True`.
+`solve` returns a `Result` object: `x`, `phi`, `history` (minimum of phi at each
+iteration), `population`, `time`, `iterations`.
+
+Note: the algorithm builds a population of `n_population` feasible solutions that
+are mutually non-dominated. With very few objectives or variables, such a
+population may not exist; `dega2` then stops with an error message (reduce
+`n_population` or add objectives).
+
+## Random demonstration
+
+```bash
+dega2 --demo --seed 1
+dega2 --demo -n 20 -p 5 --no-plot
+```
+
+## Tests
+
+```bash
+pip install -e ".[test]"
+pytest
+```

dega2-0.1.0/README.md

@@ -0,0 +1,101 @@
+# DEGA-2
+
+A optimisation of function over the efficient set of multi-objective  integer variables using a genetics algorithms, by Ali Zaidi.
+
+It minimizes a function `phi·x` subject to linear constraints `a·x <= b`
+(`x` integer, and `x >= 0` by default), using `p` objectives `c·x` for the
+non-dominance test.
+
+## Installation
+
+```bash
+pip install dega2
+# with the convergence plot:
+pip install "dega2[plot]"
+```
+
+## Entering your problem and parameters
+
+### 1. Interactive assistant
+
+```bash
+dega2
+```
+
+The assistant asks for the problem (file, keyboard entry, or a random example),
+then for the parameters (population size, alpha, number of explored variables,
+iterations, `x >= 0` constraints). Press Enter to accept the suggested value.
+
+### 2. `.json` file
+
+```bash
+dega2 --exemple my_problem.json     # writes a template to edit
+dega2 -f my_problem.json            # runs the computation
+```
+
+File format:
+
+```json
+{
+  "a": [[2, 3, 1], [1, 1, 2]],
+  "b": [20, 15],
+  "c": [[3, -1, 2], [-2, 4, 1]],
+  "phi": [-3, -2, -4],
+  "parametres": {
+    "n_population": 20, "alpha": 4, "explor": 3,
+    "iterations": 10, "positivity": true
+  }
+}
+```
+
+- `a`: constraint matrix (m rows, n columns); `b`: right-hand side (m values)
+- `c`: objectives matrix (p rows, n columns); `phi`: function to minimize (n values)
+- `parametres` is optional. Command-line options (`--population`, `--alpha`,
+  `--explor`, `-T`, `--sans-positivite`, `--seed`, `--no-plot`) take precedence over
+  the file. A `.npz` file (keys `a`, `b`, `c`, `phi`) is also accepted.
+
+### 3. In Python code
+
+```python
+import numpy as np
+import dega2
+
+a   = np.array([[2, 3, 1], [1, 1, 2]])
+b   = np.array([20, 15])
+c   = np.array([[3, -1, 2], [-2, 4, 1]])
+phi = np.array([-3, -2, -4])
+
+res = dega2.solve(a, b, c, phi, n_population=20, explor=3, iterations=10, seed=0)
+
+print(res.phi)      # best value of phi
+print(res.x)        # best solution
+res.plot()          # convergence curve (requires matplotlib)
+
+# or from a file:
+a, b, c, phi, params = dega2.charger_probleme("my_problem.json")
+res = dega2.solve(a, b, c, phi, **params)
+```
+
+`solve` parameters: `n_population=80`, `alpha=4`, `explor=3`,
+`iterations=None` (2·n by default), `positivity=True`, `seed=None`, `verbose=True`.
+`solve` returns a `Result` object: `x`, `phi`, `history` (minimum of phi at each
+iteration), `population`, `time`, `iterations`.
+
+Note: the algorithm builds a population of `n_population` feasible solutions that
+are mutually non-dominated. With very few objectives or variables, such a
+population may not exist; `dega2` then stops with an error message (reduce
+`n_population` or add objectives).
+
+## Random demonstration
+
+```bash
+dega2 --demo --seed 1
+dega2 --demo -n 20 -p 5 --no-plot
+```
+
+## Tests
+
+```bash
+pip install -e ".[test]"
+pytest
+```

dega2-0.1.0/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = ["setuptools>=77", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "dega2"
+version = "0.1.0"
+description = "DEGA-2: A optimization a function over the efficient set of  multi-objective  integer variables using the genetics algorithms"
+readme = "README.md"
+requires-python = ">=3.9"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Ali Zaidi", email = "a.zaidi@crlca.dz" }]
+keywords = ["optimization", "genetic algorithm", "multi-objective", "integer programming"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Intended Audience :: Science/Research",
+    "Topic :: Scientific/Engineering :: Mathematics",
+]
+dependencies = [
+    "numpy",
+    "tqdm",
+]
+
+[project.optional-dependencies]
+plot = ["matplotlib"]
+test = ["pytest"]
+
+[project.scripts]
+dega2 = "dega2.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]

dega2-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

dega2-0.1.0/src/dega2/BuildpopGA.py

@@ -0,0 +1,51 @@
+import numpy as np
+
+from . import ConsChekGA4, DomChekGA4
+
+
+def explorer(population1, n_population, explor, p_cof1, index_p, p_cofphi1, index_phi,
+             n_pop, n_pop_phi):
+    """Phase d'exploration, vectorisée : pour chaque variable j, on ajoute +1 ou -1
+    sur toute la ligne concernée (au lieu de boucler colonne par colonne)."""
+    blocs_phi, blocs_p = [], []
+    tab_ind1, tab_ind1_ph = [], []
+    n_p = n_pop - n_pop_phi          # nombre de colonnes modifiées dans la 2e moitié
+
+    for j in range(explor):
+        a1 = np.array(population1[:, 0:n_pop_phi])
+        a2 = np.array(population1[:, n_pop_phi:n_population])
+
+        r_phi = index_phi[0, j]
+        r_p = index_p[0, j]
+        a1[r_phi, :] += 1 if p_cofphi1[2, j] < 0 else -1
+        a2[r_p, :n_p] += 1 if p_cof1[2, j] < 0 else -1
+
+        tab_ind1_ph.extend([r_phi] * n_pop_phi)
+        tab_ind1.extend([r_p] * n_p)
+        blocs_phi.append(a1)
+        blocs_p.append(a2)
+
+    a3 = np.concatenate(blocs_phi, axis=1)   # une seule concaténation
+    a4 = np.concatenate(blocs_p, axis=1)
+    return a3, a4, tab_ind1, tab_ind1_ph
+
+
+def Build_PT(population1, n_population, explor, p_cof1, index_p, p_cofphi1, index_phi,
+             phi, alpha, a, b, c, n_pop, n_pop_phi, n):
+
+    ###################### Variables exploration ##############################
+    a3, a4, tab_ind1, tab_ind1_ph = explorer(
+        population1, n_population, explor, p_cof1, index_p, p_cofphi1, index_phi,
+        n_pop, n_pop_phi)
+
+    ############ Check the constraints and dominance of new populations ########
+    tab_ind11 = tab_ind1.copy()
+    tab_ind11_phi = tab_ind1_ph.copy()
+
+    [pop1, pop1_phi, tab_ind11, tab_ind11_phi] = ConsChekGA4.chek(
+        a3, a4, a, b, tab_ind11_phi, tab_ind11)
+
+    [pop2, tab_ind11_phi, tab_ind11] = DomChekGA4.nd_update(
+        c, population1, pop1, pop1_phi, tab_ind11, tab_ind11_phi)
+
+    return pop2, tab_ind1, tab_ind11, tab_ind1_ph, tab_ind11_phi

dega2-0.1.0/src/dega2/ConsChek.py

@@ -0,0 +1,13 @@
+import numpy as np
+
+
+def chek(pop, a, b):
+    if pop.shape[1] == 0:
+        return pop
+    return pop[:, (a @ pop <= b).all(axis=0)]
+        
+       
+       
+    
+    
+

dega2-0.1.0/src/dega2/ConsChekGA4.py

@@ -0,0 +1,19 @@
+import numpy as np
+
+
+def _realisables(a, b, pop):
+    """Indices des colonnes de `pop` qui vérifient a @ x <= b (test fait pour toutes
+    les colonnes en un seul produit matriciel)."""
+    if pop.shape[1] == 0:
+        return np.arange(0)
+    return np.flatnonzero((a @ pop <= b).all(axis=0))
+
+
+def chek(pop_phi, pop, a, b, tab_ind11_phi, tab_ind11):
+    idx = _realisables(a, b, pop)
+    idx_phi = _realisables(a, b, pop_phi)
+
+    return (pop[:, idx],
+            pop_phi[:, idx_phi],
+            [tab_ind11[k] for k in idx],
+            [tab_ind11_phi[k] for k in idx_phi])

dega2-0.1.0/src/dega2/DomChek.py

@@ -0,0 +1,19 @@
+import numpy as np
+
+
+def non_dominance(c, pop):
+    obj_val = np.dot(c, pop)
+    idx = np.arange(obj_val.shape[1])
+    i = 0
+    while i < len(idx) - 1:
+        oi = obj_val[:, idx[i]][:, None]
+        reste = obj_val[:, idx[i + 1:]]
+        le = (oi <= reste).all(axis=0)      # i domine (faiblement) j  -> j supprimé
+        gt = (oi > reste).all(axis=0)       # j domine strictement i   -> i supprimé
+        if gt.any():
+            jg = int(gt.argmax())           # premier j qui domine i
+            idx = np.delete(idx, np.append(np.flatnonzero(le[:jg]) + i + 1, i))
+        else:
+            idx = np.delete(idx, np.flatnonzero(le) + i + 1)
+            i += 1
+    return pop[:, idx]

dega2-0.1.0/src/dega2/DomChekGA4.py

@@ -0,0 +1,78 @@
+import numpy as np
+
+
+def _indices_non_domines(obj):
+    """Équivalent exact de la boucle de `non_dominance`, mais sans np.delete répétés
+    et avec la comparaison de i contre tous les j restants faite en une seule fois.
+    Renvoie les indices (dans l'ordre d'origine) des colonnes conservées."""
+    idx = np.arange(obj.shape[1])
+    i = 0
+    while i < len(idx) - 1:
+        oi = obj[:, idx[i]][:, None]
+        reste = obj[:, idx[i + 1:]]
+        le = (oi <= reste).all(axis=0)      # i domine (faiblement) j  -> j supprimé
+        gt = (oi > reste).all(axis=0)       # j domine strictement i   -> i supprimé
+        if gt.any():
+            jg = int(gt.argmax())           # premier j qui domine i
+            a_supprimer = np.append(np.flatnonzero(le[:jg]) + i + 1, i)
+            idx = np.delete(idx, a_supprimer)   # i reste à la même position
+        else:
+            idx = np.delete(idx, np.flatnonzero(le) + i + 1)
+            i += 1
+    return idx
+
+
+def non_dominance(c, pop, tab_ind3):
+    obj_val = np.dot(c, pop)
+    idx = _indices_non_domines(obj_val)
+    return pop[:, idx], [tab_ind3[k] for k in idx], obj_val[:, idx]
+
+
+def _filtrer_contre(obj_p, idx_p, obj_ref, idx_ref, limite_fixe=None):
+    """Compare chaque individu de la population (idx_p) à l'ensemble de référence
+    (idx_ref) : un individu de référence dominé est supprimé, et l'individu de la
+    population est supprimé dès qu'un élément de référence le domine strictement.
+    `limite_fixe` reproduit la borne de balayage de la 2e boucle d'origine."""
+    i = 0
+    while i < len(idx_p):
+        oi = obj_p[:, idx_p[i]][:, None]
+        L = len(idx_ref) if limite_fixe is None else min(limite_fixe, len(idx_ref))
+        ref = obj_ref[:, idx_ref[:L]]
+        le = (oi <= ref).all(axis=0)
+        gt = (oi > ref).all(axis=0)
+        if gt.any():
+            jg = int(gt.argmax())
+            idx_ref = np.delete(idx_ref, np.flatnonzero(le[:jg]))
+            idx_p = np.delete(idx_p, i)     # i reste à la même position
+        else:
+            idx_ref = np.delete(idx_ref, np.flatnonzero(le))
+            i += 1
+    return idx_p, idx_ref
+
+
+def nd_update(c, population, pop1, pop1_phi, tab_ind11, tab_ind11_phi):
+
+    # non-dominance interne de pop1_phi puis de pop1
+    pop1_phi, tab_ind11_phi, obj_val_phi = non_dominance(c, pop1_phi, tab_ind11_phi)
+    pop1, tab_ind11, obj_val1 = non_dominance(c, pop1, tab_ind11)
+
+    obj_val_p = np.dot(c, population)
+    idx_p = np.arange(population.shape[1])
+
+    # population contre pop1
+    idx_p, idx1 = _filtrer_contre(obj_val_p, idx_p, obj_val1,
+                                  np.arange(pop1.shape[1]))
+
+    # population contre pop1_phi
+    # NB : comportement d'origine conservé. Le balayage de pop1_phi est borné par la
+    # taille de la population (size_popkD), pas par celle de pop1_phi : si pop1_phi
+    # est plus grande, ses derniers éléments ne sont pas comparés.
+    D = len(idx_p)
+    idx_p, idx_phi = _filtrer_contre(obj_val_p, idx_p, obj_val_phi,
+                                     np.arange(pop1_phi.shape[1]), limite_fixe=D)
+
+    pop2 = np.concatenate((population[:, idx_p], pop1_phi[:, idx_phi], pop1[:, idx1]),
+                          axis=1)
+    return (pop2,
+            [tab_ind11_phi[k] for k in idx_phi],
+            [tab_ind11[k] for k in idx1])

dega2-0.1.0/src/dega2/GA4.py

@@ -0,0 +1,64 @@
+import numpy as np
+from . import BuildpopGA, GenPop, upload_cofGA
+from tqdm import tqdm
+
+
+def NewPop(population1, n_population, explor, p_cof1, index_p, p_cofphi1, index_phi,
+           phi, alpha, a, b, c, T, n, verbose=True):
+
+    n_pop = len(population1.T)
+    n_pop_phi = int(n_pop / alpha)
+
+    min_phi = []
+
+    barre = tqdm(
+        range(T),
+        desc="DEGA-2",
+        unit="it",
+        colour="green",
+        disable=not verbose,
+        bar_format="{desc} {percentage:3.0f}%|{bar:35}| {n_fmt}/{total_fmt} "
+                   "[{elapsed}<{remaining}, {rate_fmt}] {postfix}",
+    )
+
+    for _ in barre:
+        [pop2, tab_ind1, tab_ind11, tab_ind1_phi, tab_ind11_phi] = BuildpopGA.Build_PT(
+            population1, n_population, explor, p_cof1, index_p, p_cofphi1, index_phi,
+            phi, alpha, a, b, c, n_pop, n_pop_phi, n)
+
+        s = pop2.shape[1]
+
+        if s > n_population:
+            # sélection des n_pop meilleurs individus (tri croissant de phi)
+            xphi1 = np.dot(phi, pop2)
+            ind_phi1 = np.argsort(xphi1, axis=1)
+            pop3 = pop2[:, ind_phi1[0, :n_pop]].astype(int)
+        elif s < n_population:
+            pop3 = GenPop.Gen(a, b, c, n, n_population - s)
+            pop3 = np.concatenate((pop2, pop3), axis=1)
+        else:
+            pop3 = pop2
+
+        population1 = pop3
+        xphi1 = np.dot(phi, pop3)
+
+        xphi2 = xphi1.min()
+        min_phi.append(xphi2)
+
+        ##################### Candidats ####################################
+        condidat_phi = list(index_phi[0, :explor])
+        condidat = list(index_p[0, :explor])
+
+        ##################### Mise à jour des coefficients #################
+        [p_cof1, p_cofphi1, index_p, index_phi] = upload_cofGA.upload(
+            p_cof1, index_p, p_cofphi1, index_phi,
+            tab_ind1, tab_ind1_phi, tab_ind11, tab_ind11_phi,
+            explor, condidat_phi, condidat, n_pop, n_pop_phi)
+
+        barre.set_postfix_str(f"min_phi={xphi2:.4e}", refresh=False)
+
+    # Correction : l'indice vient de pop3 (= population1), pas de pop2
+    min_index = xphi1.argmin()
+    xopt = population1[:, min_index]
+
+    return pop2, xphi2, min_phi, xopt

dega2-0.1.0/src/dega2/GenPop.py

@@ -0,0 +1,32 @@
+import numpy as np
+from . import ConsChek, DomChek
+
+# Nombre maximal de tirages consécutifs sans progression avant d'abandonner.
+_ESSAIS_MAX = 5000
+
+
+def Gen(a,b,c,n,n_population):
+    population=np.random.randint(0,3,(n,n_population),dtype=int);
+    pop2=ConsChek.chek(population, a, b)
+    pop3=DomChek.non_dominance(c, pop2)
+    np1=n_population-len(pop3.T)
+    sans_progres=0
+    while np1!=0:
+        population=np.random.randint(0,3,(n,np1),dtype=int);
+        pop2=ConsChek.chek(population, a, b)
+        pop3=np.concatenate((pop3,pop2),axis=1);
+        pop3=DomChek.non_dominance(c, pop3)
+        np1_nouveau=n_population-len(pop3.T)
+        # Garde-fou : sans lui, un problème où il n'existe pas assez de solutions
+        # réalisables et deux à deux non dominées (peu d'objectifs, peu de variables,
+        # contraintes très serrées...) faisait tourner la boucle indéfiniment.
+        sans_progres = 0 if np1_nouveau < np1 else sans_progres + 1
+        if sans_progres > _ESSAIS_MAX:
+            raise RuntimeError(
+                "Impossible de construire une population de %d solutions réalisables "
+                "et non dominées entre elles (%d trouvées). Réduis la taille de la "
+                "population, ajoute des objectifs (lignes de c) ou relâche les "
+                "contraintes." % (n_population, n_population - np1_nouveau))
+        np1=np1_nouveau
+
+    return(pop3)

dega2-0.1.0/src/dega2/__init__.py

@@ -0,0 +1,9 @@
+"""DEGA-2 : algorithme génétique multi-objectifs à variables entières."""
+
+__version__ = "0.1.0"
+
+from .solver import Result, solve
+from .entree import charger_probleme, ecrire_exemple
+from .example import demo
+
+__all__ = ["solve", "charger_probleme", "ecrire_exemple", "demo", "Result", "__version__"]

dega2-0.1.0/src/dega2/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())