walopy 0.4.2__tar.gz → 0.4.3__tar.gz

{walopy-0.4.2/src/walopy.egg-info → walopy-0.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: walopy
-Version: 0.4.2
+Version: 0.4.3
 Summary: Herramientas de investigación de operaciones: colas, inventarios, scheduling, CPM/PERT, confiabilidad, OEE, cuellos de botella y árboles de KPI
 Author-email: LeoSanta15 <angelsanta1@gmail.com>
 License-Expression: MIT

{walopy-0.4.2 → walopy-0.4.3}/src/walopy/__init__.py

@@ -164,7 +164,7 @@ from .solver import (
     solve_servers,
 )
 
-__version__ = "0.4.2"  # fuente única de la versión; pyproject.toml la lee con [tool.setuptools.dynamic]
+__version__ = "0.4.3"  # fuente única de la versión; pyproject.toml la lee con [tool.setuptools.dynamic]
 
 __all__ = [
     # idioma de los textos

{walopy-0.4.2 → walopy-0.4.3}/src/walopy/_catalogo_en.py

@@ -584,6 +584,10 @@ EN: dict[str, str] = {
     "solver.error.solve_lam.supera_incluso_muy_baja_objetivo": "{target_metric} exceeds {target_value} even with a very low λ. The target may be infeasible for this model / μ.",
     "solver.error.solve_mu.sigue_superando_objetivo_puede_ser": "{target_metric} still exceeds {target_value} with μ = {mu_max:.4g}. The target may be numerically infeasible.",
     "solver.error.solve_servers.pudo_cumplir_hasta_servidores_considere": "Could not meet {target_metric} ≤ {target_value} with up to {c_max} servers. Consider increasing μ or relaxing the target.",
+    "solver.error.optimize_servers.sin_servidores_estables_hasta_c_max": "With λ={lam} and μ={mu} at least {c_min} servers are needed for the system to be stable, but c_max={c_max}. Increase c_max.",
+    "solver.error.sensitivity.values_no_puede_estar_vacio": "values cannot be empty.",
+    "solver.error.sensitivity.param_no_es_parametro_modelo": "{param!r} is not a parameter of {modelo}.",
+    "solver.error.compare.sin_resultados": "compare needs at least one result.",
     "solver.etiqueta.compare.escenario": "scenario_{expr}",
     "solver.etiqueta.summary.convergio": "did NOT converge",
     "solver.etiqueta.summary.convergio_2": "converged",

{walopy-0.4.2 → walopy-0.4.3}/src/walopy/_catalogo_es.py

@@ -584,6 +584,10 @@ ES: dict[str, str] = {
     "solver.error.solve_lam.supera_incluso_muy_baja_objetivo": "{target_metric} supera {target_value} incluso con λ muy baja. El objetivo puede ser infactible para este modelo / μ.",
     "solver.error.solve_mu.sigue_superando_objetivo_puede_ser": "{target_metric} sigue superando {target_value} con μ = {mu_max:.4g}. El objetivo puede ser numéricamente infactible.",
     "solver.error.solve_servers.pudo_cumplir_hasta_servidores_considere": "No se pudo cumplir {target_metric} ≤ {target_value} con hasta {c_max} servidores. Considere aumentar μ o relajar el objetivo.",
+    "solver.error.optimize_servers.sin_servidores_estables_hasta_c_max": "Con λ={lam} y μ={mu} hacen falta al menos {c_min} servidores para que el sistema sea estable, pero c_max={c_max}. Aumente c_max.",
+    "solver.error.sensitivity.values_no_puede_estar_vacio": "values no puede estar vacío.",
+    "solver.error.sensitivity.param_no_es_parametro_modelo": "{param!r} no es un parámetro de {modelo}.",
+    "solver.error.compare.sin_resultados": "compare necesita al menos un resultado.",
     "solver.etiqueta.compare.escenario": "escenario_{expr}",
     "solver.etiqueta.summary.convergio": "NO convergió",
     "solver.etiqueta.summary.convergio_2": "convergió",

{walopy-0.4.2 → walopy-0.4.3}/src/walopy/solver.py

@@ -1,6 +1,7 @@
 """Solvers: encuentran parámetros óptimos o metas definidas por la persona usuaria en modelos de colas y operaciones."""
 from __future__ import annotations
 
+import inspect
 from collections.abc import Sequence
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any, Callable
@@ -9,7 +10,7 @@ import numpy as np
 import pandas as pd
 
 from ._i18n import t as _t
-from ._utils import as_positive
+from ._utils import MAX_SERVIDORES, as_int_positive, as_positive
 
 if TYPE_CHECKING:
     import plotly.graph_objects as go
@@ -316,6 +317,14 @@ def solve_mu(
 # solve_servers — minimum c to meet a target
 # ---------------------------------------------------------------------------
 
+def _min_servidores_estables(lam: float, mu: float) -> int:
+    """Menor número de servidores *c* con ρ = λ/(c·μ) < 1 (la misma condición que exige ``mmc``)."""
+    c = max(1, int(lam / mu))
+    while lam / (c * mu) >= 1.0:
+        c += 1
+    return c
+
+
 def solve_servers(
     target_metric: str,
     target_value: float,
@@ -355,15 +364,16 @@ def solve_servers(
     --------
     >>> r = solve_servers(target_metric='Wq', target_value=0.5, lam=4.0, mu=3.0)
     >>> round(r.value, 4)
-    3.0
+    2.0
     """
     from .queuing import mmc
 
     lam = as_positive(lam, "lam")
     mu  = as_positive(mu, "mu")
     target_value = as_positive(target_value, "target_value")
+    c_max = as_int_positive(c_max, "c_max", max=MAX_SERVIDORES)
 
-    c_min_stable = int(np.ceil(lam / mu)) + 1  # min c for stability
+    c_min_stable = _min_servidores_estables(lam, mu)
 
     for c in range(c_min_stable, c_max + 1):
         result = mmc(lam, mu, c)
@@ -428,7 +438,7 @@ def optimize_servers(
     --------
     >>> r = optimize_servers(lam=4.0, mu=3.0, cost_per_server=10.0, cost_per_wait=5.0)
     >>> round(r.min_cost, 4)
-    30.7232
+    25.3333
     """
     from .queuing import mmc
 
@@ -436,8 +446,11 @@ def optimize_servers(
     mu              = as_positive(mu, "mu")
     cost_per_server = as_positive(cost_per_server, "cost_per_server")
     cost_per_wait   = as_positive(cost_per_wait, "cost_per_wait")
+    c_max           = as_int_positive(c_max, "c_max", max=MAX_SERVIDORES)
 
-    c_min = int(np.ceil(lam / mu)) + 1
+    c_min = _min_servidores_estables(lam, mu)
+    if c_min > c_max:
+        raise ValueError(_t("solver.error.optimize_servers.sin_servidores_estables_hasta_c_max", lam=lam, mu=mu, c_min=c_min, c_max=c_max))
     rows: list[dict[str, Any]] = []
 
     for c in range(c_min, c_max + 1):
@@ -518,6 +531,15 @@ def sensitivity(
     >>> import numpy as np
     >>> df = sensitivity(mm1, "lam", np.linspace(0.5, 4.5, 20), mu=5.0)
     """
+    if len(values) == 0:
+        raise ValueError(_t("solver.error.sensitivity.values_no_puede_estar_vacio"))
+    try:
+        parametros = inspect.signature(model_fn).parameters
+    except (TypeError, ValueError):   # callables sin firma inspeccionable: se intenta igualmente
+        parametros = None
+    if parametros is not None and param not in parametros and not any(p.kind is p.VAR_KEYWORD for p in parametros.values()):
+        nombre_modelo = repr(model_fn) if not hasattr(model_fn, "__name__") else model_fn.__name__
+        raise ValueError(_t("solver.error.sensitivity.param_no_es_parametro_modelo", param=param, modelo=nombre_modelo))
     rows: list[dict[str, Any]] = []
     for v in values:
         try:
@@ -601,6 +623,8 @@ def batch_model(
 
     # Pre-compute integer columns so iterrows() float-upcast can be reversed
     int_cols = {col for col in df.columns if pd.api.types.is_integer_dtype(df[col].dtype)}
+    # Una columna entera con NaN (DataFrame disperso) pasa a float64: sus valores enteros vuelven a ser int al llamar al modelo
+    sparse_int_cols = {col for col in df.columns if pd.api.types.is_float_dtype(df[col].dtype) and df[col].isna().any()}
 
     for _, row_series in df.iterrows():
         # Merge: fixed_kwargs as base, row values (non-NaN) take precedence
@@ -609,7 +633,10 @@ def batch_model(
             if isinstance(v, float) and np.isnan(v):
                 continue
             # iterrows() upcasts int64 columns to float64; reverse that cast
-            kwargs[k] = int(v) if k in int_cols else v
+            if k in int_cols or (k in sparse_int_cols and isinstance(v, (float, np.floating)) and float(v).is_integer()):
+                kwargs[k] = int(v)
+            else:
+                kwargs[k] = v
 
         try:
             result = model_fn(**kwargs)
@@ -655,7 +682,8 @@ def compare(
     ----------
     *results
         Cualquier objeto de resultado de walopy (``QueueResult``, ``SimulationResult``,
-        ``EOQResult``, etc.) o diccionarios simples.
+        ``EOQResult``, etc.) o diccionarios simples. Si la tabla ``to_frame()`` de un resultado tiene varias filas
+        (pedidos, actividades…), se comparan sus campos escalares (costo total, duración del proyecto…).
     labels : sequence of str, optional
         Etiquetas de las filas. Por defecto ``'escenario_1'``, ``'escenario_2'``, …
 
@@ -680,11 +708,14 @@ def compare(
     >>> tabla["c (servidores)"].tolist()
     [1, 2]
     """
+    if len(results) == 0:
+        raise ValueError(_t("solver.error.compare.sin_resultados"))
     rows: list[dict[str, Any]] = []
     for i, r in enumerate(results):
         label = labels[i] if (labels and i < len(labels)) else _t("solver.etiqueta.compare.escenario", expr=i + 1)
-        if hasattr(r, "to_frame"):
-            row = r.to_frame().iloc[0].to_dict()
+        tabla = r.to_frame() if hasattr(r, "to_frame") else None
+        if tabla is not None and len(tabla) == 1:
+            row = tabla.iloc[0].to_dict()
         elif isinstance(r, dict):
             row = dict(r)
         elif hasattr(r, "__dict__"):

{walopy-0.4.2 → walopy-0.4.3/src/walopy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: walopy
-Version: 0.4.2
+Version: 0.4.3
 Summary: Herramientas de investigación de operaciones: colas, inventarios, scheduling, CPM/PERT, confiabilidad, OEE, cuellos de botella y árboles de KPI
 Author-email: LeoSanta15 <angelsanta1@gmail.com>
 License-Expression: MIT

{walopy-0.4.2 → walopy-0.4.3}/src/walopy.egg-info/SOURCES.txt

@@ -33,6 +33,7 @@ tests/test_cli.py
 tests/test_complejidad.py
 tests/test_contrato_entradas.py
 tests/test_cpm_pert.py
+tests/test_dibujo_plotly.py
 tests/test_documentacion.py
 tests/test_documentacion_ingles.py
 tests/test_ejemplos.py
@@ -56,7 +57,9 @@ tests/test_notas_release.py
 tests/test_operations.py
 tests/test_plotting.py
 tests/test_politicas_inventario.py
+tests/test_propiedades_algoritmos.py
 tests/test_propiedades_diferenciales.py
+tests/test_propiedades_inventario_fiabilidad.py
 tests/test_queuing.py
 tests/test_readme.py
 tests/test_referencias_externas.py
@@ -67,7 +70,10 @@ tests/test_salida_identica.py
 tests/test_salida_por_idioma.py
 tests/test_scheduling.py
 tests/test_scorecard.py
+tests/test_servidores_cmax.py
+tests/test_servidores_minimos.py
 tests/test_solver.py
+tests/test_solver_contratos.py
 tests/test_trazabilidad.py
 tests/test_version.py
 tests/test_wagner_whitin_ceros.py

walopy-0.4.3/tests/test_dibujo_plotly.py

@@ -0,0 +1,153 @@
+"""Las figuras de Plotly se dibujan, no solo existen como objeto (W-26).
+
+El árbol de KPI de 0.4.0 tenía una ``Figure`` correcta para los tests y salía **en blanco** en el navegador. Aquí hay dos capas:
+
+* **Siempre** (sin navegador): cada traza de cada figura tiene datos finitos que dibujar.
+* **Con Chromium** (``WALOPY_DIBUJO=1``; ``make dibujo`` y el job «Dibujo» del CI): se renderiza la figura en un navegador sin interfaz y se compara
+  la **zona del gráfico** con la misma figura con las trazas invisibles (``opacity=0``). Medir solo esa zona y contra una base con los mismos ejes y
+  cuadrículas es lo que separa «dibujada» de «en blanco»: una captura completa tiene título y ejes aunque no haya datos (el árbol roto ocupa 1,1 %
+  de píxeles distintos de blanco en pantalla completa, y 0,00 % de píxeles distintos de la base en la zona del gráfico; los correctos, entre 1,3 % y 66 %).
+
+Si ``WALOPY_DIBUJO=1`` y no hay navegador, los tests **fallan** (no se saltan), para que el CI no pase en silencio. Ruta explícita: ``WALOPY_CHROME``.
+"""
+from __future__ import annotations
+
+import copy
+import glob
+import math
+import os
+import shutil
+import subprocess  # noqa: S404
+from pathlib import Path
+
+import pytest
+
+import walopy as wl
+from walopy import plotting
+
+go = pytest.importorskip("plotly.graph_objects")
+np = pytest.importorskip("numpy")
+
+ANCHO, ALTO = 800, 500
+MARGEN = {"l": 60, "r": 30, "t": 60, "b": 60}
+UMBRAL = 0.002  # fracción mínima de píxeles de la zona del gráfico que cambian al quitar los datos
+EXIGIDO = os.environ.get("WALOPY_DIBUJO") == "1"
+
+pytestmark = pytest.mark.filterwarnings("ignore::UserWarning")
+
+
+def _ebitda() -> wl.KPINode:
+    a = wl.KPINode("Producto A", value=120_000, unit="€")
+    b = wl.KPINode("Producto B", value=80_000, unit="€")
+    ingresos = wl.KPINode("Ingresos", value=200_000, unit="€", children=[a, b])
+    costos = wl.KPINode("Costos de operación", value=100_000, unit="€")
+    return wl.KPINode("EBITDA", value=100_000, unit="€", children=[ingresos, costos])
+
+
+def _contrato(nombre: str):
+    from tests.test_contrato_entradas import BASE
+
+    return getattr(wl, nombre)(**copy.deepcopy(BASE[nombre]))
+
+
+FIGURAS = {
+    "kpi_ebitda_treemap": lambda: _ebitda().plot(),
+    "kpi_ebitda_sunburst": lambda: _ebitda().plot(kind="sunburst"),
+    "kpi_oee_treemap": lambda: wl.oee_kpi_tree(0.9, 0.8, 0.95).plot(),
+    "kpi_roi_sunburst": lambda: wl.roi_kpi_tree(50_000.0, 10_000.0, 8.0, 2_000.0, 20_000.0).plot(kind="sunburst"),
+    "optimize_servers": lambda: _contrato("optimize_servers").plot(),
+    "monte_carlo_gg1": lambda: _contrato("monte_carlo_gg1").plot(),
+    "line_balance": lambda: _contrato("line_balance").plot(),
+    "break_even": lambda: _contrato("break_even").plot(),
+    "break_even_sales": lambda: _contrato("break_even_sales").plot(),
+    "sensitivity": lambda: plotting.plot_sensitivity(wl.sensitivity(wl.mm1, "lam", [1.0, 1.5, 2.0, 2.5], mu=3.0), "lam"),
+    "queue_distribution": lambda: plotting.plot_queue_distribution(
+        wl.queue_length_pmf(2.0, 3.0, n_max=10), wl.sojourn_cdf(2.0, 3.0, n_points=20)
+    ),
+}
+
+
+def _arreglos(traza) -> list:
+    """Matrices que la traza dibuja: ``x``/``y`` (barras, líneas) o ``values`` (árboles)."""
+    return [getattr(traza, k) for k in ("x", "y", "values") if getattr(traza, k, None) is not None]
+
+
+@pytest.mark.parametrize("nombre", sorted(FIGURAS))
+def test_cada_traza_tiene_datos_finitos_que_dibujar(nombre):
+    fig = FIGURAS[nombre]()
+    assert len(fig.data) > 0, nombre
+    for i, traza in enumerate(fig.data):
+        valores = [float(v) for a in _arreglos(traza) for v in a if isinstance(v, (int, float, np.integer, np.floating))]
+        assert any(math.isfinite(v) for v in valores), f"{nombre}: la traza {i} ({traza.type}) no tiene valores finitos"
+
+
+# ---------------------------------------------------------------------------------------------- navegador
+def _chrome() -> str | None:
+    if os.environ.get("WALOPY_CHROME"):
+        return os.environ["WALOPY_CHROME"]
+    for cmd in ("google-chrome", "google-chrome-stable", "chromium", "chromium-browser", "chrome"):
+        ruta = shutil.which(cmd)
+        if ruta:
+            return ruta
+    candidatos = sorted(glob.glob("/opt/pw-browsers/chromium-*/chrome-linux/chrome"))
+    return candidatos[-1] if candidatos else None
+
+
+@pytest.fixture(scope="module")
+def navegador() -> str:
+    if not EXIGIDO:
+        pytest.skip("renderizado en navegador: ejecuta con WALOPY_DIBUJO=1 (make dibujo)")
+    ruta = _chrome()
+    assert ruta, "WALOPY_DIBUJO=1 pero no hay Chromium/Chrome (define WALOPY_CHROME)"
+    return ruta
+
+
+def _preparar(fig):
+    f = go.Figure(fig)
+    f.update_layout(
+        width=ANCHO, height=ALTO, margin=MARGEN, showlegend=False, title=None, paper_bgcolor="white", plot_bgcolor="white"
+    )
+    return f
+
+
+def _invisible(fig):
+    f = go.Figure(fig)
+    for traza in f.data:
+        traza.opacity = 0
+    return f
+
+
+def _renderizar(chrome: str, fig, carpeta: Path) -> np.ndarray:
+    import matplotlib.image as mpimg
+
+    html, png = carpeta / "figura.html", carpeta / "figura.png"
+    png.unlink(missing_ok=True)
+    fig.write_html(str(html), include_plotlyjs=True, full_html=True, config={"displayModeBar": False, "staticPlot": True})
+    orden = [
+        chrome, "--headless", "--no-sandbox", "--disable-gpu", "--disable-dev-shm-usage", f"--window-size={ANCHO},{ALTO}",
+        "--virtual-time-budget=4000", f"--screenshot={png}", html.as_uri(),
+    ]
+    subprocess.run(orden, capture_output=True, timeout=120, check=True)  # noqa: S603
+    return np.asarray(mpimg.imread(str(png)))[..., :3]
+
+
+def _fraccion_dibujada(chrome: str, fig, carpeta: Path) -> float:
+    con = _renderizar(chrome, _preparar(fig), carpeta)
+    sin = _renderizar(chrome, _preparar(_invisible(fig)), carpeta)
+    zona = (slice(MARGEN["t"], ALTO - MARGEN["b"]), slice(MARGEN["l"], ANCHO - MARGEN["r"]))
+    return float((np.abs(con[zona] - sin[zona]).max(axis=2) > 0.1).mean())
+
+
+@pytest.mark.parametrize("nombre", sorted(FIGURAS))
+def test_la_figura_se_dibuja_en_el_navegador(nombre, navegador, tmp_path):
+    fraccion = _fraccion_dibujada(navegador, FIGURAS[nombre](), tmp_path)
+    assert fraccion > UMBRAL, f"{nombre}: la zona del gráfico solo cambia un {fraccion:.4%} respecto de la figura sin datos (¿en blanco?)"
+
+
+def test_el_detector_ve_en_blanco_el_arbol_de_kpi_de_0_4_0(navegador, tmp_path):
+    """Control: con un padre menor que la suma de sus hijos (el defecto W-26) Plotly no dibuja y la medida tiene que quedar bajo el umbral."""
+    fig = go.Figure(_ebitda().plot())
+    valores = list(fig.data[0].values)
+    valores[0] = 1e-9  # raíz menor que la suma de sus hijos
+    fig.data[0].values = valores
+    assert _fraccion_dibujada(navegador, fig, tmp_path) <= UMBRAL

{walopy-0.4.2 → walopy-0.4.3}/tests/test_inventario_i18n.py

@@ -131,6 +131,10 @@ def test_el_catalogo_es_contiene_todas_las_claves_de_la_base_con_su_texto():
 # Textos añadidos después de v0.3.0 (no están en la línea base congelada): una clave nueva debe declararse aquí a propósito.
 AÑADIDAS_TRAS_V030 = {
     "i18n.error.validar.idioma_no_admitido",
+    "solver.error.optimize_servers.sin_servidores_estables_hasta_c_max",   # W-29
+    "solver.error.sensitivity.values_no_puede_estar_vacio",   # W-32
+    "solver.error.sensitivity.param_no_es_parametro_modelo",
+    "solver.error.compare.sin_resultados",   # W-31
     "project.cabecera.to_frame.ht",    # «HT»/«HL» (holgura total/libre): acrónimos españoles que el extractor no veía; ya existían en v0.3.0
     "project.cabecera.to_frame.hl",
 }

walopy-0.4.3/tests/test_propiedades_algoritmos.py

@@ -0,0 +1,194 @@
+"""Algoritmos de secuenciación, redes, colas finitas, lotes y MRP contra oráculos independientes (escenarios aleatorios con semilla fija).
+
+Cada oráculo está escrito aparte del código de ``walopy`` (fuerza bruta, camino más largo, ecuaciones de balance, fórmula cerrada), y se comprueba que
+discrimina: NEH, que es una heurística, se compara con el óptimo solo como cota. Carga moderada (``N`` escenarios por familia).
+"""
+from __future__ import annotations
+
+import itertools
+import math
+import random
+import warnings
+
+import walopy as wl
+
+N = 120
+SEMILLA = 20261008
+
+
+def _cerca(a: float, b: float, rel: float = 1e-7) -> bool:
+    return math.isclose(a, b, rel_tol=rel, abs_tol=1e-9)
+
+
+def _escenarios(familia: str):
+    r = random.Random(f"{SEMILLA}-{familia}")
+    return [random.Random(r.random()) for _ in range(N)]
+
+
+def _makespan(tiempos, perm):
+    c = [0.0] * len(tiempos[0])
+    for j in perm:
+        c[0] += tiempos[j][0]
+        for k in range(1, len(c)):
+            c[k] = max(c[k], c[k - 1]) + tiempos[j][k]
+    return c[-1]
+
+
+def _indices(secuencia):
+    return [int(s[1:]) - 1 for s in secuencia]
+
+
+def test_neh_devuelve_una_permutacion_coherente_y_no_mejor_que_el_optimo():
+    for r in _escenarios("neh"):
+        n, m = r.randint(2, 6), r.randint(2, 4)
+        T = [[r.randint(1, 20) for _ in range(m)] for _ in range(n)]
+        res = wl.neh_flowshop(T)
+        sec = _indices(res.sequence)
+        optimo = min(_makespan(T, p) for p in itertools.permutations(range(n)))
+        assert sorted(sec) == list(range(n)), T
+        assert _cerca(res.makespan, _makespan(T, sec)), T
+        assert res.makespan >= optimo - 1e-9, T
+
+
+def test_johnson_es_optimo_con_dos_maquinas():
+    for r in _escenarios("johnson"):
+        n = r.randint(2, 6)
+        a, b = [r.randint(1, 20) for _ in range(n)], [r.randint(1, 20) for _ in range(n)]
+        T = [[x, y] for x, y in zip(a, b)]
+        res = wl.johnson_flowshop(a, b)
+        optimo = min(_makespan(T, p) for p in itertools.permutations(range(n)))
+        assert _cerca(res.makespan, optimo), (a, b)
+        assert _cerca(_makespan(T, _indices(res.sequence)), optimo), (a, b)
+
+
+def _terminaciones(p, perm):
+    t, out = 0, {}
+    for j in perm:
+        t += p[j]
+        out[j] = t
+    return out
+
+
+def _camino_mas_largo(acts, i, memo):
+    if i not in memo:
+        previos = [_camino_mas_largo(acts, int(q[1:]), memo) for q in acts[i]["predecessors"]]
+        memo[i] = acts[i]["duration"] + max(previos or [0])
+    return memo[i]
+
+
+def test_reglas_de_secuenciacion_en_una_maquina_son_optimas_en_su_criterio():
+    for r in _escenarios("una_maquina"):
+        n = r.randint(2, 6)
+        p = [r.randint(1, 15) for _ in range(n)]
+        d = [r.randint(1, 40) for _ in range(n)]
+        w = [r.randint(1, 5) for _ in range(n)]
+        perms = list(itertools.permutations(range(n)))
+
+        total = min(sum(_terminaciones(p, q).values()) for q in perms)
+        ponderado = min(sum(w[j] * c for j, c in _terminaciones(p, q).items()) for q in perms)
+        retraso = min(max(c - d[j] for j, c in _terminaciones(p, q).items()) for q in perms)
+        assert _cerca(wl.schedule_single(p, rule="SPT").total_completion_time, total), p
+        assert _cerca(wl.schedule_single(p, rule="WSPT", weights=w).total_weighted_completion_time, ponderado), (p, w)
+        assert _cerca(wl.schedule_single(p, rule="EDD", due_dates=d).max_lateness, retraso), (p, d)
+
+
+def test_cpm_la_duracion_es_el_camino_mas_largo():
+    for r in _escenarios("cpm"):
+        na = r.randint(1, 9)
+        acts = [
+            {"name": f"A{i}", "duration": r.randint(1, 12), "predecessors": [f"A{j}" for j in range(i) if r.random() < 0.35]}
+            for i in range(na)
+        ]
+        memo: dict[int, int] = {}
+        assert _cerca(wl.cpm(acts).project_duration, max(_camino_mas_largo(acts, i, memo) for i in range(na))), acts
+
+
+def test_colas_finitas_coinciden_con_las_ecuaciones_de_balance():
+    for r in _escenarios("mmck"):
+        c = r.randint(1, 5)
+        K = c + r.randint(0, 10)
+        mu = r.uniform(0.5, 10)
+        lam = r.uniform(0.1, 2.0) * c * mu
+        pesos = [1.0]
+        for k in range(1, K + 1):
+            pesos.append(pesos[-1] * lam / (min(k, c) * mu))
+        pi = [x / sum(pesos) for x in pesos]
+        L = sum(k * pi[k] for k in range(K + 1))
+        Lq = sum((k - c) * pi[k] for k in range(c + 1, K + 1))
+        q = wl.mmck(lam, mu, c, K)
+        assert _cerca(q.L, L, 1e-6) and _cerca(q.Lq, Lq, 1e-6), (lam, mu, c, K)
+        assert _cerca(q.W, L / (lam * (1 - pi[K])), 1e-6), (lam, mu, c, K)
+        q1, qc = wl.mm1k(lam, mu, K), wl.mmck(lam, mu, 1, K)
+        assert _cerca(q1.L, qc.L) and _cerca(q1.W, qc.W), (lam, mu, K)
+
+
+def test_prioridades_conservan_el_numero_total_en_el_sistema():
+    for r in _escenarios("prioridad"):
+        lams = [r.uniform(0.05, 0.8) for _ in range(r.randint(2, 4))]
+        mu = sum(lams) / r.uniform(0.1, 0.95)
+        pr = wl.mm1_priority(lams, mu)
+        assert _cerca(sum(c["L"] for c in pr.classes), wl.mm1(sum(lams), mu).L, 1e-6), (lams, mu)
+
+
+def _phi(z: float) -> float:
+    return math.exp(-z * z / 2) / math.sqrt(2 * math.pi)
+
+
+def _gran_phi(z: float) -> float:
+    return 0.5 * (1 + math.erf(z / math.sqrt(2)))
+
+
+def _ganancia(Q, media, sd, precio, costo, rescate):
+    """Ganancia esperada con demanda normal: precio·E[ventas] + rescate·E[sobrante] − costo·Q."""
+    z = (Q - media) / sd
+    ventas = media - sd * (_phi(z) - z * (1 - _gran_phi(z)))
+    return precio * ventas + rescate * (Q - ventas) - costo * Q
+
+
+def test_newsvendor_el_optimo_maximiza_la_ganancia_esperada():
+    for r in _escenarios("newsvendor"):
+        media = r.uniform(20, 500)
+        sd = media * r.uniform(0.05, 0.3)
+        precio = r.uniform(5, 30)
+        costo = precio * r.uniform(0.1, 0.8)
+        rescate = costo * r.uniform(0, 0.6)
+
+        datos = (media, sd, precio, costo, rescate)
+        res = wl.newsvendor(media, sd, precio, costo, salvage=rescate)
+        rejilla = [media * (0.2 + i * 0.01) for i in range(300)]
+        assert _ganancia(res.optimal_qty, *datos) >= max(_ganancia(g, *datos) for g in rejilla) - 1e-6, datos
+        assert _cerca(res.expected_profit, _ganancia(res.optimal_qty, *datos), 1e-6), datos
+
+
+def test_politicas_de_lotes_son_coherentes_con_sus_pedidos():
+    for r in _escenarios("lotes"):
+        dem = [r.choice([0, 0, r.uniform(1, 200)]) for _ in range(r.randint(1, 12))]
+        S, h = r.uniform(1, 500), r.uniform(0.05, 5)
+        for fn in (wl.silver_meal, wl.lot_for_lot):
+            res = fn(dem, S, h)
+            costo = len(res.orders) * S + h * sum(
+                dem[t - 1] * (t - o["period"]) for o in res.orders for t in o["covers_periods"]
+            )
+            assert all(o["order_qty"] > 0 for o in res.orders), (fn.__name__, dem)
+            assert _cerca(sum(o["order_qty"] for o in res.orders), sum(dem), 1e-9), (fn.__name__, dem)
+            assert _cerca(res.total_cost, costo, 1e-9), (fn.__name__, dem, S, h)
+            assert res.n_orders == len(res.orders), (fn.__name__, dem)
+
+
+def test_mrp_cumple_el_balance_de_inventario():
+    for r in _escenarios("mrp"):
+        T = r.randint(2, 10)
+        bruto = [r.choice([0, r.randint(1, 50)]) for _ in range(T)]
+        inicial, lt, ss = r.randint(0, 60), r.randint(0, 3), r.randint(0, 10)
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", UserWarning)  # liberaciones vencidas (W-16): aviso esperado con lead_time largo
+            res = wl.mrp(bruto, initial_on_hand=inicial, lead_time=lt, safety_stock=ss)
+        previo = inicial
+        for t in range(T):
+            esperado = previo + res.scheduled_receipts[t] + res.planned_receipts[t] - bruto[t]
+            assert _cerca(res.projected_on_hand[t], esperado, 1e-9), (bruto, inicial, lt, ss, t)
+            assert res.projected_on_hand[t] >= ss - 1e-9, (bruto, inicial, lt, ss, t)
+            sin_recepcion = previo + res.scheduled_receipts[t] - bruto[t]
+            if res.planned_receipts[t] > 1e-9:
+                assert sin_recepcion < ss - 1e-9, (bruto, inicial, lt, ss, t)  # solo se recibe lo necesario (LFL)
+            previo = res.projected_on_hand[t]