walopy 0.4.1__tar.gz → 0.4.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: walopy
-Version: 0.4.1
+Version: 0.4.2
 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.1 → walopy-0.4.2}/src/walopy/__init__.py

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

{walopy-0.4.1 → walopy-0.4.2}/src/walopy/inventory.py

@@ -1455,13 +1455,21 @@ def wagner_whitin(
     n = len(demands_v)
 
     INF = float("inf")
-    dp = [INF] * (n + 1)   # dp[j] = min cost to satisfy demands 0..j-1
+    dp = [INF] * (n + 1)   # dp[j] = costo mínimo de satisfacer las demandas 1..j
     dp[0] = 0.0
-    last = [-1] * (n + 1)  # last[j] = period i where order was placed
+    last = [-1] * (n + 1)  # last[j] = periodo del último pedido (0 = ninguno: demanda nula)
 
     # Recursión hacia adelante: el costo de mantener se acumula de forma incremental
     # (O(n²) en total; antes se recalculaba la suma completa para cada par (i, j): O(n³)).
+    # Solo se pide en periodos con demanda positiva: pedir antes de que haga falta nunca
+    # abarata el plan, y un periodo de demanda nula no justifica pagar la preparación.
     for i in range(1, n + 1):
+        if demands_v[i - 1] == 0:
+            # Sin demanda no hay pedido: se arrastra el costo del periodo anterior.
+            if dp[i - 1] < dp[i]:
+                dp[i] = dp[i - 1]
+                last[i] = 0
+            continue
         acum = 0.0  # Σ_{k=i..j} (k - i) · d_k
         for j in range(i, n + 1):
             acum += (j - i) * demands_v[j - 1]
@@ -1476,6 +1484,9 @@ def wagner_whitin(
     j = n
     while j > 0:
         i = last[j]
+        if i == 0:  # periodo sin demanda ni pedido
+            j -= 1
+            continue
         qty = sum(demands_v[k - 1] for k in range(i, j + 1))
         orders.append({
             "period": i,

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: walopy
-Version: 0.4.1
+Version: 0.4.2
 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.1 → walopy-0.4.2}/src/walopy.egg-info/SOURCES.txt

@@ -56,6 +56,7 @@ tests/test_notas_release.py
 tests/test_operations.py
 tests/test_plotting.py
 tests/test_politicas_inventario.py
+tests/test_propiedades_diferenciales.py
 tests/test_queuing.py
 tests/test_readme.py
 tests/test_referencias_externas.py
@@ -69,4 +70,5 @@ tests/test_scorecard.py
 tests/test_solver.py
 tests/test_trazabilidad.py
 tests/test_version.py
+tests/test_wagner_whitin_ceros.py
 tests/test_weibull.py

{walopy-0.4.1 → walopy-0.4.2}/tests/test_complejidad.py

@@ -77,10 +77,18 @@ def test_neh_n200_m10_es_rapido():
 
 
 def _ww_fuerza_bruta(d, S, h):
+    """Óptimo por enumeración, independiente de la programación dinámica.
+
+    Un pedido solo se coloca en un periodo con demanda positiva (no hay nada que cubrir en uno nulo) y el primero
+    de ellos debe tener pedido. Un horizonte sin demanda cuesta 0.
+    """
+    positivos = [t for t, x in enumerate(d) if x > 0]
+    if not positivos:
+        return 0.0
     n = len(d)
     mejor = math.inf
-    for mascara in range(1 << (n - 1)):
-        inicios = [0] + [i + 1 for i in range(n - 1) if mascara >> i & 1]
+    for mascara in range(1 << (len(positivos) - 1)):
+        inicios = [positivos[0]] + [positivos[i + 1] for i in range(len(positivos) - 1) if mascara >> i & 1]
         costo = 0.0
         for si, a in enumerate(inicios):
             fin = inicios[si + 1] if si + 1 < len(inicios) else n
@@ -93,8 +101,7 @@ def _ww_fuerza_bruta(d, S, h):
 def test_wagner_whitin_coincide_con_fuerza_bruta(semilla):
     r = random.Random(semilla)
     n = r.randint(2, 9)
-    d = [r.randint(0, 40) for _ in range(n)]
-    d[0] = d[0] or 1
+    d = [r.choice([0, 0, r.randint(1, 40)]) for _ in range(n)]  # ceros en cualquier posición (W-27)
     S, h = r.randint(10, 100), r.choice([0.5, 1, 2])
     assert wl.wagner_whitin(d, S, h).total_cost == pytest.approx(_ww_fuerza_bruta(d, S, h), abs=1e-9)
 

walopy-0.4.2/tests/test_propiedades_diferenciales.py

@@ -0,0 +1,118 @@
+"""Relaciones que deben cumplir funciones distintas del mismo modelo, sobre escenarios aleatorios con semilla fija.
+
+Complementan a los tests de valores concretos: detectan errores que un caso a mano no cubre (como W-27). Carga moderada
+(``N`` escenarios por familia); la semilla fija hace que un fallo sea reproducible.
+"""
+from __future__ import annotations
+
+import math
+import random
+
+import walopy as wl
+
+N = 300
+SEMILLA = 20261007
+
+
+def _cerca(a: float, b: float, rel: float = 1e-7) -> bool:
+    return math.isclose(a, b, rel_tol=rel, abs_tol=1e-12)
+
+
+def _costo_eoq(D: float, K: float, h: float, q: float) -> float:
+    return D / q * K + h * q / 2
+
+
+def _escenarios(familia: str):
+    r = random.Random(f"{SEMILLA}-{familia}")
+    return [random.Random(r.random()) for _ in range(N)]
+
+
+def _cola(r):
+    mu = r.uniform(0.2, 50)
+    lam = r.uniform(0.01, 0.97) * mu
+    return lam, mu, wl.mm1(lam, mu)
+
+
+def test_mg1_con_cs2_igual_a_1_es_mm1():
+    for r in _escenarios("mg1"):
+        lam, mu, m = _cola(r)
+        g = wl.mg1(lam, mu, 1.0)
+        assert _cerca(g.L, m.L) and _cerca(g.Wq, m.Wq), (lam, mu)
+
+
+def test_kingman_con_cv_1_coincide_con_mm1():
+    for r in _escenarios("kingman"):
+        lam, mu, m = _cola(r)
+        assert _cerca(wl.kingman(lam, mu, 1.0, 1.0).Wq, m.Wq), (lam, mu)
+
+
+def test_md1_tiene_la_mitad_de_cola_que_mm1():
+    for r in _escenarios("md1"):
+        lam, mu, m = _cola(r)
+        assert _cerca(wl.md1(lam, mu).Lq, m.Lq / 2), (lam, mu)
+
+
+def test_mmc_con_un_servidor_es_mm1():
+    for r in _escenarios("mmc1"):
+        lam, mu, m = _cola(r)
+        c1 = wl.mmc(lam, mu, 1)
+        assert _cerca(c1.Wq, m.Wq) and _cerca(c1.L, m.L), (lam, mu)
+
+
+def test_erlang_b_decrece_al_añadir_servidores():
+    for r in _escenarios("erlang"):
+        c, a = r.randint(1, 40), r.uniform(0.1, 60)
+        b0, b1 = wl.erlang_b(a, 1.0, c), wl.erlang_b(a, 1.0, c + 1)
+        assert 0 <= b1 <= b0 + 1e-15 and b0 <= 1, (a, c, b0, b1)
+
+
+def test_mmc_la_espera_decrece_al_añadir_un_servidor():
+    for r in _escenarios("mmc_c"):
+        c, mu = r.randint(1, 15), r.uniform(1, 20)
+        lam = r.uniform(0.05, 0.95) * c * mu
+        w1, w2 = wl.mmc(lam, mu, c).Wq, wl.mmc(lam, mu, c + 1).Wq
+        assert w2 <= w1 + 1e-12, (lam, mu, c, w1, w2)
+
+
+def test_lotes_wagner_whitin_no_supera_a_las_heuristicas():
+    for r in _escenarios("lotes"):
+        d = [r.choice([0, 0, r.uniform(1, 200)]) for _ in range(r.randint(2, 12))]
+        if sum(d) == 0:
+            continue
+        S, h = r.uniform(1, 500), r.uniform(0.05, 5)
+        ww = wl.wagner_whitin(d, S, h).total_cost
+        assert ww <= wl.silver_meal(d, S, h).total_cost + 1e-6, (d, S, h)
+        assert ww <= wl.lot_for_lot(d, S, h).total_cost + 1e-6, (d, S, h)
+
+
+def test_fiabilidad_serie_y_paralelo_acotan_a_los_componentes():
+    for r in _escenarios("fiabilidad"):
+        n = r.randint(2, 6)
+        lams = [r.uniform(1e-3, 0.2) for _ in range(n)]
+        t = r.uniform(0.5, 100)
+        Ri = [math.exp(-x * t) for x in lams]
+        assert wl.series_system(lams, t=t).R_t <= min(Ri) + 1e-12, (lams, t)
+        assert wl.parallel_system(lams, t=t).R_t >= max(Ri) - 1e-12, (lams, t)
+
+
+def test_k_de_n_esta_entre_serie_y_paralelo():
+    for r in _escenarios("koon"):
+        n = r.randint(2, 6)
+        k, lam, t = r.randint(1, n), r.uniform(1e-3, 0.2), r.uniform(0.5, 100)
+        rk = wl.koon_system(n=n, k=k, failure_rate=lam, t=t).R_t
+        assert math.exp(-lam * t) ** n - 1e-12 <= rk <= 1 - (1 - math.exp(-lam * t)) ** n + 1e-12, (n, k, lam, t)
+
+
+def test_eoq_es_el_minimo_del_costo_y_coincide_con_la_formula():
+    for r in _escenarios("eoq"):
+        D, K, h = r.uniform(1, 5000), r.uniform(1, 500), r.uniform(0.01, 10)
+        e = wl.eoq(D, K, h)
+
+        assert _cerca(e.total_cost, _costo_eoq(D, K, h, e.eoq), 1e-9), (D, K, h)
+        assert all(e.total_cost <= _costo_eoq(D, K, h, e.eoq * f) + 1e-9 for f in (0.5, 0.9, 1.1, 2)), (D, K, h)
+
+
+def test_eoq_decrece_con_el_costo_de_mantener():
+    for r in _escenarios("eoq_h"):
+        D, K, h = r.uniform(1, 5000), r.uniform(1, 500), r.uniform(0.01, 10)
+        assert wl.eoq(D, K, h * 1.5).eoq < wl.eoq(D, K, h).eoq, (D, K, h)

walopy-0.4.2/tests/test_wagner_whitin_ceros.py

@@ -0,0 +1,61 @@
+"""W-27: ``wagner_whitin`` cobraba preparación en periodos sin demanda y obligaba a pedir en el periodo 1."""
+from __future__ import annotations
+
+import math
+import random
+
+import pytest
+
+import walopy as wl
+from tests.test_complejidad import _ww_fuerza_bruta
+
+
+def _pedidos(r):
+    return [(o["period"], o["order_qty"]) for o in r.orders]
+
+
+def test_ceros_iniciales_no_obligan_a_pedir_en_el_periodo_1():
+    r = wl.wagner_whitin([0, 0, 100, 0, 0], setup_cost=100, holding_cost=1)
+    assert r.total_cost == pytest.approx(100.0)  # antes 200: pedido vacío en el periodo 1 + el real
+    assert _pedidos(r) == [(3, 100.0)]
+
+
+def test_ceros_intermedios_no_pagan_preparacion():
+    r = wl.wagner_whitin([0, 50, 0, 100], setup_cost=100, holding_cost=1)
+    assert r.total_cost == pytest.approx(200.0)  # antes 250
+    assert _pedidos(r) == [(2, 50.0), (4, 100.0)]
+
+
+def test_horizonte_sin_demanda_cuesta_cero_y_no_pide():
+    r = wl.wagner_whitin([0, 0, 0], setup_cost=100, holding_cost=1)
+    assert r.total_cost == 0.0
+    assert r.orders == [] and r.n_orders == 0
+    assert r.total_setup_cost == 0.0 and r.total_holding_cost == 0.0
+
+
+def test_ningun_pedido_es_de_cantidad_cero():
+    r = random.Random(27)
+    for _ in range(200):
+        d = [r.choice([0, 0, r.randint(1, 40)]) for _ in range(r.randint(1, 12))]
+        res = wl.wagner_whitin(d, r.randint(5, 80), r.choice([0.5, 1, 2]))
+        assert all(o["order_qty"] > 0 for o in res.orders)
+        assert sum(o["order_qty"] for o in res.orders) == pytest.approx(sum(d))
+
+
+@pytest.mark.parametrize("semilla", range(150))
+def test_costo_optimo_exacto_con_ceros_en_cualquier_posicion(semilla):
+    r = random.Random(7000 + semilla)
+    d = [r.choice([0, 0, r.randint(1, 60)]) for _ in range(r.randint(1, 10))]
+    S, h = r.uniform(1, 200), r.uniform(0.05, 3)
+    res = wl.wagner_whitin(d, S, h)
+    assert res.total_cost == pytest.approx(_ww_fuerza_bruta(d, S, h), rel=1e-9, abs=1e-9)
+    assert res.total_cost == pytest.approx(res.total_setup_cost + res.total_holding_cost)
+    assert res.total_setup_cost == pytest.approx(res.n_orders * S)
+
+
+def test_con_demanda_positiva_el_resultado_no_cambia():
+    # Caso de referencia del docstring: sin ceros el plan es el de siempre.
+    r = wl.wagner_whitin([100, 80, 120, 60], setup_cost=200, holding_cost=1)
+    assert r.total_cost == pytest.approx(_ww_fuerza_bruta([100, 80, 120, 60], 200, 1))
+    assert r.orders[0]["period"] == 1
+    assert math.isfinite(r.total_cost)