IGJSP 1.0.1__py3-none-any.whl → 1.1.1__py3-none-any.whl

IGJSP/generador.py

@@ -26,6 +26,42 @@ def t(c):
     return 4.0704 * np.log(2) / np.log(1 + (c* 2.5093)**3)
 
 
+# ------- Helpers internos para el DZN -------
+
+def _parse_int_var(text, name, default=None):
+    """
+    Busca una variable escalar tipo: name = 10;
+    """
+    m = re.search(rf'\b{name}\b\s*=\s*([0-9]+)', text)
+    if m:
+        return int(m.group(1))
+    if default is not None:
+        return default
+    raise ValueError(f"No se encontró la variable entera '{name}' en el fichero DZN.")
+
+
+def _parse_array_var(text, name):
+    """
+    Busca una variable array tipo:
+        name = [1, 2, 3];
+    o
+        name = [1 2 3];
+    Devuelve un np.array de ints o None si no está.
+    """
+    m = re.search(rf'\b{name}\b\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)
+
 #################################################################################
 #                                                                               # 
 #                                    JSP                                       # 
@@ -124,10 +160,325 @@ class JSP:
         else:
             return expon(loc=duration, scale=duration/2).rvs()
 
-    def savePythonFile(self, path):
-        os.makedirs(os.path.dirname(path), exist_ok=True)
-        with open(path, 'wb') as f:
-            pickle.dump(self, f)
+    def loadPythonFile(path):
+        """
+        Carga un fichero .pkl generado por savePythonFile y devuelve un JSP.
+        """
+        with open(path, 'rb') as f:
+            obj = pickle.load(f)
+
+        # Si ya es un JSP, lo devolvemos tal cual
+        if isinstance(obj, JSP):
+            return obj
+
+        # Si es un dict con la misma estructura que usamos en loadJsonFile, construimos el JSP
+        if isinstance(obj, dict) and all(
+            k in obj for k in ['jobs', 'machines', 'ProcessingTime', 'EnergyConsumption', 'ReleaseDateDueDate', 'Orden']
+        ):
+            return JSP(**obj)
+
+        raise TypeError(
+            f"El objeto cargado desde {path} no es un JSP ni un diccionario compatible para construir uno."
+        )
+
+    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).
+        """
+        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)
+
+        time_flat = _parse_array_var(text, 'time')
+        energy_flat = _parse_array_var(text, 'energy')
+        prec_flat = _parse_array_var(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.")
+
+        # Comprobar tamaños
+        expected_te = numJobs * numMchs * speed
+        if time_flat.size != expected_te or energy_flat.size != expected_te:
+            raise ValueError(
+                f"Tamaños incompatibles en time/energy: esperado {expected_te}, "
+                f"time={time_flat.size}, energy={energy_flat.size}"
+            )
+
+        expected_prec = numJobs * numMchs
+        if prec_flat.size != expected_prec:
+            raise ValueError(
+                f"Tamaño incompatible en precedence: esperado {expected_prec}, precedence={prec_flat.size}"
+            )
+
+        ProcessingTime = time_flat.reshape((numJobs, numMchs, speed))
+        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)
+        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')
+
+        if release_flat is None or due_flat is None:
+            # rddd = 0
+            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)
+                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)
+                ReleaseDueDate = np.zeros((numJobs, numMchs, 2), dtype=int)
+                ReleaseDueDate[:, :, 0] = release_flat.reshape((numJobs, numMchs))
+                ReleaseDueDate[:, :, 1] = due_flat.reshape((numJobs, numMchs))
+            else:
+                raise ValueError(
+                    "Los tamaños de releaseDate/dueDate no cuadran ni con rddd=1 ni con rddd=2."
+                )
+
+        sol = {
+            'jobs': numJobs,
+            'machines': numMchs,
+            'ProcessingTime': ProcessingTime,
+            'EnergyConsumption': EnergyConsumption,
+            'ReleaseDateDueDate': ReleaseDueDate,
+            'Orden': Orden
+        }
+        return JSP(**sol)
+
+    def loadTaillardFile(path):
+        """
+        Carga un fichero de texto generado por saveTaillardStandardFile y devuelve un JSP.
+        Formato esperado:
+
+            Number of jobs: J
+            Number of machines: M
+
+            Processing times:
+            ... J filas, cada una con M enteros ...
+
+            Energy consumption:
+            ... J filas, cada una con M enteros ...
+
+            Machine order:
+            ... J filas, cada una con M enteros ...
+        """
+        with open(path, 'r') as f:
+            lines = [line.strip() for line in f]
+
+        # Leer encabezado
+        # Number of jobs: X
+        # Number of machines: Y
+        numJobs = None
+        numMchs = None
+
+        i = 0
+        while i < len(lines):
+            line = lines[i]
+            if line.startswith("Number of jobs"):
+                numJobs = int(line.split(":")[1].strip())
+            elif line.startswith("Number of machines"):
+                numMchs = int(line.split(":")[1].strip())
+            if numJobs is not None and numMchs is not None:
+                i += 1
+                break
+            i += 1
+
+        if numJobs is None or numMchs is None:
+            raise ValueError("No se pudieron leer numJobs / numMchs del fichero Taillard.")
+
+        # Saltar líneas vacías hasta "Processing times:"
+        while i < len(lines) and lines[i] == "":
+            i += 1
+        if i >= len(lines) or not lines[i].startswith("Processing times"):
+            raise ValueError("No se encontró la sección 'Processing times:' en el fichero Taillard.")
+        i += 1  # pasar la línea de cabecera
+
+        # Leer matriz de tiempos de procesamiento (J filas)
+        proc_by_order = np.zeros((numJobs, numMchs), dtype=int)
+        for j in range(numJobs):
+            while i < len(lines) and lines[i] == "":
+                i += 1
+            parts = lines[i].split()
+            if len(parts) != numMchs:
+                raise ValueError(
+                    f"Línea de tiempos de procesamiento para job {j} tiene {len(parts)} elementos, "
+                    f"pero se esperaban {numMchs}."
+                )
+            proc_by_order[j, :] = [int(x) for x in parts]
+            i += 1
+
+        # Saltar hasta "Energy consumption:"
+        while i < len(lines) and lines[i] == "":
+            i += 1
+        if i >= len(lines) or not lines[i].startswith("Energy consumption"):
+            raise ValueError("No se encontró la sección 'Energy consumption:' en el fichero Taillard.")
+        i += 1  # cabecera
+
+        energy_by_order = np.zeros((numJobs, numMchs), dtype=int)
+        for j in range(numJobs):
+            while i < len(lines) and lines[i] == "":
+                i += 1
+            parts = lines[i].split()
+            if len(parts) != numMchs:
+                raise ValueError(
+                    f"Línea de consumo de energía para job {j} tiene {len(parts)} elementos, "
+                    f"pero se esperaban {numMchs}."
+                )
+            energy_by_order[j, :] = [int(x) for x in parts]
+            i += 1
+
+        # Saltar hasta "Machine order:"
+        while i < len(lines) and lines[i] == "":
+            i += 1
+        if i >= len(lines) or not lines[i].startswith("Machine order"):
+            raise ValueError("No se encontró la sección 'Machine order:' en el fichero Taillard.")
+        i += 1  # cabecera
+
+        Orden = np.zeros((numJobs, numMchs), dtype=int)
+        for j in range(numJobs):
+            while i < len(lines) and lines[i] == "":
+                i += 1
+            parts = lines[i].split()
+            if len(parts) != numMchs:
+                raise ValueError(
+                    f"Línea de orden de máquinas para job {j} tiene {len(parts)} elementos, "
+                    f"pero se esperaban {numMchs}."
+                )
+            Orden[j, :] = [int(x) for x in parts]
+            i += 1
+
+        # Reconstruir ProcessingTime y EnergyConsumption con speed=1
+        speed = 1
+        ProcessingTime = np.zeros((numJobs, numMchs, speed), dtype=int)
+        EnergyConsumption = np.zeros((numJobs, numMchs, speed), dtype=int)
+
+        for j in range(numJobs):
+            for pos in range(numMchs):
+                machine = Orden[j, pos]
+                ProcessingTime[j, machine, 0] = proc_by_order[j, pos]
+                EnergyConsumption[j, machine, 0] = energy_by_order[j, pos]
+
+        # Taillard estándar: sin release/due dates → rddd=0
+        ReleaseDueDate = np.array([])
+
+        sol = {
+            'jobs': numJobs,
+            'machines': numMchs,
+            'ProcessingTime': ProcessingTime,
+            'EnergyConsumption': EnergyConsumption,
+            'ReleaseDateDueDate': ReleaseDueDate,
+            'Orden': Orden
+        }
+        return JSP(**sol)
+        
+    def loadJsonFile(path):
+        with open(path, "r") as f:
+            data = json.load(f)
+        numJobs = len(data["nbJobs"])
+        numMchs = len(data["nbMchs"])
+        speed = data["speed"]
+    
+        # # Load KPIs (opcional)
+        # min_makespan = data.get("minMakespan", None)
+        # min_energy = data.get("minEnergy", None)
+        # max_min_makespan = data.get("maxMinMakespan", None)
+        # max_min_energy = data.get("maxMinEnergy", None)
+    
+        # Prepare empty structures
+        ProcessingTime = np.zeros((numJobs, numMchs, speed), dtype=int)
+        EnergyConsumption = np.zeros((numJobs, numMchs, speed), dtype=int)
+        Orden_list = [[] for _ in range(numJobs)]
+    
+        # Detect rddd mode
+        # rddd = 0 → no release/due dates
+        # rddd = 1 → job-level RDF
+        # rddd = 2 → operation-level RDF
+        rddd = 0
+        if data["timeEnergy"]:
+            if "release-date" in data["timeEnergy"][0]:
+                rddd = 1
+            for m in data["timeEnergy"][0]["operations"]:
+                if "release-date" in data["timeEnergy"][0]["operations"][m]:
+                    rddd = 2
+                    break
+    
+        # Initialize ReleaseDueDate array according to rddd
+        if rddd == 1:
+            ReleaseDueDate = np.zeros((numJobs, 2), dtype=int)
+        elif rddd == 2:
+            ReleaseDueDate = np.zeros((numJobs, numMchs, 2), dtype=int)
+        else:
+            # No dates: devolver array vacío para que __init__ detecte rddd=0
+            ReleaseDueDate = np.array([])
+    
+        # -------------------------
+        # Load jobs & operations
+        # -------------------------
+        for job_data in data["timeEnergy"]:
+            job = int(job_data["jobId"])
+    
+            # Optional job-level release/due dates
+            if rddd == 1:
+                ReleaseDueDate[job, 0] = int(job_data["release-date"])
+                ReleaseDueDate[job, 1] = int(job_data["due-date"])
+    
+            for machine_str, op_data in job_data["operations"].items():
+                machine = int(machine_str)
+                Orden_list[job].append(machine)
+    
+                # Load speed-scaling arrays
+                proc_times = [int(entry["procTime"]) for entry in op_data["speed-scaling"]]
+                energies = [int(entry["energyCons"]) for entry in op_data["speed-scaling"]]
+    
+                # Aseguramos longitud speed
+                # Si speed > len(proc_times) -> rellenamos con ceros (o ajustar según tu política)
+                proc_arr = np.zeros((speed,), dtype=int)
+                en_arr = np.zeros((speed,), dtype=int)
+                L = min(len(proc_times), speed)
+                proc_arr[:L] = proc_times[:L]
+                en_arr[:L] = energies[:L]
+    
+                ProcessingTime[job, machine, :] = proc_arr
+                EnergyConsumption[job, machine, :] = en_arr
+    
+                if rddd == 2:
+                    ReleaseDueDate[job, machine, 0] = int(op_data["release-date"])
+                    ReleaseDueDate[job, machine, 1] = int(op_data["due-date"])
+    
+        # Convertir Orden a ndarray (shape = numJobs x numMchs)
+        Orden = np.zeros((numJobs, numMchs), dtype=int)
+        for j in range(numJobs):
+            if len(Orden_list[j]) != numMchs:
+                # Si por algun motivo no tiene todas las máquinas,
+                # rellenamos con -1 o lanzamos error; aquí uso -1.
+                row = Orden_list[j] + [-1] * (numMchs - len(Orden_list[j]))
+            else:
+                row = Orden_list[j]
+            Orden[j, :] = np.array(row, dtype=int)
+    
+        sol = {
+            'jobs': numJobs,
+            'machines': numMchs,
+            'ProcessingTime': ProcessingTime,
+            'EnergyConsumption': EnergyConsumption,
+            'ReleaseDateDueDate': ReleaseDueDate,   # <-- ahora es array, no int
+            'Orden': Orden
+        }
+        return JSP(**sol)
 
     def saveJsonFile(self, path):
         self.JSP = {
@@ -150,13 +501,13 @@ class JSP:
             for machine in self.Orden[job]:
                 machine = int(machine)
                 new["operations"][machine] = {"speed-scaling" : 
-                                              [
+                                            [
                                                 {"procTime" : int(proc),
-                                                 "energyCons" : int(energy)
+                                                "energyCons" : int(energy)
                                                 }
                                                 for proc, energy in zip(self.ProcessingTime[job, machine],self.EnergyConsumption[job, machine])
-                                              ]
-                                              }
+                                            ]
+                                            }
                 if self.rddd == 2:
                     new["operations"][machine]["release-date"] = int(self.ReleaseDueDate[job][machine][0])
                     new["operations"][machine]["due-date"] = int(self.ReleaseDueDate[job][machine][1])
@@ -192,6 +543,11 @@ class JSP:
             
             f.write(json_str)
 
+    def savePythonFile(self, path):
+        os.makedirs(os.path.dirname(path), exist_ok=True)
+        with open(path, 'wb') as f:
+            pickle.dump(self, f)
+
     def saveDznFile(self, InputDir, OutputDir):
         indexProblema = OutputDir.split("/")[-2]
         OutputDir = "/".join(OutputDir.split("/")[:-2])

{igjsp-1.0.1.dist-info → igjsp-1.1.1.dist-info}/METADATA

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

{igjsp-1.0.1.dist-info → igjsp-1.1.1.dist-info}/RECORD

@@ -1,4 +1,4 @@
-IGJSP/generador.py,sha256=w9SxkVC3oj4inIH9gP_CKvOecMm84_TVS08Kbc12A6E,34349
+IGJSP/generador.py,sha256=vpopW1e8zwZ5H69uvCSY28KJuP-XGNM6VQPKCTawiAs,48598
 IGJSP/main.py,sha256=Sia5Ss8O3HWBdshvPLJKUMaZIoQPHy6x8yzvojojPFo,2838
 IGJSP/Minizinc/Models/RD/JSP0.mzn,sha256=cfN_E3RQ6nBulGfaOOYTd-zAgA5SI6E2saDlYtKCflg,2282
 IGJSP/Minizinc/Models/RD/JSP1.mzn,sha256=5B8cyw2WyKR8yEL1fFd0TaCAVhjPoxEJRJDPPEjJGEk,2840
@@ -12,7 +12,7 @@ IGJSP/Minizinc/Types/RD/FJSP/type2.dzn,sha256=Wz1MnkSL5GUPsbh1eq0leoaQRImkNqQqkX
 IGJSP/Minizinc/Types/RD/JSP/type0.dzn,sha256=wNuPQkXBXPSpPaPz2WFhp4pGDgfSimtg4I93UfwC01Q,263
 IGJSP/Minizinc/Types/RD/JSP/type1.dzn,sha256=Xbt9StzCgEqqh_HS9tWGrTVtu-OEnf5Yq5Ty91AkzoM,333
 IGJSP/Minizinc/Types/RD/JSP/type2.dzn,sha256=L2nc7bPJEhyuaEwgw0ZCpC52CpVJILQU_WQdKn8GUZs,379
-igjsp-1.0.1.dist-info/METADATA,sha256=xBsUY3HSGQvowsRaCPdf1wmwU8N9N_c9QykR2Y7dZs4,10609
-igjsp-1.0.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-igjsp-1.0.1.dist-info/licenses/LICENSE,sha256=f7RDRO-z_nMoooAya7NAb8sXtrHR6WnttYtyUc9fB-c,1116
-igjsp-1.0.1.dist-info/RECORD,,
+igjsp-1.1.1.dist-info/METADATA,sha256=JtfzaTnLrHW2GMG__daue2UjaEjh9_0UwgDMFDjVCRI,10609
+igjsp-1.1.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+igjsp-1.1.1.dist-info/licenses/LICENSE,sha256=f7RDRO-z_nMoooAya7NAb8sXtrHR6WnttYtyUc9fB-c,1116
+igjsp-1.1.1.dist-info/RECORD,,

{igjsp-1.0.1.dist-info → igjsp-1.1.1.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.27.0
+Generator: hatchling 1.28.0
 Root-Is-Purelib: true
 Tag: py3-none-any