walopy 0.2.8__tar.gz → 0.3.0__tar.gz

{walopy-0.2.8 → walopy-0.3.0}/PKG-INFO

@@ -1,14 +1,15 @@
 Metadata-Version: 2.4
 Name: walopy
-Version: 0.2.8
-Summary: Queuing theory, operations analysis, OEE, bottleneck analysis and KPI trees for Python
+Version: 0.3.0
+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
 Project-URL: Homepage, https://github.com/LeoSanta15/walopy
 Project-URL: Issues, https://github.com/LeoSanta15/walopy/issues
 Project-URL: Changelog, https://github.com/LeoSanta15/walopy/blob/main/CHANGELOG.md
-Keywords: queuing theory,operations research,little's law,kingman,bottleneck,OEE,efficiency,utilization,unit cost,KPI
+Keywords: operations research,queuing theory,little's law,kingman,inventory,EOQ,MRP,ABC analysis,scheduling,flow-shop,CPM,PERT,reliability,weibull,bottleneck,OEE,KPI
 Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
@@ -17,6 +18,7 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Operating System :: OS Independent
 Classifier: Intended Audience :: Science/Research
 Classifier: Topic :: Scientific/Engineering
+Classifier: Typing :: Typed
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
@@ -27,8 +29,13 @@ Requires-Dist: plotly>=5.0
 Provides-Extra: dev
 Requires-Dist: pytest>=7; extra == "dev"
 Requires-Dist: pytest-cov>=4; extra == "dev"
-Requires-Dist: ruff>=0.6; extra == "dev"
-Requires-Dist: mypy>=1.10; extra == "dev"
+Requires-Dist: pytest-timeout>=2; extra == "dev"
+Requires-Dist: ruff~=0.16.10; extra == "dev"
+Requires-Dist: mypy<3,>=1.10; extra == "dev"
+Provides-Extra: release
+Requires-Dist: build; extra == "release"
+Requires-Dist: twine; extra == "release"
+Requires-Dist: pip-audit; extra == "release"
 Provides-Extra: docs
 Requires-Dist: sphinx>=7; extra == "docs"
 Requires-Dist: sphinx-rtd-theme>=2; extra == "docs"
@@ -66,15 +73,16 @@ pip install walopy
 12. [Curvas de intercambio](#12-curvas-de-intercambio)
 13. [Programación de producción (scheduling)](#13-programación-de-producción-scheduling)
 14. [Confiabilidad](#14-confiabilidad--reliability)
-15. [Árboles de KPI](#15-árboles-de-kpi)
-16. [Solvers y optimización](#16-solvers-y-optimización)
-17. [Análisis de sensibilidad](#17-análisis-de-sensibilidad)
-18. [Escenarios en lote (batch_model)](#18-escenarios-en-lote-batch_model)
-19. [Comparar múltiples resultados](#19-comparar-múltiples-resultados)
-20. [Gráficas](#20-gráficas)
-21. [CLI](#21-cli)
-22. [Referencia de módulos](#22-referencia-de-módulos)
-23. [Requisitos](#23-requisitos)
+15. [Proyectos: CPM y PERT](#15-proyectos-cpm-y-pert--project)
+16. [Árboles de KPI](#16-árboles-de-kpi)
+17. [Solvers y optimización](#17-solvers-y-optimización)
+18. [Análisis de sensibilidad](#18-análisis-de-sensibilidad)
+19. [Escenarios en lote (batch_model)](#19-escenarios-en-lote-batch_model)
+20. [Comparar múltiples resultados](#20-comparar-múltiples-resultados)
+21. [Gráficas](#21-gráficas)
+22. [CLI](#22-cli)
+23. [Referencia de módulos](#23-referencia-de-módulos)
+24. [Requisitos](#24-requisitos)
 
 ---
 
@@ -119,14 +127,14 @@ import walopy as wl
 
 r = wl.mm1(lam=3.0, mu=5.0)
 print(r)
-# Model : M/M/1
-# λ     : 3.0   (arrival rate)
-# μ     : 5.0   (service rate per server)
-# ρ     : 0.6   (utilization)
-# L     : 1.5   (avg units in system)
-# Lq    : 0.9   (avg units in queue)
-# W     : 0.5   (avg time in system)
-# Wq    : 0.3   (avg wait time in queue)
+# Modelo : M/M/1
+# λ      : 3.0   (tasa de llegada)
+# μ      : 5.0   (tasa de servicio por servidor)
+# ρ      : 0.6   (utilización por servidor)
+# L      : 1.5   (unidades promedio en el sistema)
+# Lq     : 0.9   (unidades promedio en cola)
+# W      : 0.5   (tiempo promedio en el sistema)
+# Wq     : 0.3   (tiempo promedio de espera en cola)
 
 df = r.to_frame()   # exportar a DataFrame
 r.plot()            # gráfica Wq y Lq vs ρ
@@ -193,7 +201,9 @@ r = wl.kingman(lam=3.0, mu=5.0, ca2=0.5, cs2=1.0)
 r = wl.kingman(lam=3.0, mu=5.0, ca2=1.0, cs2=3.0)
 
 # Recuperar parámetros ajustados desde datos reales y usarlos directamente
-fit = wl.fit_from_data(inter_arrivals=..., service_times=...)
+import numpy as np
+rng = np.random.default_rng(42)
+fit = wl.fit_from_data(inter_arrivals=rng.exponential(0.2, 500), service_times=rng.exponential(0.1, 500))
 r   = wl.kingman(**fit.to_model_kwargs())
 ```
 
@@ -266,12 +276,12 @@ Cola con **capacidad finita** K (servidor + sala de espera). Los clientes que ll
 
 **Parámetros adicionales en `result.params`:**
 - `PK (blocking prob)` — probabilidad de rechazo (sistema lleno)
-- `lam_eff` — tasa de llegada efectiva = λ · (1 − P_K)
+- `λ_eff (effective rate)` — tasa de llegada efectiva = λ · (1 − P_K)
 
 ```python
 r = wl.mm1k(lam=5.0, mu=3.0, K=10)
-print(r.params["PK (blocking prob)"])  # fracción de clientes rechazados
-print(r.params["lam_eff"])             # tasa real de entrada al sistema
+print(r.params["PK (prob. de bloqueo)"])  # fracción de clientes rechazados
+print(r.params["λ_eff (tasa efectiva)"])  # tasa real de entrada al sistema
 ```
 
 ---
@@ -282,7 +292,7 @@ Multi-servidor con capacidad finita. Generaliza tanto M/M/c (K→∞) como M/M/1
 
 ```python
 r = wl.mmck(lam=8.0, mu=3.0, c=2, K=20)
-print(r.params["PK (blocking prob)"])
+print(r.params["PK (prob. de bloqueo)"])
 
 # Verificación: con K muy grande se acerca a M/M/c
 r_inf  = wl.mmc(lam=3.0, mu=5.0, c=2)
@@ -455,8 +465,9 @@ print(fit_ia.mu)     # None
 ts  = np.cumsum(rng.exponential(0.2, 1000))   # timestamps acumulados
 fit = wl.fit_from_data(arrival_timestamps=ts)
 
-# 4. Conectar directamente con un modelo
-r = wl.kingman(**fit.to_model_kwargs())  # usa lam, mu, ca2, cs2
+# 4. Conectar directamente con un modelo (necesita λ, μ, ca² y cs²: ajuste con ambas muestras)
+fit_completo = wl.fit_from_data(ia, svc)
+r = wl.kingman(**fit_completo.to_model_kwargs())  # usa lam, mu, ca2, cs2
 ```
 
 **`FitResult` — atributos:**
@@ -570,12 +581,12 @@ r = wl.eoq(
     holding_cost=2,      # h: costo por unidad por período
 )
 print(r)
-# EOQ (order quantity): 223.6 units
-# Order frequency     : 4.472 orders/period
-# Cycle time          : 0.2236 periods
-# Total cost          : 447.2
-#   Holding cost      : 223.6
-#   Ordering cost     : 223.6   ← iguales en el óptimo
+# EOQ (cantidad de pedido): 223.6 unidades
+# Frecuencia de pedidos   : 4.472 pedidos/periodo
+# Tiempo de ciclo         : 0.2236 periodos
+# Costo total             : 447.2
+#   Costo de mantener     : 223.6
+#   Costo de ordenar      : 223.6   ← iguales en el óptimo
 
 r.plot()            # gráfica de curvas de costo
 df = r.to_frame()
@@ -613,11 +624,11 @@ r = wl.reorder_point(
     service_level=0.95,  # nivel de servicio deseado
 )
 print(r)
-# Reorder point   : 132.4 units
-# Safety stock    : 32.4 units
-# Service level   : 95.00%
-# z-score         : 1.645
-# Mean demand LT  : 100.0
+# Punto de reorden    : 132.4 unidades
+# Stock de seguridad  : 32.4 unidades
+# Nivel de servicio   : 95.00%
+# z                   : 1.645
+# Demanda media en LT : 100.0
 # Std demand LT   : 19.72
 
 # Sin variabilidad → solo demanda esperada durante LT
@@ -665,14 +676,14 @@ r = wl.newsvendor(
     salvage=2,       # valor residual de unidades no vendidas
 )
 print(r)
-# Optimal quantity   : 100.0 units
-# Critical ratio     : 0.5
-# Expected profit    : 320.0
-# Expected sales     : 100.0
-# Expected leftover  : 0.0
-# Expected stockout  : 0.0
-# Underage cost Cu   : 4.0
-# Overage cost  Co   : 4.0
+# Cantidad óptima     : 100.0 unidades
+# Razón crítica       : 0.5
+# Utilidad esperada   : 320.0
+# Ventas esperadas    : 100.0
+# Sobrante esperado   : 0.0
+# Faltante esperado   : 0.0
+# Costo de subestimar Cu: 4.0
+# Costo de sobrestimar Co: 4.0
 
 # Producto con alto margen → pedir por encima de la media
 r_alto = wl.newsvendor(demand_mean=100, demand_std=20,
@@ -719,15 +730,15 @@ r = wl.ebq(
     production_rate=4000,   # P: tasa de producción (debe ser > D)
 )
 print(r)
-# EBQ (batch size)    : 258.2 units
-# Max inventory       : 193.6
-# Avg inventory       : 96.82
-# Order frequency     : 3.873 runs/period
-# Cycle time          : 0.2582 periods
-# Production time/cyc : 0.06455 periods
-# Total cost          : 193.6
-#   Holding cost      : 96.82
-#   Setup cost        : 96.82
+# EBQ (tamaño de lote): 258.2 unidades
+# Inventario máximo   : 193.6
+# Inventario promedio : 96.82
+# Frecuencia de lotes : 3.873 lotes/periodo
+# Tiempo de ciclo     : 0.2582 periodos
+# Tiempo de producción: 0.06455 periodos
+# Costo total         : 193.6
+#   Costo de mantener : 96.82
+#   Costo de preparación: 96.82
 ```
 
 **`EBQResult` — atributos:**
@@ -833,9 +844,9 @@ r = wl.lot_for_lot(demands, setup_cost=200, holding_cost=1)
 print(r.total_holding_cost)   # 0.0 — sin inventario residual
 print(r.n_orders)             # 4 — un pedido por período con demanda > 0
 print(r)
-# Method              : Lot-for-Lot
-# Number of orders    : 4
-# Total cost          : 800.0
+# Método               : Lote por lote
+# Número de pedidos    : 4
+# Costo total          : 800.0
 ```
 
 ---
@@ -898,11 +909,83 @@ df = r.to_frame()       # todos los candidatos evaluados
 
 ---
 
+---
+
+### ABC, XYZ y ABC-XYZ — clasificación de artículos
+
+`abc_analysis` clasifica por **valor anual** (Pareto): un artículo es A mientras el acumulado *previo* a él sea
+menor que `a_threshold` (80 %), B mientras sea menor que `b_threshold` (95 %) y C en el resto. Los artículos
+sin demanda quedan en C. `xyz_analysis` clasifica por **variabilidad** (coeficiente de variación): X si
+CV ≤ `x_threshold` (0.5), Y hasta `y_threshold` (1.0) y Z por encima. `abc_xyz` combina ambas y devuelve la
+matriz 3×3.
+
+```python
+items = [
+    {"name": "A", "demand": 500, "unit_value": 10.0, "demand_std": 120},
+    {"name": "B", "demand": 300, "unit_value": 10.0, "demand_std": 60},
+    {"name": "C", "demand": 100, "unit_value": 10.0, "demand_std": 150},
+    {"name": "D", "demand": 700, "unit_value": 1.0,  "demand_std": 300},
+    {"name": "E", "demand": 300, "unit_value": 1.0,  "demand_std": 10},
+]
+
+abc = wl.abc_analysis(items)
+print(abc)                       # resumen por clase: A = 2 artículos (80 % del valor)
+print(abc.to_frame()[["artículo", "valor_anual", "pct_acumulado", "clase"]])
+
+# XYZ: cada artículo aporta 'cv' directamente o 'demand_std' + 'demand_mean' (o 'demand_rate')
+xyz = wl.xyz_analysis([
+    {"name": i["name"], "demand_std": i["demand_std"], "demand_mean": i["demand"]} for i in items
+])
+print(xyz.to_frame())            # columnas: artículo, cv, clase
+
+# ABC-XYZ: matriz de conteos (filas ABC, columnas XYZ)
+combo = wl.abc_xyz([{**i, "cv": i["demand_std"] / i["demand"]} for i in items])
+print(combo.matrix_frame())
+print(combo.items[0]["combined_class"])   # 'AX'
+```
+
+| Parámetro | Descripción |
+|---|---|
+| `items` | Lista de diccionarios. ABC: `demand` (≥ 0) y `unit_value` (> 0). XYZ: `cv` o `demand_std` + `demand_mean`/`demand_rate` |
+| `a_threshold`, `b_threshold` | Límites acumulados de las clases A y B (0 < a < b < 1) |
+| `x_threshold`, `y_threshold` | Límites de CV de las clases X e Y |
+
+Errores: lista vacía, elementos que no son diccionarios, claves faltantes y valores no finitos lanzan `ValueError`/`TypeError`
+con el elemento y la clave afectados; si todas las demandas son 0 no hay nada que clasificar y se lanza `ValueError`.
+
+---
+
+### MRP de un nivel — `mrp`
+
+Plan de requerimientos de materiales para un artículo: necesidades netas, órdenes planificadas (recepción y
+liberación) y existencias proyectadas. Admite lote por lote (`"LFL"`) o lote fijo, tiempo de entrega,
+stock de seguridad y recepciones programadas.
+
+```python
+r = wl.mrp(
+    gross_requirements=[0, 50, 0, 30, 60, 20],
+    initial_on_hand=40,
+    scheduled_receipts=[0, 0, 25, 0, 0, 0],
+    lead_time=1,
+    lot_size=40,          # "LFL" para lote por lote
+    safety_stock=10,
+    item_name="Eje",
+)
+print(r)                      # tabla por periodo: GR, SR, OH, NR, PR, PO
+print(r.to_frame())           # el mismo plan como DataFrame
+print(r.past_due_releases)    # 0.0
+```
+
+Si el `lead_time` es mayor que el periodo en que se necesita la orden, la liberación cae antes del periodo 1:
+`mrp` emite un `UserWarning` y acumula esa cantidad en `past_due_releases` (no aparece en `planned_releases`).
+
+---
+
 ## 8. Análisis de operaciones
 
 ### `oee(availability, performance, quality)` — OEE
 
-Calcula la **Eficiencia Global de los Equipos** (OEE = Availability × Performance × Quality).
+Calcula la **Eficiencia Global de los Equipos** (OEE = Disponibilidad × Rendimiento × Calidad).
 
 ```python
 r = wl.oee(
@@ -917,21 +1000,21 @@ print(r)
 r.plot()    # gráfica horizontal con referencia world-class (85%)
 ```
 
-### `utilization_efficiency(actual_output, max_output)` — Utilización
+### `utilization_efficiency(actual_output, capacity)` — Utilización
 
 ```python
-r = wl.utilization_efficiency(actual_output=750, max_output=1000)
+r = wl.utilization_efficiency(actual_output=750, capacity=1000)
 print(r.utilization)         # 0.75 — 75% de utilización
-print(r.idle_fraction)       # 0.25 — 25% capacidad ociosa
+print(1 - r.utilization)     # 0.25 — 25% de capacidad ociosa
 ```
 
-### `unit_cost(fixed_cost, variable_cost, units)` — Costo unitario
+### `unit_cost(fixed_cost, variable_cost_per_unit, units_produced)` — Costo unitario
 
 ```python
-r = wl.unit_cost(fixed_cost=10_000, variable_cost=5_000, units=500)
-print(r.unit_cost)           # 30.0 $/unidad
-print(r.fixed_cost_per_unit) # 20.0
-print(r.var_cost_per_unit)   # 10.0
+r = wl.unit_cost(fixed_cost=10_000, variable_cost_per_unit=10, units_produced=500)
+print(r.unit_cost)               # 30.0 $/unidad
+print(r.fixed_cost_per_unit)     # 20.0
+print(r.variable_cost_per_unit)  # 10.0
 ```
 
 ---
@@ -949,7 +1032,7 @@ r = wl.bottleneck_analysis(
     demand_rate=70.0,                  # demanda requerida
 )
 print(r)
-# Bottleneck: Soldadura  (capacidad 80 < demanda 70 con menor margen)
+# Cuello de botella: Soldadura  (capacidad 80 < demanda 70 con menor margen)
 # Utilization: Corte=58.3%, Soldadura=87.5%, Pintura=70.0%
 
 r.plot()   # barras de utilización con cuello de botella en rojo
@@ -968,19 +1051,19 @@ takt = wl.takt_time(available_time=480, demand=60)
 print(takt)   # 8.0 min/unidad
 ```
 
-### `line_balance(names, cycle_times, takt)` — Balance de línea
+### `line_balance(station_names, cycle_times, takt)` — Balance de línea
 
 Analiza si cada estación puede cumplir con el tiempo takt y calcula la eficiencia de balance.
 
 ```python
 lb = wl.line_balance(
-    names=["A", "B", "C"],
+    station_names=["A", "B", "C"],
     cycle_times=[5.0, 9.0, 4.0],
     takt=10.0,
 )
 print(lb.bottleneck)           # "B" — estación más lenta
-print(lb.balance_efficiency)   # 0.60 — 60% de eficiencia
-print(lb.total_idle_time)      # tiempo ocioso total
+print(lb.balance_efficiency)   # eficiencia de balance de la línea
+print(lb.theoretical_min_stations)  # número mínimo teórico de estaciones
 
 lb.plot()  # barras de cycle time vs takt
 ```
@@ -1000,8 +1083,8 @@ be = wl.break_even(
 )
 print(be.bep_units)              # 1000.0 — punto de equilibrio en unidades
 print(be.bep_revenue)            # 25000.0 — ingresos en el punto de equilibrio
-print(be.margin_of_safety_pct)   # 33.3% — margen de seguridad sobre ventas actuales
-print(be.profit)                 # 5000.0 — beneficio con actual_units
+print(be.margin_of_safety_pct)   # 0.333 — margen de seguridad (fracción) sobre ventas actuales
+print(be.margin_of_safety_units) # 500.0 — unidades por encima del punto de equilibrio
 
 be.plot()   # líneas de ingresos/costos con BEP y zona de beneficio
 ```
@@ -1024,7 +1107,7 @@ print(r.bep_units_total)          # unidades totales en el punto de equilibrio
 print(r.bep_revenue_total)        # ingresos totales en el punto de equilibrio
 
 for item in r.items:
-    print(item["Name"], item["BEP units"])
+    print(item["Producto"], item["PE unidades"])
 
 r.to_frame()    # DataFrame con una fila por producto
 ```
@@ -1058,577 +1141,668 @@ print(r.margin_of_safety_pct)     # 0.375 — porcentaje del margen de seguridad
 
 ---
 
-## 15. Árboles de KPI
+## 12. Curvas de intercambio
 
-Los árboles de KPI crean jerarquías interactivas visualizadas como **treemap** o **sunburst** con Plotly.
+Herramientas para tomar decisiones de política agregada en familias de artículos.
 
-### `oee_kpi_tree(availability, performance, quality)`
+### Tipo 1 — ciclo: `exchange_curve`
+
+Traza la hipérbola entre número de pedidos por año (N) e inversión promedio en inventario de ciclo (I):
 
-```python
-tree = wl.oee_kpi_tree(0.90, 0.80, 0.95)
-tree.plot()                     # treemap (por defecto)
-tree.plot(kind="sunburst")      # diagrama radial
+```
+N(k) = N* / k      I(k) = k · I*      →      N · I = N* · I*  (constante)
 ```
 
-### `throughput_kpi_tree(actual_throughput, capacity, defect_rate)`
+Dado un target de N o de I, resuelve el multiplicador k óptimo y recalcula Q para cada artículo.
 
 ```python
-tree = wl.throughput_kpi_tree(
-    actual_throughput=750,
-    capacity=1000,
-    defect_rate=0.05,
-)
-tree.plot()
-```
+import walopy as wl
 
-### `roi_kpi_tree(revenue, fixed_cost, variable_cost_per_unit, units_sold, investment)`
+items = [
+    {"name": "A", "demand": 1000, "ordering_cost": 50,  "holding_cost": 2,  "unit_value": 10},
+    {"name": "B", "demand":  500, "ordering_cost": 30,  "holding_cost": 1,  "unit_value":  5},
+    {"name": "C", "demand": 2000, "ordering_cost": 100, "holding_cost": 4,  "unit_value":  8},
+]
 
-```python
-tree = wl.roi_kpi_tree(
-    revenue=50_000,
-    fixed_cost=10_000,
-    variable_cost_per_unit=8,
-    units_sold=2_000,
-    investment=20_000,
-)
-print(tree.value)   # ROI = 0.2 (20%)
-tree.plot()
+# Sin target → punto EOQ (k = 1)
+r = wl.exchange_curve(items)
+print(r)
 ```
 
-### `KPINode` — árbol personalizado
+```
+Objetivo                : eoq
+Multiplicador k         : 1.0000
+N pedidos/año (EOQ)     : 87.27
+N pedidos/año (óptimo)  : 87.27
+Inversión (EOQ)         : 5430
+Inversión (óptimo)      : 5430
+```
 
 ```python
-root = wl.KPINode("EBITDA", value=100_000, unit="€")
-rev  = root.add_child("Revenue",        value=200_000, unit="€")
-cost = root.add_child("Operating costs", value=100_000, unit="€")
-rev.add_child("Product A", value=120_000, unit="€")
-rev.add_child("Product B", value=80_000,  unit="€")
+# Reducir a 20 pedidos/año (k > 1 → Q más grandes → más inversión)
+r = wl.exchange_curve(items, target_orders=20)
 
-from walopy.plotting import plot_kpi_tree
-fig = plot_kpi_tree(root, kind="treemap")
-fig.show()
+# Limitar inversión a 3 000 (k < 1 → Q más pequeños → más pedidos)
+r = wl.exchange_curve(items, target_investment=3000)
+
+# Tabla por artículo
+df = r.to_frame()
+# columnas: artículo | Q_eoq | Q_óptima | n_pedidos | inversión
+
+# Hipérbola para graficar
+curve = r.curve_to_frame()
+# columnas: N | I
 ```
 
+**Parámetros de cada artículo**
+
+| Clave | Requerido | Descripción |
+|-------|-----------|-------------|
+| `demand` | ✓ | Demanda anual Di |
+| `ordering_cost` | ✓ | Costo de pedido Ki |
+| `holding_cost` | ✓ | Costo de mantenimiento hi |
+| `unit_value` | — | Valor unitario vi (default 1) |
+| `name` | — | Etiqueta (default I1, I2, …) |
+
 ---
 
-## 16. Solvers y optimización
+### Tipo 2 — seguridad: `safety_stock_curve`
 
-### `solve_lam(metric, target, *, mu, model)` — Máxima tasa de llegada
+Traza la curva entre inversión en stock de seguridad e nivel de servicio por ciclo usando una **política z común** para toda la familia:
 
-Encuentra la mayor λ tal que una métrica no supere el objetivo.
+```
+SS_i(z) = z · σᵢ_DLT · vᵢ          σᵢ_DLT = √(Lᵢ·σ²_Di + D²ᵢ·σ²_Li)
+SS_total(z) = z · Σ σᵢ_DLT · vᵢ     SL(z) = Φ(z)
+```
 
 ```python
-r = wl.solve_lam("Wq", target=0.5, mu=5.0, model="mm1")
-print(r.value)          # λ máxima ≈ 3.33
-print(r.achieved_value) # Wq ≈ 0.5
-print(r.model_result)   # QueueResult completo en la solución
+items = [
+    {"name": "A", "demand_rate": 100, "demand_std": 10, "lead_time": 2, "unit_value": 10},
+    {"name": "B", "demand_rate":  50, "demand_std":  5, "lead_time": 1, "unit_value":  5},
+    {"name": "C", "demand_rate": 200, "demand_std": 20, "lead_time": 3, "unit_value":  8},
+]
+
+# Target: nivel de servicio 95%
+r = wl.safety_stock_curve(items, target_service_level=0.95)
+print(r)
 ```
 
-### `solve_mu(metric, target, *, lam, model)` — Mínima tasa de servicio
+```
+Objetivo          : nivel_de_servicio=95.0000%
+z                 : 1.6449
+Nivel de servicio : 95.0000%
+Inversión en SS   : 1 847
+```
 
 ```python
-r = wl.solve_mu("Wq", target=0.3, lam=3.0, model="mm1")
-print(r.value)   # μ mínima necesaria ≈ 5.0
-```
+# Target: presupuesto máximo de SS
+r = wl.safety_stock_curve(items, target_ss_investment=1000)
 
-### `solve_servers(metric, target, *, lam, mu)` — Mínimo número de servidores
+# Tabla por artículo (incluye punto de reorden cuando se da demand_rate)
+df = r.to_frame()
+# columnas: artículo | sigma_dlt | stock_de_seguridad | inversión | punto_de_reorden
 
-```python
-r = wl.solve_servers("Wq", target=0.1, lam=8.0, mu=5.0)
-print(r.value)         # c mínimo = 3
-print(r.model_result)  # QueueResult para M/M/3
+# Curva completa (z de −2 a 4)
+curve = r.curve_to_frame()
+# columnas: z | service_level | ss_investment
 ```
 
-### `optimize_servers(lam, mu, cost_per_server, cost_per_wait)` — Optimización de costo total
+**Parámetros de cada artículo**
 
-Minimiza cost_per_server × c + cost_per_wait × λ × Wq evaluando todos los c viables.
+| Clave | Requerido | Descripción |
+|-------|-----------|-------------|
+| `demand_std` | ✓ | Desviación estándar de la demanda |
+| `lead_time` | ✓ | Lead time medio |
+| `demand_rate` | — | Demanda media; activa columna `reorder_point` |
+| `lead_time_std` | — | Desviación estándar del lead time (default 0) |
+| `unit_value` | — | Valor unitario (default 1) |
+| `name` | — | Etiqueta (default I1, I2, …) |
 
-```python
-r = wl.optimize_servers(
-    lam=6.0,
-    mu=5.0,
-    cost_per_server=10.0,   # costo fijo por servidor por unidad de tiempo
-    cost_per_wait=5.0,      # costo por unidad de tiempo de espera de cada cliente
-)
-print(r.optimal_servers)   # c óptimo
-print(r.optimal_cost)      # costo mínimo
+---
 
-r.plot()   # gráfica de costo vs número de servidores
-```
+### Relación entre ambas curvas
+
+| | Tipo 1 (ciclo) | Tipo 2 (seguridad) |
+|---|---|---|
+| **Función** | `exchange_curve` | `safety_stock_curve` |
+| **Decide** | Tamaño de lote Q | Punto de reorden r |
+| **Tradeoff** | N pedidos/año ↔ Inversión ciclo | Nivel de servicio ↔ SS |
+| **Resultado** | `ExchangeCurveResult` | `SafetyStockCurveResult` |
+| **Parámetro** | Multiplicador k | Factor z |
+
+Usadas juntas cubren la política completa `(Q, r)` para toda la familia.
 
 ---
 
-## 17. Análisis de sensibilidad
+## 13. Programación de producción (scheduling)
 
-### `sensitivity(model_fn, param, values, **fixed_kwargs)` — Barrido paramétrico
+### Máquina única — `schedule_single`
 
-Evalúa un modelo sobre un rango de valores de un parámetro.
+Asigna *n* trabajos a una sola máquina según una regla de prioridad.
 
 ```python
-import numpy as np
-
-df = wl.sensitivity(
-    wl.mm1,
-    param="lam",
-    values=np.linspace(0.5, 4.5, 20),
-    mu=5.0,       # parámetros fijos
-)
-print(df.columns.tolist())  # ['lam', 'rho', 'L', 'Lq', 'W', 'Wq', ...]
+import walopy as wl
 
-# Barrido sobre μ
-df2 = wl.sensitivity(wl.mm1, "mu", np.linspace(4.0, 10.0, 15), lam=3.0)
+p = [3, 1, 4, 1, 5]          # tiempos de proceso
+d = [8, 3, 10, 4, 12]         # fechas de entrega
+w = [2, 5, 1, 4, 1]           # pesos de importancia
 
-# Barrido sobre número de servidores en M/M/c
-df3 = wl.sensitivity(wl.mmc, "c", range(1, 6), lam=8.0, mu=5.0)
+r = wl.schedule_single(p, rule="SPT", due_dates=d, weights=w,
+                        names=["A","B","C","D","E"])
+print(r)
+```
 
-# Visualizar
-from walopy.plotting import plot_sensitivity
-fig = plot_sensitivity(df, "lam", metrics=["Wq", "Lq"])
-fig.show()
+```
+Regla                   : SPT
+Secuencia               : B → D → A → C → E
+Makespan (Cmax)         : 14
+Finalización total ΣCj  : 37
+Finalización pond. ΣwCj : 89
+Retraso máximo          : 2
+Tardanza total ΣTj      : 2
+Trabajos con retraso    : 1
 ```
 
----
+**Reglas disponibles**
 
-## 18. Escenarios en lote (batch_model)
+| `rule` | Criterio minimizado | Datos requeridos |
+|--------|---------------------|-----------------|
+| `'SPT'` | ΣCj (tiempo total de completación) | — |
+| `'EDD'` | Lmax (máxima tardanza) | `due_dates` |
+| `'WSPT'` | ΣwjCj (completación ponderada) | `weights` |
+| `'CR'` | Ratio crítico dj/pj | `due_dates` |
+| `'FIFO'` | Orden de llegada (línea base) | — |
 
-### `batch_model(model_fn, df, **fixed_kwargs)` — Aplicar modelo a un DataFrame
+**Atributos de `ScheduleResult`**
 
-Aplica cualquier función de walopy a cada fila de un DataFrame de escenarios.
+| Atributo | Descripción |
+|----------|-------------|
+| `rule` | Regla utilizada |
+| `sequence` | Lista de nombres en orden de procesamiento |
+| `jobs` | Lista de `JobSchedule` (por trabajo) |
+| `makespan` | Cmax = suma de tiempos de proceso |
+| `total_completion_time` | ΣCj |
+| `total_weighted_completion_time` | ΣwjCj |
+| `max_lateness` | max(Lj) |
+| `total_tardiness` | ΣTj |
+| `n_tardy` | Número de trabajos tarde |
 
 ```python
-import pandas as pd
+df = r.to_frame()  # columnas: Trabajo, p, d, w, Inicio, C, L, T, Con retraso
+```
 
-# Varios escenarios con distintas tasas de llegada
-escenarios = pd.DataFrame({
-    "lam": [1.0, 2.0, 3.0, 4.0]
-})
-resultado = wl.batch_model(wl.mm1, escenarios, mu=5.0)
-print(resultado[["lam", "rho", "Wq", "L"]])
+---
 
-# Escenarios mixtos (lambda y mu variables)
-escenarios2 = pd.DataFrame({
-    "lam": [2.0, 3.0, 4.0],
-    "mu":  [5.0, 6.0, 7.0],
-})
-resultado2 = wl.batch_model(wl.mm1, escenarios2)
+### Flow-shop de 2 máquinas — `johnson_flowshop`
 
-# Con número de servidores variable (columna int)
-escenarios3 = pd.DataFrame({
-    "c": [1, 2, 3, 4],
-})
-resultado3 = wl.batch_model(wl.mmc, escenarios3, lam=8.0, mu=5.0)
+El algoritmo de Johnson encuentra la secuencia óptima que minimiza el makespan cuando todos los trabajos pasan primero por M1 y luego por M2.
+
+```python
+m1 = [3, 8, 5, 7, 2]   # tiempos en máquina 1
+m2 = [5, 2, 8, 4, 6]   # tiempos en máquina 2
+
+r = wl.johnson_flowshop(m1, m2)
+print(r)
+```
+
+```
+Secuencia : J1 → J5 → J4 → J3 → J2
+Makespan  : 34
+```
 
-# Las filas con error quedan marcadas en "_error"
-print(resultado[resultado["_error"].notna()])  # filas fallidas
+```python
+df = r.to_frame()
+# columnas: Job | M1 start | M1 end | M2 start | M2 end
 ```
 
 ---
 
-## 19. Comparar múltiples resultados
+### Flow-shop de m máquinas — `neh_flowshop`
 
-### `compare(*results, labels)` — DataFrame comparativo
-
-Construye un DataFrame con una fila por resultado para facilitar la comparación.
+Heurística de **Nawaz-Enscore-Ham** para el flow-shop de permutación con cualquier número de máquinas:
+ordena los trabajos por tiempo total decreciente e inserta cada uno en la mejor posición (aceleración de
+Taillard: O(n²·m)). Es una heurística: en casos pequeños el makespan queda típicamente a pocos puntos
+porcentuales del óptimo.
 
 ```python
-df = wl.compare(
-    wl.mm1(3.0, 5.0),
-    wl.mmc(3.0, 5.0, 2),
-    wl.md1(3.0, 5.0),
-    labels=["M/M/1", "M/M/2", "M/D/1"],
-)
-print(df[["label", "ρ (utilization)", "Wq (wait time)", "L (system)"]])
-#    label  ρ (utilization)  Wq (wait time)  L (system)
-# 0  M/M/1          0.6         0.3000         1.50
-# 1  M/M/2          0.3         0.0302         1.02
-# 2  M/D/1          0.6         0.1500         1.05
-
-# Sin etiquetas → scenario_1, scenario_2, ...
-df2 = wl.compare(wl.mm1(1, 5), wl.mm1(2, 5), wl.mm1(3, 5))
+# filas = trabajos, columnas = máquinas
+tiempos = [[5, 9, 8], [9, 3, 10], [9, 4, 5], [4, 8, 8]]
+r = wl.neh_flowshop(tiempos, names=["P1", "P2", "P3", "P4"])
+print(r)               # secuencia y makespan
+print(r.to_frame())    # Gantt: columnas M1_inicio, M1_fin, M2_inicio, ...
+print(r.sequence, r.makespan)
 ```
 
 ---
 
-## 20. Gráficas
+## 14. Confiabilidad — `reliability`
 
-Todos los resultados exponen `.plot()` que devuelve una figura de Matplotlib o Plotly. También se pueden llamar directamente desde `walopy.plotting`.
+Modelos de confiabilidad con distribución exponencial (tasa de falla constante).
 
-| Función `.plot()` | Tipo | Descripción |
-|---|---|---|
-| `QueueResult.plot()` | Matplotlib | Curvas Wq y Lq vs ρ con punto operativo |
-| `OEEResult.plot()` | Matplotlib | Barras horizontales OEE con referencia 85% |
-| `BottleneckResult.plot()` | Matplotlib | Utilización por estación, cuello de botella en rojo |
-| `EOQResult.plot()` | Matplotlib | Curvas de costo de mantener, ordenar y total |
-| `LineBalanceResult.plot()` | Plotly | Cycle time vs takt por estación |
-| `BreakEvenResult.plot()` | Plotly | Líneas ingreso/costo con BEP y zona de beneficio |
-| `SimulationResult.plot()` | Plotly | Histograma de Wq + CDF empírica con percentiles |
-| `OptimizeResult.plot()` | Plotly | Costo por servidor, costo de espera y total vs c |
-| `KPINode.plot(kind=)` | Plotly | Treemap o sunburst interactivo |
+### Componente individual — `mtbf_analysis`
 
 ```python
-# Guardar como HTML interactivo (Plotly)
-fig = r.plot()
-fig.write_html("resultado.html")
+r = wl.mtbf_analysis(failure_rate=0.01, mttr=5.0, t=100)
+print(r)
+```
 
-# Guardar como imagen (Matplotlib)
-fig = wl.oee(0.9, 0.8, 0.95).plot()
-fig.savefig("oee.png", dpi=150)
+```
+Topología       : component
+Componentes     : 1
+Tasas de falla λ: ['0.01']
+MTBF            : 100
+R(t=100)        : 0.367879
+Disponibilidad  : 95.2381%
 ```
 
-Para la curva de sensibilidad:
+### Sistema en serie — `series_system`
+
+El sistema falla si **cualquier** componente falla. λ_sys = Σλi.
+
 ```python
-from walopy.plotting import plot_sensitivity
-df = wl.sensitivity(wl.mm1, "lam", np.linspace(0.5, 4.5, 20), mu=5.0)
-fig = plot_sensitivity(df, "lam", metrics=["Wq", "Lq", "L"])
-fig.show()
+r = wl.series_system([0.01, 0.02, 0.03], t=10)
+print(r.mtbf)      # 1/0.06 ≈ 16.67
+print(r.R_t)       # e^{-0.06·10} ≈ 0.549
 ```
 
----
-
-## 21. CLI
+### Sistema en paralelo — `parallel_system`
 
-walopy incluye una interfaz de línea de comandos para uso rápido sin escribir código.
+El sistema opera si **al menos uno** de los componentes opera.  
+R_sys(t) = 1 − ∏(1 − e^{−λi·t}). MTBF calculado numéricamente.
 
-```bash
-# M/M/1
-python -m walopy mm1 --lam 3 --mu 5
+```python
+r = wl.parallel_system([0.01, 0.02], t=50)
+print(r.R_t)        # mayor que el sistema en serie
+print(r.mtbf)       # mayor que cualquier componente individual
+```
 
-# M/M/c
-python -m walopy mmc --lam 8 --mu 5 --c 2
+### Sistema k-de-n — `koon_system`
 
-# M/D/1
-python -m walopy md1 --lam 3 --mu 5
+Opera si al menos **k** de **n** componentes idénticos están en servicio.  
+MTBF exacto = (1/λ) · Σ_{j=k}^{n} (1/j).
 
-# G/G/1 (Kingman)
-python -m walopy gg1 --lam 3 --mu 5 --ca2 1.2 --cs2 0.8
+```python
+# 2-de-3: requiere al menos 2 de 3 componentes idénticos
+r = wl.koon_system(n=3, k=2, failure_rate=0.01, t=50)
+print(r.mtbf)   # (1/0.01) * (1/2 + 1/3) ≈ 83.33
+print(r.R_t)
+```
 
-# Ley de Little (resolver W)
-python -m walopy littles --L 2.5 --lam 5.0
+**Casos especiales**
+- `k=1` → equivale a `parallel_system` con n componentes idénticos.
+- `k=n` → equivale a `series_system` con n componentes idénticos.
 
-# EOQ
-python -m walopy eoq --demand 1000 --ordering 50 --holding 2
+**Atributos de `ReliabilityResult`**
 
-# Versión
-python -m walopy --version
-```
+| Atributo | Descripción |
+|----------|-------------|
+| `topology` | `'component'`, `'series'`, `'parallel'`, `'k-of-n'` |
+| `n_components` | Número de componentes |
+| `failure_rates` | Lista de λi |
+| `mtbf` | MTBF del sistema |
+| `R_t` | Confiabilidad R(t) si se proporcionó `t` |
+| `availability` | Disponibilidad estacionaria A si se proporcionó `mttr` |
+| `mttr` | Tiempo medio de reparación (si se proporcionó) |
 
-Ejemplo de salida:
-```
-Model : M/M/1
-λ     : 3.0   (arrival rate)
-μ     : 5.0   (service rate per server)
-ρ     : 0.6   (utilization)
-L     : 1.5   (avg units in system)
-Lq    : 0.9   (avg units in queue)
-W     : 0.5   (avg time in system)
-Wq    : 0.3   (avg wait time in queue)
-  P0      : 0.4
+```python
+df = r.to_frame()   # columnas: Topología, Componentes, MTBF[, R(t), Disponibilidad]
+r.R(t=200)          # evalúa R(t) en cualquier tiempo posterior
 ```
 
 ---
 
-## 12. Curvas de intercambio
-
-Herramientas para tomar decisiones de política agregada en familias de artículos.
+### Distribución de Weibull — `weibull_analysis`
 
-### Tipo 1 — ciclo: `exchange_curve`
+Ajusta una Weibull de dos parámetros (forma β, escala η) a tiempos de falla completos por **máxima
+verosimilitud** (`method="MLE"`, bisección sobre la ecuación de verosimilitud) o por **regresión de rangos**
+(`method="RRY"`, rangos medianos de Benard). β < 1 indica mortalidad infantil, β ≈ 1 fallas aleatorias y
+β > 1 desgaste.
 
-Traza la hipérbola entre número de pedidos por año (N) e inversión promedio en inventario de ciclo (I):
+```python
+tiempos = [12.5, 18.3, 24.1, 31.7, 38.2, 45.9, 52.4, 61.0, 70.8, 85.3]
+w = wl.weibull_analysis(tiempos)
+print(w)                       # β ≈ 2.10, η ≈ 49.86, MTTF ≈ 44.16
+print(w.R(30), w.F(30))        # confiabilidad y probabilidad de falla a t = 30
+print(w.h(30))                 # tasa de falla instantánea
+print(w.b10, w.b50, w.b_life(5))   # vidas B10, B50 y B5
+print(w.to_frame())
 
-```
-N(k) = N* / k      I(k) = k · I*      →      N · I = N* · I*  (constante)
+w_rry = wl.weibull_analysis(tiempos, method="RRY")
 ```
 
-Dado un target de N o de I, resuelve el multiplicador k óptimo y recalcula Q para cada artículo.
+Se necesitan al menos 2 tiempos finitos y positivos; si todos son iguales la forma no es estimable
+(`ValueError`) y, si casi no hay dispersión, se avisa (`UserWarning`) de que β alcanzó la cota superior de 100.
 
-```python
-import walopy as wl
+---
 
-items = [
-    {"name": "A", "demand": 1000, "ordering_cost": 50,  "holding_cost": 2,  "unit_value": 10},
-    {"name": "B", "demand":  500, "ordering_cost": 30,  "holding_cost": 1,  "unit_value":  5},
-    {"name": "C", "demand": 2000, "ordering_cost": 100, "holding_cost": 4,  "unit_value":  8},
-]
+## 15. Proyectos: CPM y PERT — `project`
 
-# Sin target → punto EOQ (k = 1)
-r = wl.exchange_curve(items)
-print(r)
-```
+Programación de proyectos sobre una red de actividades. Cada actividad es un diccionario con `name`,
+`predecessors` (lista de nombres, puede omitirse) y su duración. Los nombres deben ser únicos; los
+ciclos y los predecesores desconocidos lanzan `ValueError`.
 
-```
-Target                  : eoq
-Multiplier k            : 1.0000
-N orders/yr  (EOQ)      : 87.27
-N orders/yr  (optimal)  : 87.27
-Investment   (EOQ)      : 5430
-Investment   (optimal)  : 5430
-```
+### CPM — duraciones determinísticas
+
+Paso hacia adelante (ES, EF) y hacia atrás (LS, LF); holgura total HT = LS − ES, holgura libre HL y ruta crítica (HT = 0).
 
 ```python
-# Reducir a 20 pedidos/año (k > 1 → Q más grandes → más inversión)
-r = wl.exchange_curve(items, target_orders=20)
+acts = [
+    {"name": "A", "duration": 3, "predecessors": []},
+    {"name": "B", "duration": 4, "predecessors": ["A"]},
+    {"name": "C", "duration": 2, "predecessors": ["A"]},
+    {"name": "D", "duration": 1, "predecessors": ["B", "C"]},
+]
+r = wl.cpm(acts)
+print(r)                    # duración 8, ruta crítica A → B → D
+print(r.to_frame())         # ES, EF, LS, LF, HT, HL y si es crítica
+print(r.critical_path)      # ['A', 'B', 'D']
+```
 
-# Limitar inversión a 3 000 (k < 1 → Q más pequeños → más pedidos)
-r = wl.exchange_curve(items, target_investment=3000)
+### PERT — tres estimaciones por actividad
 
-# Tabla por artículo
-df = r.to_frame()
-# columnas: name | Q_eoq | Q_optimal | n_orders | investment
+Duración esperada tₑ = (a + 4m + b)/6 y varianza ((b − a)/6)²; la varianza del proyecto es la suma de las
+de la ruta crítica. `probability(T)` da P(duración ≤ T) con aproximación normal.
 
-# Hipérbola para graficar
-curve = r.curve_to_frame()
-# columnas: N | I
+```python
+acts = [
+    {"name": "A", "optimistic": 1, "most_likely": 3, "pessimistic": 5, "predecessors": []},
+    {"name": "B", "optimistic": 2, "most_likely": 4, "pessimistic": 9, "predecessors": ["A"]},
+]
+p = wl.pert(acts)
+print(p)                    # duración esperada 7.5, σ ≈ 1.34
+print(p.probability(9.0))   # ≈ 0.868: probabilidad de terminar en 9 unidades o menos
 ```
 
-**Parámetros de cada artículo**
-
-| Clave | Requerido | Descripción |
-|-------|-----------|-------------|
-| `demand` | ✓ | Demanda anual Di |
-| `ordering_cost` | ✓ | Costo de pedido Ki |
-| `holding_cost` | ✓ | Costo de mantenimiento hi |
-| `unit_value` | — | Valor unitario vi (default 1) |
-| `name` | — | Etiqueta (default I1, I2, …) |
+`probability` solo está disponible en resultados PERT con varianza distinta de cero.
 
 ---
 
-### Tipo 2 — seguridad: `safety_stock_curve`
+## 16. Árboles de KPI
 
-Traza la curva entre inversión en stock de seguridad e nivel de servicio por ciclo usando una **política z común** para toda la familia:
+Los árboles de KPI crean jerarquías interactivas visualizadas como **treemap** o **sunburst** con Plotly.
 
-```
-SS_i(z) = z · σᵢ_DLT · vᵢ          σᵢ_DLT = √(Lᵢ·σ²_Di + D²ᵢ·σ²_Li)
-SS_total(z) = z · Σ σᵢ_DLT · vᵢ     SL(z) = Φ(z)
-```
+### `oee_kpi_tree(availability, performance, quality)`
 
 ```python
-items = [
-    {"name": "A", "demand_rate": 100, "demand_std": 10, "lead_time": 2, "unit_value": 10},
-    {"name": "B", "demand_rate":  50, "demand_std":  5, "lead_time": 1, "unit_value":  5},
-    {"name": "C", "demand_rate": 200, "demand_std": 20, "lead_time": 3, "unit_value":  8},
-]
-
-# Target: nivel de servicio 95%
-r = wl.safety_stock_curve(items, target_service_level=0.95)
-print(r)
+tree = wl.oee_kpi_tree(0.90, 0.80, 0.95)
+tree.plot()                     # treemap (por defecto)
+tree.plot(kind="sunburst")      # diagrama radial
 ```
 
-```
-Target          : service_level=95.0000%
-z               : 1.6449
-Service level   : 95.0000%
-SS investment   : 1 847
-```
+### `throughput_kpi_tree(actual_throughput, capacity, defect_rate)`
 
 ```python
-# Target: presupuesto máximo de SS
-r = wl.safety_stock_curve(items, target_ss_investment=1000)
+tree = wl.throughput_kpi_tree(
+    actual_throughput=750,
+    capacity=1000,
+    defect_rate=0.05,
+)
+tree.plot()
+```
 
-# Tabla por artículo (incluye punto de reorden cuando se da demand_rate)
-df = r.to_frame()
-# columnas: name | sigma_dlt | safety_stock | investment | reorder_point
+### `roi_kpi_tree(revenue, fixed_cost, variable_cost_per_unit, units_sold, investment)`
 
-# Curva completa (z de −2 a 4)
-curve = r.curve_to_frame()
-# columnas: z | service_level | ss_investment
+```python
+tree = wl.roi_kpi_tree(
+    revenue=50_000,
+    fixed_cost=10_000,
+    variable_cost_per_unit=8,
+    units_sold=2_000,
+    investment=20_000,
+)
+print(tree.value)   # ROI = 0.2 (20%)
+tree.plot()
 ```
 
-**Parámetros de cada artículo**
+### `KPINode` — árbol personalizado
 
-| Clave | Requerido | Descripción |
-|-------|-----------|-------------|
-| `demand_std` | ✓ | Desviación estándar de la demanda |
-| `lead_time` | ✓ | Lead time medio |
-| `demand_rate` | — | Demanda media; activa columna `reorder_point` |
-| `lead_time_std` | — | Desviación estándar del lead time (default 0) |
-| `unit_value` | — | Valor unitario (default 1) |
-| `name` | — | Etiqueta (default I1, I2, …) |
+```python
+rev = wl.KPINode("Revenue", value=200_000, unit="€", children=[
+    wl.KPINode("Product A", value=120_000, unit="€"),
+    wl.KPINode("Product B", value=80_000, unit="€"),
+])
+cost = wl.KPINode("Operating costs", value=100_000, unit="€")
+root = wl.KPINode("EBITDA", value=100_000, unit="€", formula="Revenue − Operating costs",
+                  children=[rev, cost])
+
+from walopy.plotting import plot_kpi_tree
+fig = plot_kpi_tree(root, kind="treemap")
+fig.show()
+```
 
 ---
 
-### Relación entre ambas curvas
+## 17. Solvers y optimización
 
-| | Tipo 1 (ciclo) | Tipo 2 (seguridad) |
-|---|---|---|
-| **Función** | `exchange_curve` | `safety_stock_curve` |
-| **Decide** | Tamaño de lote Q | Punto de reorden r |
-| **Tradeoff** | N pedidos/año ↔ Inversión ciclo | Nivel de servicio ↔ SS |
-| **Resultado** | `ExchangeCurveResult` | `SafetyStockCurveResult` |
-| **Parámetro** | Multiplicador k | Factor z |
+### `solve_lam(target_metric, target_value, *, mu, model)` — Máxima tasa de llegada
 
-Usadas juntas cubren la política completa `(Q, r)` para toda la familia.
+Encuentra la mayor λ tal que una métrica no supere el objetivo.
 
----
+```python
+r = wl.solve_lam("Wq", 0.5, mu=5.0, model="mm1")
+print(r.value)          # λ máxima ≈ 3.33
+print(r.achieved_value) # Wq ≈ 0.5
+print(r.model_result)   # QueueResult completo en la solución
+```
 
-## 13. Programación de producción (scheduling)
+### `solve_mu(target_metric, target_value, *, lam, model)` — Mínima tasa de servicio
 
-### Máquina única — `schedule_single`
+```python
+r = wl.solve_mu("Wq", 0.3, lam=3.0, model="mm1")
+print(r.value)   # μ mínima necesaria ≈ 5.0
+```
 
-Asigna *n* trabajos a una sola máquina según una regla de prioridad.
+### `solve_servers(target_metric, target_value, *, lam, mu)` — Mínimo número de servidores
 
 ```python
-import walopy as wl
+r = wl.solve_servers("Wq", 0.1, lam=8.0, mu=5.0)
+print(r.value)         # c mínimo = 3
+print(r.model_result)  # QueueResult para M/M/3
+```
 
-p = [3, 1, 4, 1, 5]          # tiempos de proceso
-d = [8, 3, 10, 4, 12]         # fechas de entrega
-w = [2, 5, 1, 4, 1]           # pesos de importancia
+### `optimize_servers(lam, mu, cost_per_server, cost_per_wait)` — Optimización de costo total
 
-r = wl.schedule_single(p, rule="SPT", due_dates=d, weights=w,
-                        names=["A","B","C","D","E"])
-print(r)
-```
+Minimiza cost_per_server × c + cost_per_wait × λ × Wq evaluando todos los c viables.
 
-```
-Rule                    : SPT
-Sequence                : B → D → A → C → E
-Makespan (Cmax)         : 14
-Total completion ΣCj    : 37
-Weighted completion ΣwCj: 89
-Max lateness            : 2
-Total tardiness ΣTj     : 2
-Tardy jobs              : 1
+```python
+r = wl.optimize_servers(
+    lam=6.0,
+    mu=5.0,
+    cost_per_server=10.0,   # costo fijo por servidor por unidad de tiempo
+    cost_per_wait=5.0,      # costo por unidad de tiempo de espera de cada cliente
+)
+print(r.optimal_servers)   # c óptimo
+print(r.min_cost)          # costo mínimo
+
+r.plot()   # gráfica de costo vs número de servidores
 ```
 
-**Reglas disponibles**
+---
 
-| `rule` | Criterio minimizado | Datos requeridos |
-|--------|---------------------|-----------------|
-| `'SPT'` | ΣCj (tiempo total de completación) | — |
-| `'EDD'` | Lmax (máxima tardanza) | `due_dates` |
-| `'WSPT'` | ΣwjCj (completación ponderada) | `weights` |
-| `'CR'` | Ratio crítico dj/pj | `due_dates` |
-| `'FIFO'` | Orden de llegada (línea base) | — |
+## 18. Análisis de sensibilidad
 
-**Atributos de `ScheduleResult`**
+### `sensitivity(model_fn, param, values, **fixed_kwargs)` — Barrido paramétrico
 
-| Atributo | Descripción |
-|----------|-------------|
-| `rule` | Regla utilizada |
-| `sequence` | Lista de nombres en orden de procesamiento |
-| `jobs` | Lista de `JobSchedule` (por trabajo) |
-| `makespan` | Cmax = suma de tiempos de proceso |
-| `total_completion_time` | ΣCj |
-| `total_weighted_completion_time` | ΣwjCj |
-| `max_lateness` | max(Lj) |
-| `total_tardiness` | ΣTj |
-| `n_tardy` | Número de trabajos tarde |
+Evalúa un modelo sobre un rango de valores de un parámetro.
 
 ```python
-df = r.to_frame()  # columnas: Name, p, d, w, Start, C, L, T, Tardy
+import numpy as np
+
+df = wl.sensitivity(
+    wl.mm1,
+    param="lam",
+    values=np.linspace(0.5, 4.5, 20),
+    mu=5.0,       # parámetros fijos
+)
+print(df.columns.tolist())  # ['lam', 'rho', 'L', 'Lq', 'W', 'Wq', ...]
+
+# Barrido sobre μ
+df2 = wl.sensitivity(wl.mm1, "mu", np.linspace(4.0, 10.0, 15), lam=3.0)
+
+# Barrido sobre número de servidores en M/M/c
+df3 = wl.sensitivity(wl.mmc, "c", range(1, 6), lam=8.0, mu=5.0)
+
+# Visualizar
+from walopy.plotting import plot_sensitivity
+fig = plot_sensitivity(df, "lam", metrics=["Wq", "Lq"])
+fig.show()
 ```
 
 ---
 
-### Flow-shop de 2 máquinas — `johnson_flowshop`
+## 19. Escenarios en lote (batch_model)
 
-El algoritmo de Johnson encuentra la secuencia óptima que minimiza el makespan cuando todos los trabajos pasan primero por M1 y luego por M2.
+### `batch_model(model_fn, df, **fixed_kwargs)` — Aplicar modelo a un DataFrame
+
+Aplica cualquier función de walopy a cada fila de un DataFrame de escenarios.
 
 ```python
-m1 = [3, 8, 5, 7, 2]   # tiempos en máquina 1
-m2 = [5, 2, 8, 4, 6]   # tiempos en máquina 2
+import pandas as pd
 
-r = wl.johnson_flowshop(m1, m2)
-print(r)
-```
+# Varios escenarios con distintas tasas de llegada
+escenarios = pd.DataFrame({
+    "lam": [1.0, 2.0, 3.0, 4.0]
+})
+resultado = wl.batch_model(wl.mm1, escenarios, mu=5.0)
+print(resultado[["lam", "rho", "Wq", "L"]])
 
-```
-Sequence : J1 → J5 → J4 → J3 → J2
-Makespan : 34
-```
+# Escenarios mixtos (lambda y mu variables)
+escenarios2 = pd.DataFrame({
+    "lam": [2.0, 3.0, 4.0],
+    "mu":  [5.0, 6.0, 7.0],
+})
+resultado2 = wl.batch_model(wl.mm1, escenarios2)
 
-```python
-df = r.to_frame()
-# columnas: Job | M1 start | M1 end | M2 start | M2 end
+# Con número de servidores variable (columna int)
+escenarios3 = pd.DataFrame({
+    "c": [1, 2, 3, 4],
+})
+resultado3 = wl.batch_model(wl.mmc, escenarios3, lam=8.0, mu=5.0)
+
+# Las filas con error quedan marcadas en "_error" (la columna solo existe si alguna fila falla;
+# aquí c=1 es inestable porque λ=8 > μ=5)
+print(resultado3[resultado3["_error"].notna()])  # filas fallidas
+
+# Para que la primera excepción se propague en lugar de recogerse:
+# wl.batch_model(wl.mmc, escenarios3, errors="raise", lam=8.0, mu=5.0)
 ```
 
 ---
 
-## 14. Confiabilidad — `reliability`
+## 20. Comparar múltiples resultados
 
-Modelos de confiabilidad con distribución exponencial (tasa de falla constante).
+### `compare(*results, labels)` — DataFrame comparativo
 
-### Componente individual — `mtbf_analysis`
+Construye un DataFrame con una fila por resultado para facilitar la comparación.
 
 ```python
-r = wl.mtbf_analysis(failure_rate=0.01, mttr=5.0, t=100)
-print(r)
-```
+df = wl.compare(
+    wl.mm1(3.0, 5.0),
+    wl.mmc(3.0, 5.0, 2),
+    wl.md1(3.0, 5.0),
+    labels=["M/M/1", "M/M/2", "M/D/1"],
+)
+print(df[["label", "ρ (utilización)", "Wq (tiempo de espera)", "L (en el sistema)"]])
+#    label  ρ (utilización)  Wq (tiempo de espera)  L (en el sistema)
+# 0  M/M/1          0.6         0.3000         1.50
+# 1  M/M/2          0.3         0.0302         1.02
+# 2  M/D/1          0.6         0.1500         1.05
 
-```
-Topology        : component
-Components      : 1
-Failure rates λ : ['0.01']
-MTBF            : 100
-R(t=100)        : 0.367879
-Availability    : 95.2381%
+# Sin etiquetas → scenario_1, scenario_2, ...
+df2 = wl.compare(wl.mm1(1, 5), wl.mm1(2, 5), wl.mm1(3, 5))
 ```
 
-### Sistema en serie — `series_system`
+---
 
-El sistema falla si **cualquier** componente falla. λ_sys = Σλi.
+## 21. Gráficas
 
-```python
-r = wl.series_system([0.01, 0.02, 0.03], t=10)
-print(r.mtbf)      # 1/0.06 ≈ 16.67
-print(r.R_t)       # e^{-0.06·10} ≈ 0.549
-```
+Todos los resultados exponen `.plot()` que devuelve una figura de Matplotlib o Plotly. También se pueden llamar directamente desde `walopy.plotting`.
 
-### Sistema en paralelo — `parallel_system`
+| Función `.plot()` | Tipo | Descripción |
+|---|---|---|
+| `QueueResult.plot()` | Matplotlib | Curvas Wq y Lq vs ρ con punto operativo |
+| `OEEResult.plot()` | Matplotlib | Barras horizontales OEE con referencia 85% |
+| `BottleneckResult.plot()` | Matplotlib | Utilización por estación, cuello de botella en rojo |
+| `EOQResult.plot()` | Matplotlib | Curvas de costo de mantener, ordenar y total |
+| `LineBalanceResult.plot()` | Plotly | Tiempo de ciclo vs takt por estación |
+| `BreakEvenResult.plot()` | Plotly | Líneas ingreso/costo con BEP y zona de beneficio |
+| `SimulationResult.plot()` | Plotly | Histograma de Wq + CDF empírica con percentiles |
+| `OptimizeResult.plot()` | Plotly | Costo por servidor, costo de espera y total vs c |
+| `KPINode.plot(kind=)` | Plotly | Treemap o sunburst interactivo |
 
-El sistema opera si **al menos uno** de los componentes opera.  
-R_sys(t) = 1 − ∏(1 − e^{−λi·t}). MTBF calculado numéricamente.
+```python
+# Guardar como HTML interactivo (Plotly)
+fig = r.plot()
+fig.write_html("resultado.html")
 
+# Guardar como imagen (Matplotlib)
+fig = wl.oee(0.9, 0.8, 0.95).plot()
+fig.savefig("oee.png", dpi=150)
+```
+
+Para la curva de sensibilidad:
 ```python
-r = wl.parallel_system([0.01, 0.02], t=50)
-print(r.R_t)        # mayor que el sistema en serie
-print(r.mtbf)       # mayor que cualquier componente individual
+from walopy.plotting import plot_sensitivity
+df = wl.sensitivity(wl.mm1, "lam", np.linspace(0.5, 4.5, 20), mu=5.0)
+fig = plot_sensitivity(df, "lam", metrics=["Wq", "Lq", "L"])
+fig.show()
 ```
 
-### Sistema k-de-n — `koon_system`
+---
 
-Opera si al menos **k** de **n** componentes idénticos están en servicio.  
-MTBF exacto = (1/λ) · Σ_{j=k}^{n} (1/j).
+## 22. CLI
 
-```python
-# 2-de-3: requiere al menos 2 de 3 componentes idénticos
-r = wl.koon_system(n=3, k=2, failure_rate=0.01, t=50)
-print(r.mtbf)   # (1/0.01) * (1/2 + 1/3) ≈ 83.33
-print(r.R_t)
-```
+walopy incluye una interfaz de línea de comandos para uso rápido sin escribir código.
 
-**Casos especiales**
-- `k=1` → equivale a `parallel_system` con n componentes idénticos.
-- `k=n` → equivale a `series_system` con n componentes idénticos.
+```bash
+# M/M/1
+python -m walopy mm1 --lam 3 --mu 5
 
-**Atributos de `ReliabilityResult`**
+# M/M/c
+python -m walopy mmc --lam 8 --mu 5 --c 2
 
-| Atributo | Descripción |
-|----------|-------------|
-| `topology` | `'component'`, `'series'`, `'parallel'`, `'k-of-n'` |
-| `n_components` | Número de componentes |
-| `failure_rates` | Lista de λi |
-| `mtbf` | MTBF del sistema |
-| `R_t` | Confiabilidad R(t) si se proporcionó `t` |
-| `availability` | Disponibilidad estacionaria A si se proporcionó `mttr` |
-| `mttr` | Tiempo medio de reparación (si se proporcionó) |
+# M/D/1
+python -m walopy md1 --lam 3 --mu 5
 
-```python
-df = r.to_frame()   # columnas: Topology, Components, MTBF[, R(t), Availability]
-r.R(t=200)          # evalúa R(t) en cualquier tiempo posterior
+# G/G/1 (Kingman)
+python -m walopy gg1 --lam 3 --mu 5 --ca2 1.2 --cs2 0.8
+
+# Ley de Little (resolver W)
+python -m walopy littles --L 2.5 --lam 5.0
+
+# EOQ
+python -m walopy eoq --demand 1000 --ordering 50 --holding 2
+
+# Versión
+python -m walopy --version
+```
+
+Ejemplo de salida:
+```
+Modelo : M/M/1
+λ      : 3.0   (tasa de llegada)
+μ      : 5.0   (tasa de servicio por servidor)
+ρ      : 0.6   (utilización por servidor)
+L      : 1.5   (unidades promedio en el sistema)
+Lq     : 0.9   (unidades promedio en cola)
+W      : 0.5   (tiempo promedio en el sistema)
+Wq     : 0.3   (tiempo promedio de espera en cola)
+  P0      : 0.4
 ```
 
 ---
 
-## 22. Referencia de módulos
+## 23. Referencia de módulos
 
 | Módulo | Funciones y clases principales |
 |---|---|
 | `queuing` | `mm1`, `mmc`, `md1`, `kingman`, `mg1`, `littles_law`, `QueueResult`, `cv2_normal`, `cv2_triangular`, `cv2_uniform`, `cv2_erlang`, `cv2_gamma`, `cv2_lognormal`, `cv2_weibull` |
 | `advanced` | `mm1k`, `mmck`, `erlang_b`, `mm1_priority`, `monte_carlo_gg1`, `takt_time`, `line_balance`, `break_even`, `break_even_multi`, `break_even_sales`, `queue_length_pmf`, `sojourn_cdf`, `PriorityQueueResult`, `SimulationResult`, `LineBalanceResult`, `BreakEvenResult`, `BreakEvenMultiResult` |
 | `fitting` | `fit_from_data`, `FitResult` |
-| `inventory` | `eoq`, `ebq`, `eoq_multi`, `ebq_multi`, `eoq_multi_constrained`, `lot_for_lot`, `silver_meal`, `eoq_quantity_discount`, `wagner_whitin`, `rq_policy`, `rs_policy`, `exchange_curve`, `safety_stock_curve`, `reorder_point`, `newsvendor`, `EOQResult`, `EBQResult`, `MultiItemResult`, `ConstrainedMultiEOQResult`, `LotSizingResult`, `QuantityDiscountResult`, `ReorderResult`, `NewsvendorResult`, `RQPolicyResult`, `RSPolicyResult`, `ExchangeCurveResult`, `SafetyStockCurveResult` |
-| `scheduling` | `schedule_single`, `johnson_flowshop`, `ScheduleResult`, `JobSchedule`, `FlowShopResult` |
-| `reliability` | `mtbf_analysis`, `series_system`, `parallel_system`, `koon_system`, `ReliabilityResult` |
+| `inventory` | `eoq`, `ebq`, `eoq_multi`, `ebq_multi`, `eoq_multi_constrained`, `lot_for_lot`, `silver_meal`, `eoq_quantity_discount`, `wagner_whitin`, `rq_policy`, `rs_policy`, `exchange_curve`, `safety_stock_curve`, `abc_analysis`, `xyz_analysis`, `abc_xyz`, `mrp`, `reorder_point`, `newsvendor`, `EOQResult`, `EBQResult`, `MultiItemResult`, `ConstrainedMultiEOQResult`, `LotSizingResult`, `QuantityDiscountResult`, `ReorderResult`, `NewsvendorResult`, `RQPolicyResult`, `RSPolicyResult`, `ExchangeCurveResult`, `SafetyStockCurveResult`, `ABCResult`, `XYZResult`, `ABCXYZResult`, `MRPResult` |
+| `scheduling` | `schedule_single`, `johnson_flowshop`, `neh_flowshop`, `ScheduleResult`, `JobSchedule`, `FlowShopResult`, `NEHResult` |
+| `project` | `cpm`, `pert`, `ProjectResult`, `ActivityResult` |
+| `reliability` | `mtbf_analysis`, `series_system`, `parallel_system`, `koon_system`, `weibull_analysis`, `ReliabilityResult`, `WeibullResult` |
 | `network` | `jackson_network`, `JacksonResult`, `StationMetrics` |
 | `operations` | `oee`, `utilization_efficiency`, `unit_cost`, `OEEResult`, `UtilizationResult`, `UnitCostResult` |
 | `bottleneck` | `bottleneck_analysis`, `BottleneckResult`, `StationResult` |
@@ -1638,7 +1812,7 @@ r.R(t=200)          # evalúa R(t) en cualquier tiempo posterior
 
 ---
 
-## 23. Requisitos
+## 24. Requisitos
 
 ```
 Python ≥ 3.9