walopy 0.4.0__tar.gz → 0.4.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: walopy
-Version: 0.4.0
+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
@@ -1563,6 +1563,9 @@ tree.plot()
 
 ### `KPINode` — árbol personalizado
 
+El rótulo de cada rectángulo es el valor real del nodo; su **tamaño** es el mayor entre ese valor y la suma de sus hijos (un KPI como EBITDA = Ingresos − Costos no
+es la suma de sus hijos, y Plotly dibuja en blanco un padre menor que ellos).
+
 ```python
 rev = wl.KPINode("Revenue", value=200_000, unit="€", children=[
     wl.KPINode("Product A", value=120_000, unit="€"),

{walopy-0.4.0 → walopy-0.4.2}/README.md

@@ -1515,6 +1515,9 @@ tree.plot()
 
 ### `KPINode` — árbol personalizado
 
+El rótulo de cada rectángulo es el valor real del nodo; su **tamaño** es el mayor entre ese valor y la suma de sus hijos (un KPI como EBITDA = Ingresos − Costos no
+es la suma de sus hijos, y Plotly dibuja en blanco un padre menor que ellos).
+
 ```python
 rev = wl.KPINode("Revenue", value=200_000, unit="€", children=[
     wl.KPINode("Product A", value=120_000, unit="€"),

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

@@ -164,7 +164,7 @@ from .solver import (
     solve_servers,
 )
 
-__version__ = "0.4.0"  # 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.0 → 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.0 → walopy-0.4.2}/src/walopy/plotting.py

@@ -193,6 +193,9 @@ def plot_kpi_tree(
 ) -> go.Figure:
     """Árbol de KPI interactivo con Plotly.
 
+    El rectángulo de cada nodo rotula su valor real; su tamaño es el mayor entre ese valor y la suma de los tamaños de sus hijos (un KPI como
+    EBITDA = Ingresos − Costos no es la suma de sus hijos, y Plotly no dibuja un padre menor que ellos).
+
     Parameters
     ----------
     root : KPINode
@@ -214,20 +217,26 @@ def plot_kpi_tree(
     labels: list[str]     = []
     parents: list[str]    = []
     values: list[float]   = []
+    shown: list[str]      = []     # valor real de cada nodo (el que se rotula)
     hover: list[str]      = []
 
-    def _collect(node: KPINode, parent_id: str = "") -> None:
+    def _collect(node: KPINode, parent_id: str = "") -> float:
         node_id = f"{parent_id}/{node.name}" if parent_id else node.name
+        pos = len(ids)
         ids.append(node_id)
         labels.append(node.name)
         parents.append(parent_id)
-        # Use absolute value for area sizing; zero would collapse the tile
-        values.append(max(abs(node.value), 1e-9))
+        values.append(0.0)
+        shown.append(f"{node.value:,.8g}")
         unit_str    = f" {node.unit}" if node.unit else ""
         formula_str = _t("plotting.grafica.collect.br_2", formula=node.formula) if node.formula else ""
         hover.append(_t("plotting.grafica.collect.br", name=node.name, value=node.value, unit_str=unit_str, formula_str=formula_str))
-        for child in node.children:
-            _collect(child, node_id)
+        children_size = sum(_collect(child, node_id) for child in node.children)
+        # Tamaño del rectángulo: con branchvalues="total" Plotly exige que el padre valga al menos la suma de sus hijos, y si no lo
+        # cumple dibuja la figura en blanco. Un KPI no es la suma de sus hijos (EBITDA = Ingresos − Costos; OEE = A × P × Q), así que
+        # el tamaño del padre es max(su valor, la suma de los tamaños de sus hijos); el valor rotulado sigue siendo el del nodo.
+        values[pos] = max(abs(node.value), children_size, 1e-9)
+        return values[pos]
 
     _collect(root)
 
@@ -239,10 +248,11 @@ def plot_kpi_tree(
             labels=labels,
             parents=parents,
             values=values,
+            text=shown,
             customdata=hover,
             hovertemplate=_t("plotting.grafica.plot_kpi_tree.customdata_extra_extra"),
             branchvalues="total",
-            textinfo="label+value",
+            texttemplate="%{label}<br>%{text}",
             insidetextorientation="radial",
             marker=dict(colorscale="Blues"),
         )
@@ -256,10 +266,11 @@ def plot_kpi_tree(
             labels=labels,
             parents=parents,
             values=values,
+            text=shown,
             customdata=hover,
             hovertemplate=_t("plotting.grafica.plot_kpi_tree.customdata_extra_extra"),
             branchvalues="total",
-            texttemplate="<b>%{label}</b><br>%{value:.4g}",
+            texttemplate="<b>%{label}</b><br>%{text}",
             textfont=dict(size=13),
             marker=dict(
                 colorscale="Blues",

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: walopy
-Version: 0.4.0
+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
@@ -1563,6 +1563,9 @@ tree.plot()
 
 ### `KPINode` — árbol personalizado
 
+El rótulo de cada rectángulo es el valor real del nodo; su **tamaño** es el mayor entre ese valor y la suma de sus hijos (un KPI como EBITDA = Ingresos − Costos no
+es la suma de sus hijos, y Plotly dibuja en blanco un padre menor que ellos).
+
 ```python
 rev = wl.KPINode("Revenue", value=200_000, unit="€", children=[
     wl.KPINode("Product A", value=120_000, unit="€"),

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

@@ -45,6 +45,7 @@ tests/test_inventario_i18n.py
 tests/test_inventory.py
 tests/test_inventory_new.py
 tests/test_kpi.py
+tests/test_kpi_grafica.py
 tests/test_mg1.py
 tests/test_mmc_estable.py
 tests/test_mrp.py
@@ -55,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
@@ -68,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.0 → 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_kpi_grafica.py

@@ -0,0 +1,82 @@
+"""Los árboles de KPI se dibujan (W-26).
+
+Con ``branchvalues="total"`` Plotly exige que el valor de cada padre sea **al menos** la suma de los de sus hijos; si no, la figura sale en blanco en el
+navegador. Un KPI casi nunca es la suma de sus hijos (EBITDA = Ingresos − Costos; OEE = A × P × Q), así que ``plot_kpi_tree`` usa como tamaño del
+rectángulo ``max(valor, suma de los tamaños de los hijos)`` y rotula el valor real del nodo. Estos tests comprueban esa condición sobre la figura
+(el objeto ``Figure`` no se renderiza aquí).
+"""
+from __future__ import annotations
+
+import pytest
+
+import walopy as wl
+
+pytest.importorskip("plotly")
+
+
+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 _suma_exacta() -> wl.KPINode:
+    return wl.KPINode("Total", value=300.0, children=[wl.KPINode("A", value=100.0), wl.KPINode("B", value=200.0)])
+
+
+ARBOLES = {
+    "ebitda": _ebitda,
+    "oee": lambda: wl.oee_kpi_tree(0.9, 0.8, 0.95),
+    "throughput": lambda: wl.throughput_kpi_tree(750.0, 1000.0, 0.05),
+    "roi": lambda: wl.roi_kpi_tree(50_000.0, 10_000.0, 8.0, 2_000.0, 20_000.0),
+    "suma_exacta": _suma_exacta,
+    "una_hoja": lambda: wl.KPINode("Solo", value=5.0),
+    "con_cero": lambda: wl.KPINode("R", value=0.0, children=[wl.KPINode("H", value=0.0)]),
+    "negativo": lambda: wl.KPINode("R", value=-10.0, children=[wl.KPINode("H1", value=-30.0), wl.KPINode("H2", value=5.0)]),
+}
+
+
+def _violaciones(traza) -> list[str]:
+    """Padres cuyo valor es menor que la suma de sus hijos (lo que deja a Plotly con la figura en blanco)."""
+    valor = dict(zip(traza.ids, traza.values))
+    suma: dict[str, float] = {}
+    for id_, padre in zip(traza.ids, traza.parents):
+        if padre:
+            suma[padre] = suma.get(padre, 0.0) + valor[id_]
+    return [f"{p}: {valor[p]:g} < {s:g}" for p, s in suma.items() if valor[p] < s * (1 - 1e-12)]
+
+
+@pytest.mark.parametrize("kind", ["treemap", "sunburst"])
+@pytest.mark.parametrize("nombre", sorted(ARBOLES))
+def test_ningun_padre_vale_menos_que_la_suma_de_sus_hijos(nombre, kind):
+    fig = ARBOLES[nombre]().plot(kind=kind)
+    traza = fig.data[0]
+    assert traza.branchvalues == "total"
+    assert not _violaciones(traza), f"{nombre} ({kind}) se dibujaría en blanco: {_violaciones(traza)}"
+    assert all(v > 0 for v in traza.values)
+
+
+@pytest.mark.parametrize("kind", ["treemap", "sunburst"])
+def test_el_rotulo_es_el_valor_real_del_nodo_no_el_tamano(kind):
+    fig = _ebitda().plot(kind=kind)
+    traza = fig.data[0]
+    rotulos = dict(zip(traza.labels, traza.text))
+    assert rotulos["EBITDA"] == "100,000"                    # no 300 000, que es el tamaño del rectángulo
+    assert rotulos["Ingresos"] == "200,000" and rotulos["Producto A"] == "120,000"
+    assert "%{text}" in traza.texttemplate
+
+
+def test_un_arbol_valido_conserva_los_tamanos_de_siempre():
+    """Si el padre ya es la suma (o mayor), nada cambia: tamaño = valor del nodo."""
+    traza = _suma_exacta().plot().data[0]
+    assert dict(zip(traza.labels, traza.values)) == {"Total": 300.0, "A": 100.0, "B": 200.0}
+    mayor = wl.KPINode("P", value=500.0, children=[wl.KPINode("H", value=100.0)])
+    assert dict(zip(mayor.plot().data[0].labels, mayor.plot().data[0].values)) == {"P": 500.0, "H": 100.0}
+
+
+def test_el_texto_emergente_sigue_mostrando_el_valor_y_la_formula():
+    raiz = wl.KPINode("EBITDA", value=100_000, unit="€", formula="Ingresos − Costos", children=[wl.KPINode("X", value=1.0)])
+    hover = raiz.plot().data[0].customdata[0]
+    assert "100000" in hover and "Ingresos − Costos" in hover and "€" in hover

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.0 → walopy-0.4.2}/tests/test_salida_identica.py

@@ -3,6 +3,9 @@
 ``tests/golden/salida_es.json`` se generó con ``python scripts/instantanea_salida.py --escribir`` sobre el código de v0.3.0, ANTES de
 mover los textos a un catálogo. Cubre resultados, tablas, mensajes de error, avisos, gráficas, README y CLI, con el idioma por defecto.
 Si cambia a propósito un texto en español, regenera la instantánea y revisa el diff como parte del PR.
+
+Excepción deliberada (W-26): la ``grafica`` de ``oee_kpi_tree``, ``throughput_kpi_tree`` y ``roi_kpi_tree`` se actualizó a mano en la instantánea: ahora
+rotula el valor real de cada nodo en ``text`` (los árboles salían en blanco en el navegador, ver ``tests/test_kpi_grafica.py``).
 """
 from __future__ import annotations
 

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)