IGJSP 1.1.0__tar.gz → 1.1.2__tar.gz

{igjsp-1.1.0 → igjsp-1.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: IGJSP
-Version: 1.1.0
+Version: 1.1.2
 Summary: Instance generator for JSP
 Project-URL: Homepage, https://gps.blogs.upv.es/
 Author-email: GPS-UPV <gps@dsic.upv.es>

{igjsp-1.1.0 → igjsp-1.1.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "IGJSP"
-version = "1.1.0"
+version = "1.1.2"
 authors = [
   { name="GPS-UPV", email="gps@dsic.upv.es" },
 ]

{igjsp-1.1.0 → igjsp-1.1.2}/src/IGJSP/generador.py

@@ -26,6 +26,101 @@ def t(c):
     return 4.0704 * np.log(2) / np.log(1 + (c* 2.5093)**3)
 
 
+# ------- Helpers internos para el DZN -------
+
+
+def _parse_set_size(text, name):
+    """
+    Obtiene el tamaño de un conjunto tipo:
+        JOBS = 1..50;
+    Devuelve 50.
+    """
+    m = re.search(rf'\b{name}\b\s*=\s*1\.\.(\d+)\s*;', text)
+    if not m:
+        raise ValueError(f"No se pudo encontrar el conjunto {name} = 1..N; en el fichero DZN.")
+    return int(m.group(1))
+
+
+def _parse_speed(text):
+    """
+    SPEED puede ir como:
+        SPEED = 1;
+    o (por si acaso) como 1..SPEED; (aunque en tu ejemplo es un escalar).
+    """
+    m = re.search(r'\bSPEED\b\s*=\s*(\d+)\s*;', text)
+    if m:
+        return int(m.group(1))
+
+    m = re.search(r'\bSPEED\b\s*=\s*1\.\.(\d+)\s*;', text)
+    if m:
+        return int(m.group(1))
+
+    # Si no aparece, asumimos 1 (como en muchos templates tuyos)
+    return 1
+
+
+def _parse_array_from_arrayXd(text, name):
+    """
+    Extrae la parte entre corchetes de cosas tipo:
+        name = array3d(...,[1,2,3,...]);
+        name = array2d(...,[1,2,3,...]);
+        name = array1d(...,[1,2,3,...]);
+
+    Devuelve np.array de ints o None si no se encuentra.
+    """
+    m = re.search(
+        rf'\b{name}\b\s*=\s*array[123]d\([^[]*\[\s*(.*?)\s*\]\s*\)\s*;',
+        text,
+        re.DOTALL
+    )
+    if not m:
+        return None
+
+    inner = m.group(1).strip()
+    if not inner:
+        return np.array([], dtype=int)
+
+    # Separar por comas o espacios
+    tokens = re.split(r'[\s,]+', inner)
+    tokens = [t for t in tokens if t != '']
+
+    return np.array([int(t) for t in tokens], dtype=int)
+
+
+def _parse_array_fallback_plain(text, name):
+    """
+    Fallback para cosas tipo:
+        name = [1,2,3,...];
+    por si en algún template no se usa arrayXd.
+    """
+    m = re.search(
+        rf'\b{name}\b\s*=\s*\[\s*(.*?)\s*\]\s*;',
+        text,
+        re.DOTALL
+    )
+    if not m:
+        return None
+
+    inner = m.group(1).strip()
+    if not inner:
+        return np.array([], dtype=int)
+
+    tokens = re.split(r'[\s,]+', inner)
+    tokens = [t for t in tokens if t != '']
+
+    return np.array([int(t) for t in tokens], dtype=int)
+
+
+def _parse_array_generic(text, name):
+    """
+    Intenta primero arrayXd(...,[...]); y si no lo encuentra,
+    prueba el formato plano name = [ ... ];
+    """
+    arr = _parse_array_from_arrayXd(text, name)
+    if arr is not None:
+        return arr
+    return _parse_array_fallback_plain(text, name)
+
 #################################################################################
 #                                                                               # 
 #                                    JSP                                       # 
@@ -147,24 +242,46 @@ class JSP:
 
     def loadDznFile(path):
         """
-        Carga un .dzn generado por saveDznFile y devuelve un JSP.
-        Soporta rddd = 0, 1, 2 (sin fechas, fechas por job, fechas por operación).
+        Carga un .dzn generado a partir de tus templates, del estilo:
+
+            JOBS = 1..J;
+            MACHINES = 1..M;
+            SPEED = S;
+
+            time = array3d(JOBS,MACHINES,1..SPEED,[...]);
+            energy = array3d(JOBS,MACHINES,1..SPEED,[...]);
+            precedence = array2d(JOBS,MACHINES,[...]);
+
+        Opcionalmente puede contener:
+            releaseDate = array1d(JOBS,[...])  (rddd = 1)
+            dueDate     = array1d(JOBS,[...])
+
+        o
+
+            releaseDate = array2d(JOBS,MACHINES,[...])  (rddd = 2)
+            dueDate     = array2d(JOBS,MACHINES,[...])
+
+        Devuelve un objeto JSP(**sol) consistente con loadJsonFile.
         """
         with open(path, 'r', encoding='utf-8') as f:
             text = f.read()
 
-        numJobs = _parse_int_var(text, 'jobs')
-        numMchs = _parse_int_var(text, 'machines')
-        speed = _parse_int_var(text, 'Speed', default=1)
+        # Eliminar comentarios de Minizinc (% hasta final de línea)
+        text = re.sub(r'%.*', '', text)
 
-        time_flat = _parse_array_var(text, 'time')
-        energy_flat = _parse_array_var(text, 'energy')
-        prec_flat = _parse_array_var(text, 'precedence')
+        # Leer tamaños de conjuntos
+        numJobs = _parse_set_size(text, "JOBS")
+        numMchs = _parse_set_size(text, "MACHINES")
+        speed = _parse_speed(text)
+
+        # Leer arrays principales
+        time_flat = _parse_array_generic(text, "time")
+        energy_flat = _parse_array_generic(text, "energy")
+        prec_flat = _parse_array_generic(text, "precedence")
 
         if time_flat is None or energy_flat is None or prec_flat is None:
-            raise ValueError("Faltan variables obligatorias (time, energy o precedence) en el fichero DZN.")
+            raise ValueError("No se pudieron leer 'time', 'energy' o 'precedence' del fichero DZN.")
 
-        # Comprobar tamaños
         expected_te = numJobs * numMchs * speed
         if time_flat.size != expected_te or energy_flat.size != expected_te:
             raise ValueError(
@@ -182,29 +299,27 @@ class JSP:
         EnergyConsumption = energy_flat.reshape((numJobs, numMchs, speed))
         precedence = prec_flat.reshape((numJobs, numMchs))
 
-        # Reconstruir Orden a partir de la precedencia (cada fila es posiciones 0..numMchs-1 por máquina)
+        # Reconstruir Orden a partir de precedence (igual que en saveDznFile)
+        # precedence[j, m] = posición de la máquina m en la secuencia 0..M-1
         Orden = np.zeros((numJobs, numMchs), dtype=int)
         for j in range(numJobs):
-            # precedence[j, m] = posición de la máquina m en la secuencia
-            # argsort da el índice de la máquina por orden de prioridad
             Orden[j, :] = np.argsort(precedence[j, :])
 
-        # Release / Due dates (pueden no existir)
-        release_flat = _parse_array_var(text, 'releaseDate')
-        due_flat = _parse_array_var(text, 'dueDate')
+        # --- Release / Due dates (si existen) ---
+        release_flat = _parse_array_generic(text, "releaseDate")
+        due_flat = _parse_array_generic(text, "dueDate")
 
         if release_flat is None or due_flat is None:
-            # rddd = 0
+            # rddd = 0 (no fechas)
             ReleaseDueDate = np.array([])
         else:
-            # O bien vector por job, o matriz jobs x machines
             if release_flat.size == numJobs and due_flat.size == numJobs:
-                # rddd = 1 → (numJobs, 2)
+                # rddd = 1: job-level
                 ReleaseDueDate = np.zeros((numJobs, 2), dtype=int)
                 ReleaseDueDate[:, 0] = release_flat
                 ReleaseDueDate[:, 1] = due_flat
             elif release_flat.size == numJobs * numMchs and due_flat.size == numJobs * numMchs:
-                # rddd = 2 → (numJobs, numMchs, 2)
+                # rddd = 2: operation-level
                 ReleaseDueDate = np.zeros((numJobs, numMchs, 2), dtype=int)
                 ReleaseDueDate[:, :, 0] = release_flat.reshape((numJobs, numMchs))
                 ReleaseDueDate[:, :, 1] = due_flat.reshape((numJobs, numMchs))
@@ -221,6 +336,7 @@ class JSP:
             'ReleaseDateDueDate': ReleaseDueDate,
             'Orden': Orden
         }
+
         return JSP(**sol)
 
     def loadTaillardFile(path):