dega2 0.1.0__py3-none-any.whl

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/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/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/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/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/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/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/__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/__main__.py

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

dega2/cli.py

@@ -0,0 +1,139 @@
+"""Ligne de commande :
+
+    dega2                        assistant interactif (l'utilisateur entre son problème)
+    dega2 -f probleme.json       problème et paramètres lus dans un fichier
+    dega2 --exemple modele.json  écrit un fichier d'exemple à modifier
+    dega2 --demo                 problème aléatoire de démonstration
+"""
+import argparse
+
+import numpy as np
+
+from . import __version__, problems
+from .entree import (PARAMETRES_DEFAUT, charger_probleme, demander,
+                     demander_oui_non, ecrire_exemple, saisir_parametres,
+                     saisir_probleme)
+from .example import demo
+from .solver import solve
+
+
+def _construire_parseur():
+    p = argparse.ArgumentParser(
+        prog="dega2",
+        description="DEGA-2. Sans option, lance un assistant qui demande le problème "
+                    "et les paramètres.")
+    p.add_argument("-f", "--probleme", metavar="FICHIER",
+                   help="fichier .json ou .npz contenant a, b, c, phi "
+                        "(et éventuellement \"parametres\")")
+    p.add_argument("--exemple", metavar="FICHIER",
+                   help="écrit un fichier .json d'exemple, puis quitte")
+    p.add_argument("--demo", action="store_true",
+                   help="problème aléatoire de démonstration (voir -n, -p, -m)")
+    p.add_argument("-n", type=int, default=None, help="[--demo] nombre de variables (défaut 30)")
+    p.add_argument("-p", "--objectifs", type=int, default=None,
+                   help="[--demo] nombre d'objectifs (défaut 10)")
+    p.add_argument("-m", "--contraintes", type=int, default=None,
+                   help="[--demo] nombre de contraintes (défaut 15)")
+    p.add_argument("-T", "--iterations", type=int, default=None,
+                   help="nombre d'itérations (défaut 2n)")
+    p.add_argument("--population", type=int, default=None, help="taille de la population (défaut 80)")
+    p.add_argument("--alpha", type=int, default=None, help="paramètre alpha (défaut 4)")
+    p.add_argument("--explor", type=int, default=None,
+                   help="variables explorées par itération (défaut 3)")
+    p.add_argument("--sans-positivite", action="store_true",
+                   help="ne pas ajouter les contraintes x >= 0")
+    p.add_argument("--seed", type=int, default=None, help="graine aléatoire")
+    p.add_argument("--no-plot", action="store_true", help="ne pas afficher la courbe")
+    p.add_argument("--version", action="version", version=f"dega2 {__version__}")
+    return p
+
+
+def _lancer(a, b, c, phi, parametres, seed=None, tracer=True):
+    a, c = np.atleast_2d(a), np.atleast_2d(c)
+    print(f"\n🧬  DEGA-2 — démarrage (variables={a.shape[1]}, objectifs={c.shape[0]}, "
+          f"contraintes={a.shape[0]})\n")
+    res = solve(a, b, c, phi, seed=seed, **parametres)
+    print("\n" + res.summary() + "\n")
+    if tracer:
+        try:
+            res.plot()
+        except ImportError as exc:
+            print(exc)
+    return res
+
+
+def _assistant():
+    print("\n🧬  DEGA-2 — assistant\n")
+    print("Comment fournir le problème ?")
+    print("  1) Charger un fichier (.json ou .npz)")
+    print("  2) Saisir au clavier")
+    print("  3) Problème aléatoire (démonstration)")
+    choix = demander("Choix", 1, minimum=1, maximum=3)
+
+    defauts = {}
+    if choix == 1:
+        while True:
+            chemin = input("Chemin du fichier : ").strip().strip('"').strip("'")
+            try:
+                a, b, c, phi, defauts = charger_probleme(chemin)
+                break
+            except (OSError, ValueError) as exc:
+                print(f"  Lecture impossible : {exc}")
+    elif choix == 2:
+        a, b, c, phi = saisir_probleme()
+    else:
+        n = demander("Nombre de variables n", 30, minimum=1)
+        m1 = demander("Nombre de contraintes", 15, minimum=1)
+        p = demander("Nombre d'objectifs", 10, minimum=1)
+        a, b, c, phi = problems.Genr(n, m1, p)
+
+    n = np.atleast_2d(a).shape[1]
+    parametres = saisir_parametres(n, defauts)
+    tracer = demander_oui_non("Afficher la courbe de convergence à la fin ?", True)
+    _lancer(a, b, c, phi, parametres, tracer=tracer)
+
+
+def main(argv=None):
+    args = _construire_parseur().parse_args(argv)
+
+    try:
+        if args.exemple:
+            ecrire_exemple(args.exemple)
+            print(f"Fichier d'exemple écrit : {args.exemple}\n"
+                  f"Modifie-le puis lance :  dega2 -f {args.exemple}")
+            return 0
+
+        if args.demo:
+            demo(n=30 if args.n is None else args.n,
+                 p=10 if args.objectifs is None else args.objectifs,
+                 m1=15 if args.contraintes is None else args.contraintes,
+                 n_population=80 if args.population is None else args.population,
+                 alpha=4 if args.alpha is None else args.alpha,
+                 explor=3 if args.explor is None else args.explor,
+                 iterations=args.iterations, seed=args.seed, plot=not args.no_plot)
+            return 0
+
+        if args.probleme:
+            a, b, c, phi, du_fichier = charger_probleme(args.probleme)
+            params = dict(PARAMETRES_DEFAUT)
+            params.update(du_fichier)                       # valeurs du fichier
+            for cle, valeur in (("n_population", args.population), ("alpha", args.alpha),
+                                ("explor", args.explor), ("iterations", args.iterations)):
+                if valeur is not None:                      # options de la ligne de commande
+                    params[cle] = valeur
+            if args.explor is None and "explor" not in du_fichier:
+                params["explor"] = min(params["explor"], np.atleast_2d(a).shape[1])
+            if args.sans_positivite:
+                params["positivity"] = False
+            _lancer(a, b, c, phi, params, seed=args.seed, tracer=not args.no_plot)
+            return 0
+
+        _assistant()
+        return 0
+
+    except (OSError, ValueError, RuntimeError) as exc:
+        print(f"Erreur : {exc}")
+        return 1
+    except (EOFError, KeyboardInterrupt):
+        print("\nInterrompu.")
+        return 1

dega2/entree.py

@@ -0,0 +1,180 @@
+"""Saisie du problème et des paramètres par l'utilisateur.
+
+Trois façons de fournir un problème :
+  - un fichier .json ou .npz           -> charger_probleme(chemin)
+  - la saisie au clavier               -> saisir_probleme()
+  - des tableaux numpy dans son code   -> dega2.solve(a, b, c, phi)
+"""
+import json
+
+import numpy as np
+
+CLES_PROBLEME = ("a", "b", "c", "phi")
+CLES_PARAMETRES = ("n_population", "alpha", "explor", "iterations", "positivity")
+
+PARAMETRES_DEFAUT = {
+    "n_population": 80,
+    "alpha": 4,
+    "explor": 3,
+    "iterations": None,      # None -> 2 * n
+    "positivity": True,
+}
+
+
+# ----------------------------------------------------------------------------
+# Fichiers
+# ----------------------------------------------------------------------------
+def charger_probleme(chemin):
+    """Lit un problème dans un fichier .json ou .npz.
+
+    Le fichier contient les clés a, b, c, phi, et éventuellement une clé
+    "parametres" (n_population, alpha, explor, iterations, positivity).
+    Renvoie (a, b, c, phi, parametres) ; `parametres` est un dict, éventuellement vide.
+    """
+    chemin = str(chemin)
+    bas = chemin.lower()
+    if bas.endswith(".json"):
+        with open(chemin, encoding="utf-8") as f:
+            donnees = json.load(f)
+    elif bas.endswith(".npz"):
+        with np.load(chemin, allow_pickle=False) as f:
+            donnees = {k: f[k] for k in f.files}
+    else:
+        raise ValueError("Format non pris en charge : utilise un fichier .json ou .npz")
+
+    manquantes = [k for k in CLES_PROBLEME if k not in donnees]
+    if manquantes:
+        raise ValueError("Clés manquantes dans le fichier : " + ", ".join(manquantes))
+
+    parametres = donnees.get("parametres", {})
+    if not isinstance(parametres, dict):
+        raise ValueError('"parametres" doit être un dictionnaire.')
+    inconnus = [k for k in parametres if k not in CLES_PARAMETRES]
+    if inconnus:
+        raise ValueError("Paramètres inconnus : " + ", ".join(inconnus)
+                         + " (attendus : " + ", ".join(CLES_PARAMETRES) + ")")
+
+    a, b, c, phi = (np.asarray(donnees[k]) for k in CLES_PROBLEME)
+    return a, b, c, phi, dict(parametres)
+
+
+def ecrire_exemple(chemin):
+    """Écrit un fichier .json d'exemple que l'utilisateur peut modifier."""
+    exemple = {
+        "a": [[2, 3, 1, 4, 2, 1, 3, 2],
+              [1, 1, 2, 3, 1, 4, 2, 1],
+              [3, 1, 1, 2, 4, 1, 1, 3]],
+        "b": [40, 36, 42],
+        "c": [[3, -1, 2, 0, 4, -2, 1, 1],
+              [-2, 4, 1, -1, 0, 3, -3, 2],
+              [1, 2, -4, 3, -1, 1, 2, -2],
+              [0, -3, 2, 2, 1, -1, 4, -1],
+              [2, 1, 1, -3, 2, 2, -2, 3]],
+        "phi": [-3, -2, -4, -1, -2, -3, -1, -2],
+        "parametres": {
+            "n_population": 20,
+            "alpha": 4,
+            "explor": 3,
+            "iterations": 16,
+            "positivity": True,
+        },
+    }
+    with open(chemin, "w", encoding="utf-8") as f:
+        json.dump(exemple, f, indent=2, ensure_ascii=False)
+    return exemple
+
+
+# ----------------------------------------------------------------------------
+# Saisie interactive
+# ----------------------------------------------------------------------------
+def _nombre(brut):
+    """Convertit un texte en int si possible, sinon en float."""
+    try:
+        return int(brut)
+    except ValueError:
+        return float(brut)
+
+
+def demander(invite, defaut=None, type_=int, minimum=None, maximum=None):
+    """Pose une question, répète tant que la réponse est invalide.
+    Entrée vide = valeur par défaut."""
+    while True:
+        suffixe = "" if defaut is None else f" [{defaut}]"
+        brut = input(f"{invite}{suffixe} : ").strip()
+        if brut == "":
+            if defaut is not None:
+                return defaut
+            print("  Une valeur est requise.")
+            continue
+        try:
+            valeur = type_(brut)
+        except ValueError:
+            print("  Valeur invalide.")
+            continue
+        if (minimum is not None and valeur < minimum) or \
+           (maximum is not None and valeur > maximum):
+            borne = f"entre {minimum} et {maximum}" if None not in (minimum, maximum) \
+                else (f">= {minimum}" if minimum is not None else f"<= {maximum}")
+            print(f"  La valeur doit être {borne}.")
+            continue
+        return valeur
+
+
+def demander_oui_non(invite, defaut=True):
+    indice = "O/n" if defaut else "o/N"
+    while True:
+        brut = input(f"{invite} [{indice}] : ").strip().lower()
+        if brut == "":
+            return defaut
+        if brut in ("o", "oui", "y", "yes"):
+            return True
+        if brut in ("n", "non", "no"):
+            return False
+        print("  Réponds par o ou n.")
+
+
+def demander_vecteur(invite, longueur):
+    """Lit `longueur` nombres séparés par des espaces ou des virgules."""
+    while True:
+        brut = input(f"{invite} : ").replace(",", " ").split()
+        try:
+            valeurs = [_nombre(t) for t in brut]
+        except ValueError:
+            print("  Il faut uniquement des nombres.")
+            continue
+        if len(valeurs) != longueur:
+            print(f"  {longueur} nombres attendus, {len(valeurs)} reçus.")
+            continue
+        return valeurs
+
+
+def saisir_probleme():
+    """Saisie au clavier de a, b, c, phi. Renvoie (a, b, c, phi)."""
+    n = demander("Nombre de variables n", minimum=1)
+    m = demander("Nombre de contraintes m", minimum=1)
+    p = demander("Nombre d'objectifs p (lignes de c)", minimum=1)
+
+    print(f"\nMatrice a : {m} lignes de {n} nombres (contraintes  a·x <= b)")
+    a = [demander_vecteur(f"  a, ligne {i + 1}/{m}", n) for i in range(m)]
+    b = demander_vecteur(f"Second membre b : {m} nombres", m)
+    print(f"\nMatrice c : {p} lignes de {n} nombres (objectifs)")
+    c = [demander_vecteur(f"  c, ligne {i + 1}/{p}", n) for i in range(p)]
+    phi = demander_vecteur(f"Fonction à minimiser phi : {n} nombres", n)
+    return np.array(a), np.array(b), np.array(c), np.array(phi)
+
+
+def saisir_parametres(n, defauts=None):
+    """Demande les paramètres de l'algorithme (n = nombre de variables, pour proposer
+    2·n itérations). Renvoie un dict utilisable par `solve`."""
+    d = dict(PARAMETRES_DEFAUT)
+    d.update(defauts or {})
+    print("\nParamètres de l'algorithme (Entrée = valeur proposée)")
+    n_population = demander("  Taille de la population", d["n_population"], minimum=1)
+    alpha = demander("  alpha", d["alpha"], minimum=1)
+    explor = demander("  Variables explorées par itération", min(d["explor"], n),
+                      minimum=1, maximum=n)
+    iterations = demander("  Nombre d'itérations",
+                          2 * n if d["iterations"] is None else d["iterations"], minimum=1)
+    positivity = demander_oui_non("  Ajouter les contraintes x >= 0 ?", d["positivity"])
+    return {"n_population": n_population, "alpha": alpha, "explor": explor,
+            "iterations": iterations, "positivity": positivity}

dega2/example.py

@@ -0,0 +1,29 @@
+"""Démonstration : reproduit le script DEGA2.py d'origine sur un problème aléatoire."""
+import numpy as np
+
+from . import problems
+from .solver import solve
+
+
+def demo(n=30, p=10, m1=15, n_population=80, alpha=4, explor=3,
+         iterations=None, seed=None, plot=True, verbose=True):
+    """Génère un problème aléatoire (n variables, p objectifs, m1 contraintes),
+    le résout avec DEGA-2 et renvoie le `Result`."""
+    if seed is not None:
+        np.random.seed(seed)
+
+    a, b, c, phi = problems.Genr(n, m1, p)
+    T = 2 * n if iterations is None else iterations
+
+    if verbose:
+        print("\n🧬  DEGA-2 — démarrage de l'optimisation "
+              f"(n={n}, objectifs={p}, contraintes={m1}, itérations={T})\n")
+
+    res = solve(a, b, c, phi, n_population=n_population, alpha=alpha,
+                explor=explor, iterations=T, verbose=verbose)
+
+    if verbose:
+        print("\n" + res.summary(max_vars=n) + "\n")
+    if plot:
+        res.plot()
+    return res

dega2/influ_cof.py

@@ -0,0 +1,29 @@
+import numpy as np
+
+
+def selct(c, n, p, phi):
+    # coefficients normalisés (version vectorisée des doubles boucles d'origine)
+    sum_c = np.sum(np.abs(c), axis=1)[:, np.newaxis]
+    sum_phi = np.sum(np.abs(phi))
+    cof_c = np.sum(c / sum_c, axis=0)       # influence cumulée de chaque variable
+    cof_phi = phi[0, :] / sum_phi
+
+    p_cof1 = np.empty((3, n))
+    p_cofphi1 = np.empty((3, n))
+
+    p_cof1[0, :] = np.abs(cof_c)
+    p_cofphi1[0, :] = np.abs(cof_phi)
+    p_cof1[1, :] = np.arange(n)
+    p_cofphi1[1, :] = np.arange(n)
+    p_cof1[2, :] = np.where(cof_c < 0, -1, 1)
+    # Comportement d'origine conservé : le signe de p_cofphi vaut toujours -1
+    # (les deux branches du `if` d'origine donnaient -1). Voir remarque.
+    p_cofphi1[2, :] = -1
+
+    # tri par influence décroissante (même expression que l'original)
+    p_cof1 = p_cof1[::, p_cof1[0, ].argsort()[::-1]]
+    p_cofphi1 = p_cofphi1[::, p_cofphi1[0, ].argsort()[::-1]]
+    index_p = (p_cof1[1, :])[np.newaxis, :].astype(int)
+    index_phi = (p_cofphi1[1, :])[np.newaxis, :].astype(int)
+
+    return [p_cof1, index_p, p_cofphi1, index_phi]

dega2/plotting.py

@@ -0,0 +1,32 @@
+"""Courbe de convergence (matplotlib est une dépendance optionnelle)."""
+import numpy as np
+
+
+def plot_convergence(result, show=True):
+    try:
+        import matplotlib.pyplot as plt
+    except ImportError as exc:  # pragma: no cover
+        raise ImportError(
+            "matplotlib est requis pour tracer la courbe : "
+            "pip install \"dega2[plot]\""
+        ) from exc
+
+    y = np.ravel(result.history)
+    t = np.arange(len(y))
+
+    fig, ax = plt.subplots(figsize=(9, 5))
+    ax.plot(t, y, color="#d62728", linewidth=2, label="min φ")
+    ax.fill_between(t, y, y.max(), color="#d62728", alpha=0.08)
+    ax.scatter([t[-1]], [y[-1]], color="#d62728", zorder=3)
+    ax.annotate(f"φ* = {y[-1]:.4g}", xy=(t[-1], y[-1]),
+                xytext=(-90, 25), textcoords="offset points",
+                arrowprops=dict(arrowstyle="->", color="gray"))
+    ax.set_xlabel("Iterations")
+    ax.set_ylabel("min of  phi")
+    ax.set_title("Convergence of DEGA-2")
+    ax.grid(True, linestyle="--", alpha=0.4)
+    ax.legend()
+    fig.tight_layout()
+    if show:
+        plt.show()
+    return fig

dega2/problems.py

@@ -0,0 +1,15 @@
+import numpy as np
+
+def Genr(n,m1,p):
+    a=np.random.randint(1,10,(m1,n),dtype=int)
+
+    
+
+    b=np.random.randint(8*n,10*n,m1,dtype=int)[:,np.newaxis]
+    
+
+    c=np.random.randint(-10,10,(p,n),dtype=int)
+    phi=np.random.randint(-10,10,n,dtype=int)[np.newaxis,:]
+    return a,b,c,phi
+    
+

dega2/solver.py

@@ -0,0 +1,120 @@
+"""Interface publique de DEGA-2.
+
+    >>> import dega2
+    >>> res = dega2.solve(a, b, c, phi)
+    >>> res.x, res.phi
+"""
+import time
+from dataclasses import dataclass
+
+import numpy as np
+
+from . import GA4, GenPop, influ_cof
+
+
+@dataclass
+class Result:
+    """Résultat d'une optimisation DEGA-2."""
+
+    x: np.ndarray            # meilleure solution trouvée (vecteur de longueur n)
+    phi: float               # valeur de phi pour cette solution
+    history: np.ndarray      # minimum de phi à chaque itération
+    population: np.ndarray   # population de la dernière itération, avant sélection (une solution par colonne)
+    time: float              # temps de calcul en secondes
+    iterations: int          # nombre d'itérations effectuées
+
+    def summary(self, max_vars=None):
+        """Encadré texte récapitulatif (comme dans le script d'origine)."""
+        x = np.ravel(self.x)
+        shown = x if max_vars is None else x[:max_vars]
+        apercu = ", ".join(f"{v:.4g}" for v in shown)
+        lignes = [
+            "RÉSULTATS DEGA-2",
+            f"Phi optimum   : {self.phi:.6g}",
+            f"Temps CPU     : {self.time:.2f} s",
+            f"Itérations    : {self.iterations}",
+            f"x*  : {apercu}",
+        ]
+        largeur = max(len(ligne) for ligne in lignes) + 2
+        out = ["┏" + "━" * largeur + "┓"]
+        for i, ligne in enumerate(lignes):
+            out.append("┃ " + ligne.ljust(largeur - 1) + "┃")
+            if i == 0:
+                out.append("┣" + "━" * largeur + "┫")
+        out.append("┗" + "━" * largeur + "┛")
+        return "\n".join(out)
+
+    def plot(self, show=True):
+        """Trace la courbe de convergence (nécessite matplotlib)."""
+        from .plotting import plot_convergence
+        return plot_convergence(self, show=show)
+
+
+def solve(a, b, c, phi, *, n_population=80, alpha=4, explor=3,
+          iterations=None, positivity=True, seed=None, verbose=True):
+    """Lance DEGA-2 sur le problème :  min phi·x  sous  a·x <= b,  x entier.
+
+    Paramètres
+    ----------
+    a : (m, n)  matrice des contraintes.
+    b : (m,) ou (m, 1)  second membre.
+    c : (p, n)  matrice des p objectifs (sert au test de non-dominance).
+    phi : (n,) ou (1, n)  fonction objectif scalaire à minimiser.
+    n_population : taille de la population.
+    alpha : la population d'exploration « phi » est de taille n_population / alpha.
+    explor : nombre de variables explorées à chaque itération.
+    iterations : nombre d'itérations (par défaut 2 * n).
+    positivity : si True, ajoute les contraintes x >= 0 (comme le script d'origine).
+    seed : graine du générateur aléatoire (résultats reproductibles).
+    verbose : affiche la barre de progression.
+
+    Renvoie un objet `Result`.
+    """
+    a = np.atleast_2d(np.asarray(a))
+    b = np.asarray(b).reshape(-1, 1)
+    c = np.atleast_2d(np.asarray(c))
+    phi = np.asarray(phi).reshape(1, -1)
+
+    n = a.shape[1]
+    p = c.shape[0]
+    if b.shape[0] != a.shape[0]:
+        raise ValueError("b doit avoir autant de lignes que a.")
+    if c.shape[1] != n or phi.shape[1] != n:
+        raise ValueError("a, c et phi doivent avoir le même nombre de variables n.")
+    if not 1 <= explor <= n:
+        raise ValueError("explor doit être compris entre 1 et n.")
+    if n_population < 1 or alpha < 1:
+        raise ValueError("n_population et alpha doivent être >= 1.")
+
+    T = 2 * n if iterations is None else int(iterations)
+
+    if seed is not None:
+        np.random.seed(seed)
+
+    if positivity:
+        a = np.concatenate((a, -np.eye(n)), axis=0)
+        b = np.concatenate((b, np.zeros((n, 1))), axis=0)
+
+    # Population initiale
+    population = GenPop.Gen(a, b, c, n, n_population)
+
+    # Influence des coefficients
+    p_cof1, index_p, p_cofphi1, index_phi = influ_cof.selct(c, n, p, phi)
+
+    # Algorithme
+    t0 = time.perf_counter()
+    pop_final, _, min_phi, x_opt = GA4.NewPop(
+        population, n_population, explor,
+        p_cof1, index_p, p_cofphi1, index_phi,
+        phi, alpha, a, b, c, T, n, verbose=verbose)
+    elapsed = time.perf_counter() - t0
+
+    history = np.asarray(min_phi, dtype=float)
+    return Result(
+        x=np.ravel(x_opt),
+        phi=float(history[-1]),
+        history=history,
+        population=pop_final,
+        time=elapsed,
+        iterations=T,
+    )

dega2/upload_cofGA.py

@@ -0,0 +1,72 @@
+import numpy as np
+from collections import Counter
+def 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):
+    x1=Counter(tab_ind11)
+    x2=Counter(tab_ind11_phi)
+    x3=Counter(tab_ind1)
+    x4=Counter(tab_ind1_phi)
+    counter_tab11=list(x1.items())
+    counter_tab11_phi=list(x2.items())
+    counter_tab1=list(x3.items())
+    counter_tab1_phi=list(x4.items())
+   
+    
+    l1=len(counter_tab1)
+    l2=len(counter_tab11)
+    l3=len(counter_tab1_phi)
+    l4=len(counter_tab11_phi)
+    
+    if (l1==explor) and (l2==explor):
+        rho=[]
+        for i in range (0,explor):
+            rho.append(counter_tab11[i][1]/counter_tab1[i][1])
+    else:
+        rho=[0]*explor
+        for ii in range(0,explor):
+            jj=0
+            while jj<l1:
+                if condidat[ii]==counter_tab1[jj][0]:
+                    tt=0
+                    while tt<l2:
+                        if counter_tab1[jj][0]==counter_tab11[tt][0]:
+                            rho[ii]=counter_tab11[tt][1]/counter_tab1[jj][1]
+                        tt=tt+1
+                jj=jj+1
+                
+                
+    if (l3==explor) and (l4==explor):
+       rho1=[]
+       for i in range (0,explor):
+           rho1.append(counter_tab11_phi[i][1]/counter_tab1_phi[i][1])
+    else:
+        rho1=[0]*explor
+        for ii in range(0,explor):
+            jj=0
+            while jj<l3:
+                if condidat_phi[ii]==counter_tab1_phi[jj][0]:
+                    tt=0
+                    while tt<l4:
+                        if counter_tab1_phi[jj][0]==counter_tab11_phi[tt][0]:
+                            rho1[ii]=counter_tab11_phi[tt][1]/counter_tab1_phi[jj][1]
+                        tt=tt+1
+                jj=jj+1           
+    rho_p=[]
+    rho_phi=[]
+    for i in range(0,explor):
+        rho_p.append((p_cof1[0,i])*(rho[i])**2)
+        p_cof1[0,i]=rho_p[i]
+        rho_phi.append((p_cofphi1[0,i])*(rho1[i])**2)
+        p_cofphi1[0,i]=rho_phi[i] 
+    
+    p_cof1= p_cof1[::, p_cof1[0,].argsort()[::-1]]
+    p_cofphi1= p_cofphi1[::, p_cofphi1[0,].argsort()[::-1]]
+    index_p=(p_cof1[1,:])[np.newaxis,:]
+    index_phi=(p_cofphi1[1,:])[np.newaxis,:]
+    index_p=index_p.astype(int)
+    index_phi=index_phi.astype(int)
+    return p_cof1,p_cofphi1, index_p,index_phi
+               
+    
+    
+    
+

dega2-0.1.0.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,23 @@
+dega2/BuildpopGA.py,sha256=rjdFi_fuzGCqdHqZioOrO6Moap_tN6i7TgkMMKdhDGg,1953
+dega2/ConsChek.py,sha256=YeR8auh1Pp0qDOvqq5ho74qASVnzfxcuROiXz1TwuK8,169
+dega2/ConsChekGA4.py,sha256=TYfZKhtZrnFfJaUHx3EiMk-akEBv1L1iMGN68v9ZuBo,577
+dega2/DomChek.py,sha256=rafMg_9Xbt_cesNXxOYX2pOI2QX8e_xnGu1PkASijDk,692
+dega2/DomChekGA4.py,sha256=FrLNy1q-PEcHr6kXyMOZa6WMCjs_A8qVs0_irqOU6hc,3332
+dega2/GA4.py,sha256=mI4g6O6gDXia4npm7gpeiEIN9-6EMJHFOYaT3cHudhQ,2181
+dega2/GenPop.py,sha256=ZgcXpGYZhIQnjrrHEa5Z8AP-SxQagRd0dIx_LBzLxQ8,1414
+dega2/__init__.py,sha256=4YUmz0fH3yyfi7wPR5kCQU1-38usChBvgNP3IaGvfuc,307
+dega2/__main__.py,sha256=MHKZ_ae3fSLGTLUUMOx15fWdeOnJSHhq-zslRP5F5Lc,79
+dega2/cli.py,sha256=7XmihOue_34Edjov6YykhwFq43lL-GXdoktfMDqzbxY,6112
+dega2/entree.py,sha256=zFqYLJnlpswm3pFKadrCYSLbHmn8rzLbqwZxGQ97kpQ,7009
+dega2/example.py,sha256=iP2zpYYIr2xyGKD9_Besr8yaxsrVyVwgdHTUTMPC36g,987
+dega2/influ_cof.py,sha256=B95jXUxy3JClO8uWKchPDBo3K-aob4xB0y2MXtviLIE,1116
+dega2/plotting.py,sha256=3LgxRzR5SPp1GI80O1sQk1KetEYtTJu-E6qwUJJtlyE,1098
+dega2/problems.py,sha256=xudbft7jXXpXA7actbJVtpqZ7LnPN_s01I8O4s8b5n8,294
+dega2/solver.py,sha256=1F8OO7mIKkd0GIyaoQVwoDfmmnCumjJtcF_0ZafaGt8,4358
+dega2/upload_cofGA.py,sha256=v3QeIWlhK8CQm9CE7Gc0ukIq1hKXkveQ0OxvJfpJYXU,2373
+dega2-0.1.0.dist-info/licenses/LICENSE,sha256=1riZ1sfK9aSG3-OIJCXqWYqNOHIZApqInCP64juYiVU,1066
+dega2-0.1.0.dist-info/METADATA,sha256=oGuueAcuxni3If4K4V8kIbeBARlbqCSTnZvXIAK49NQ,3550
+dega2-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+dega2-0.1.0.dist-info/entry_points.txt,sha256=8kH-bHcg7HiErUcwWDb1tNFiMWeewohUQfG9v1hpe1g,41
+dega2-0.1.0.dist-info/top_level.txt,sha256=3MN8auQqwfRd1lNGX52TzD434deySaQnxiDtg-AI5So,6
+dega2-0.1.0.dist-info/RECORD,,

dega2-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

dega2-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+dega2 = dega2.cli:main

dega2-0.1.0.dist-info/licenses/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.dist-info/top_level.txt

@@ -0,0 +1 @@
+dega2