walopy 0.2.3__tar.gz → 0.2.6__tar.gz

{walopy-0.2.3/src/walopy.egg-info → walopy-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: walopy
-Version: 0.2.3
+Version: 0.2.6
 Summary: Queuing theory, operations analysis, OEE, bottleneck analysis and KPI trees for Python
 Author-email: LeoSanta15 <angelsanta1@gmail.com>
 License-Expression: MIT
@@ -63,15 +63,17 @@ pip install walopy
 9. [Análisis de cuellos de botella](#9-análisis-de-cuellos-de-botella)
 10. [Balance de línea y tiempo takt](#10-balance-de-línea-y-tiempo-takt)
 11. [Análisis de punto de equilibrio](#11-análisis-de-punto-de-equilibrio)
-12. [Árboles de KPI](#12-árboles-de-kpi)
-13. [Solvers y optimización](#13-solvers-y-optimización)
-14. [Análisis de sensibilidad](#14-análisis-de-sensibilidad)
-15. [Escenarios en lote (batch_model)](#15-escenarios-en-lote-batch_model)
-16. [Comparar múltiples resultados](#16-comparar-múltiples-resultados)
-17. [Gráficas](#17-gráficas)
-18. [CLI](#18-cli)
-19. [Referencia de módulos](#19-referencia-de-módulos)
-20. [Requisitos](#20-requisitos)
+12. [Programación de producción (scheduling)](#12-programación-de-producción-scheduling)
+13. [Confiabilidad](#13-confiabilidad--reliability)
+14. [Árboles de KPI](#14-árboles-de-kpi)
+15. [Solvers y optimización](#15-solvers-y-optimización)
+16. [Análisis de sensibilidad](#16-análisis-de-sensibilidad)
+17. [Escenarios en lote (batch_model)](#17-escenarios-en-lote-batch_model)
+18. [Comparar múltiples resultados](#18-comparar-múltiples-resultados)
+19. [Gráficas](#19-gráficas)
+20. [CLI](#20-cli)
+21. [Referencia de módulos](#21-referencia-de-módulos)
+22. [Requisitos](#22-requisitos)
 
 ---
 
@@ -200,6 +202,49 @@ r   = wl.kingman(**fit.to_model_kwargs())
 
 ---
 
+### `mg1(lam, mu, cs2)` — M/G/1 (Pollaczek-Khinchine exacto)
+
+Llegadas Poisson, servicio de **distribución arbitraria** parametrizado por su media (1/μ) y su variabilidad (cs²). La fórmula P-K es **exacta**, no una aproximación.
+
+**Fórmula P-K:**  
+Wq = λ · E[S²] / (2 · (1 − ρ)),   donde E[S²] = (1 + cs²) / μ²
+
+```python
+# Servicio con distribución triangular: calcular cs² primero
+cs2 = wl.cv2_triangular(a=2, m=5, b=10)   # a=mín, m=moda, b=máx
+r   = wl.mg1(lam=0.15, mu=1/5, cs2=cs2)
+
+# Equivalencia con M/M/1 (cs²=1) y M/D/1 (cs²=0)
+r_mm1 = wl.mg1(lam=3.0, mu=5.0, cs2=1.0)  # idéntico a mm1(3, 5)
+r_md1 = wl.mg1(lam=3.0, mu=5.0, cs2=0.0)  # idéntico a md1(3, 5)
+```
+
+#### Helpers `cv2_*` — CV² por distribución
+
+El CV² (varianza / media²) es el único parámetro de distribución que M/G/1 necesita:
+
+| Función | Distribución | CV² |
+|---|---|---|
+| `cv2_normal(mean, std)` | Normal | (σ/μ)² |
+| `cv2_triangular(a, m, b)` | Triangular | fórmula exacta |
+| `cv2_uniform(a, b)` | Uniforme | (b−a)² / (12·μ²) |
+| `cv2_erlang(k)` | Erlang-k | 1/k |
+| `cv2_gamma(shape)` | Gamma | 1/shape |
+| `cv2_lognormal(mean, std)` | Lognormal | (σ/μ)² |
+| `cv2_weibull(shape)` | Weibull | Γ(1+2/k)/Γ(1+1/k)²−1 |
+
+```python
+# Servicio con distribución Weibull de forma 2 (rayleigh)
+cs2 = wl.cv2_weibull(shape=2.0)      # ≈ 0.273
+r   = wl.mg1(lam=1.0, mu=2.0, cs2=cs2)
+print(r.Wq)   # tiempo medio de espera en cola
+
+# Servicio Erlang-3 (menos variable que exponencial)
+r = wl.mg1(lam=3.0, mu=5.0, cs2=wl.cv2_erlang(3))
+```
+
+---
+
 ### `littles_law(*, L, lam, W)` — Ley de Little
 
 Resuelve L = λ · W para la variable que falte. Exactamente uno de los tres parámetros debe ser `None`.
@@ -654,6 +699,204 @@ print(r_bajo.optimal_qty < 100)   # True
 
 ---
 
+### `ebq(demand_rate, setup_cost, holding_cost, production_rate)` — Lote Económico de Producción (EBQ/EPQ)
+
+Extiende el EOQ al caso en que la producción y el consumo ocurren **simultáneamente** (tasa de producción finita P > D).
+
+**Fórmula:**
+```
+Q* = √(2 · D · S / (h · (1 − D/P)))
+Inventario máximo = Q* · (1 − D/P)
+Inventario medio  = Inventario máximo / 2
+```
+
+```python
+r = wl.ebq(
+    demand_rate=1000,       # D: unidades/período
+    setup_cost=50,          # S: costo fijo de setup por lote
+    holding_cost=2,         # h: costo/unidad/período
+    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
+```
+
+**`EBQResult` — atributos:**
+
+| Atributo | Descripción |
+|---|---|
+| `ebq` | Lote óptimo Q* |
+| `max_inventory` | Nivel máximo de inventario Q*(1−D/P) |
+| `avg_inventory` | Inventario promedio = max/2 |
+| `production_time` | Tiempo de producción por ciclo = Q*/P |
+| `cycle_time` | Duración del ciclo = Q*/D |
+| `total_cost` | Costo total mínimo |
+
+---
+
+### `eoq_multi(demand_rates, ordering_costs, holding_costs, *, names)` — EOQ multi-ítem independiente
+
+Resuelve el EOQ para cada ítem por separado sin restricciones compartidas.
+
+```python
+r = wl.eoq_multi(
+    demand_rates   = [1000, 500, 800],
+    ordering_costs = [50,   30,  40 ],
+    holding_costs  = [2,    1,   1.5],
+    names          = ["A", "B", "C"],
+)
+print(r.total_cost)   # suma de costos óptimos individuales
+df = r.to_frame()     # DataFrame con EOQ, costos y frecuencias por ítem
+```
+
+---
+
+### `ebq_multi(demand_rates, setup_costs, holding_costs, production_rates, *, names)` — EBQ multi-ítem independiente
+
+```python
+r = wl.ebq_multi(
+    demand_rates    = [1000, 500],
+    setup_costs     = [50,   30 ],
+    holding_costs   = [2,    1  ],
+    production_rates= [4000, 2000],
+)
+df = r.to_frame()   # EBQ, inventario máximo/medio, costo por ítem
+```
+
+---
+
+### `eoq_multi_constrained(demand_rates, ordering_costs, holding_costs, ...)` — EOQ multi-ítem con restricciones
+
+Minimiza el costo total de inventario sujeto a **restricciones lineales** sobre las cantidades de pedido mediante **relajación Lagrangiana** (búsqueda binaria sobre el multiplicador).
+
+**Restricciones soportadas:**
+
+| Parámetro | Restricción |
+|---|---|
+| `budget`, `budget_unit_costs` | Σ(c_i · Q_i / 2) ≤ budget — valor promedio en inventario |
+| `space`, `space_per_unit` | Σ(s_i · Q_i / 2) ≤ space — espacio promedio ocupado |
+| `constraints` | Lista de `{"name", "weights", "bound"}` — Σ(a_i · Q_i) ≤ B |
+
+```python
+# Restricción de presupuesto
+r = wl.eoq_multi_constrained(
+    [1000, 500, 800], [50, 30, 40], [2, 1, 1.5],
+    budget=5000,
+    budget_unit_costs=[10, 8, 12],   # costo unitario de compra
+)
+print(r.binding_constraints)   # ["budget"] si la restricción está activa
+print(r.lagrange_multipliers)  # {"budget": λ}
+df = r.to_frame()              # Q*, holding cost, ordering cost por ítem
+
+# Restricción de espacio
+r2 = wl.eoq_multi_constrained(
+    [1000, 500, 800], [50, 30, 40], [2, 1, 1.5],
+    space=200,
+    space_per_unit=[0.5, 0.3, 0.4],
+)
+
+# Restricción genérica: suma total de unidades pedidas ≤ 400
+r3 = wl.eoq_multi_constrained(
+    [1000, 500, 800], [50, 30, 40], [2, 1, 1.5],
+    constraints=[{"name": "total_qty", "weights": [1, 1, 1], "bound": 400}],
+)
+```
+
+**`ConstrainedMultiEOQResult` — atributos:**
+
+| Atributo | Descripción |
+|---|---|
+| `items` | Lista de dicts por ítem: nombre, Q*, costos |
+| `total_cost` | Costo total bajo las restricciones |
+| `unconstrained_total_cost` | Costo sin restricciones (cota inferior) |
+| `lagrange_multipliers` | Diccionario {nombre_restricción: λ} |
+| `binding_constraints` | Nombres de restricciones activas (λ > 0) |
+
+---
+
+### `lot_for_lot(demands, setup_cost, holding_cost)` — Lote por Lote
+
+Heurística de dimensionado dinámico: ordena **exactamente la demanda de cada período**. Minimiza el costo de almacenamiento (cero inventario en tránsito) a cambio de un setup por período.
+
+```python
+demands = [100, 80, 0, 120, 60]   # demandas por período
+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
+```
+
+---
+
+### `silver_meal(demands, setup_cost, holding_cost)` — Silver-Meal
+
+Heurística de dimensionado dinámico que **agrupa períodos** mientras el costo promedio por período decrece, reduciendo el número de setups.
+
+```python
+r = wl.silver_meal(demands, setup_cost=200, holding_cost=1)
+print(r.total_cost <= wl.lot_for_lot(demands, 200, 1).total_cost)  # True
+df = r.to_frame()   # pedidos: período, cantidad, períodos cubiertos
+```
+
+**`LotSizingResult` — atributos (Lot-for-Lot y Silver-Meal):**
+
+| Atributo | Descripción |
+|---|---|
+| `orders` | Lista de pedidos: período, cantidad, períodos cubiertos |
+| `total_cost` | Costo total (setup + almacenamiento) |
+| `total_setup_cost` | Costo total de setups |
+| `total_holding_cost` | Costo total de almacenamiento |
+| `n_orders` | Número de pedidos emitidos |
+| `method` | Nombre de la heurística usada |
+
+---
+
+### `eoq_quantity_discount(demand_rate, ordering_cost, holding_cost_rate, price_breaks)` — EOQ con descuentos por cantidad
+
+Evalúa todos los tramos de precio (all-units) y selecciona la cantidad que **minimiza el costo total anual** (compra + pedido + almacenamiento), ajustando el EOQ al tramo válido cuando cae fuera de rango.
+
+```python
+r = wl.eoq_quantity_discount(
+    demand_rate=1000,
+    ordering_cost=50,
+    holding_cost_rate=0.20,   # 20% del precio unitario por año
+    price_breaks=[
+        (0,    10.00),   # precio base
+        (500,   9.50),   # ≥ 500 unidades → $9.50
+        (1000,  9.00),   # ≥ 1000 unidades → $9.00
+    ],
+)
+print(r.optimal_qty)    # cantidad óptima seleccionada
+print(r.unit_price)     # precio en ese tramo
+print(r.total_cost)     # costo anual mínimo
+df = r.to_frame()       # todos los candidatos evaluados
+```
+
+**`QuantityDiscountResult` — atributos:**
+
+| Atributo | Descripción |
+|---|---|
+| `optimal_qty` | Cantidad óptima ajustada al tramo |
+| `unit_price` | Precio unitario en el tramo seleccionado |
+| `total_cost` | Costo total anual (compra + pedido + almacenamiento) |
+| `purchase_cost` | Costo de compra anual D · precio |
+| `ordering_cost_total` | Costo de pedido anual (D/Q) · K |
+| `holding_cost_total` | Costo de almacenamiento anual (Q/2) · h · precio |
+| `candidates` | Lista de todos los tramos evaluados |
+
+---
+
 ## 8. Análisis de operaciones
 
 ### `oee(availability, performance, quality)` — OEE
@@ -762,9 +1005,59 @@ print(be.profit)                 # 5000.0 — beneficio con actual_units
 be.plot()   # líneas de ingresos/costos con BEP y zona de beneficio
 ```
 
+### `break_even_multi(fixed_cost, prices, variable_costs, sales_mix)` — Multi-producto
+
+Calcula el punto de equilibrio para una mezcla de varios productos usando la **contribución marginal ponderada (WACM)**.
+
+**Fórmula:** WACM = Σ(CMᵢ × mixᵢ) / Σmixᵢ, luego BEP_total = FC / WACM
+
+```python
+r = wl.break_even_multi(
+    fixed_cost=120_000,
+    prices=[50, 80, 120],
+    variable_costs=[30, 50, 70],
+    sales_mix=[3, 2, 1],          # proporción de ventas
+)
+print(r.weighted_avg_cm)          # WACM ≈ 36.67
+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"])
+
+r.to_frame()    # DataFrame con una fila por producto
+```
+
+| Atributo | Descripción |
+|---|---|
+| `weighted_avg_cm` | Contribución marginal ponderada |
+| `bep_units_total` | Unidades totales en el BEP |
+| `bep_revenue_total` | Ingresos totales en el BEP |
+| `items` | Lista de dicts por producto con `BEP units`, `BEP revenue` |
+
+---
+
+### `break_even_sales(fixed_cost, variable_cost_ratio, *, actual_revenue)` — Punto de equilibrio en ingresos
+
+Calcula el BEP en términos de ingresos cuando los costos variables se expresan como porcentaje de las ventas.
+
+**Fórmula:** BEP = FC / (1 − RCV)
+
+```python
+r = wl.break_even_sales(
+    fixed_cost=50_000,
+    variable_cost_ratio=0.60,     # 60% de los ingresos son costos variables
+    actual_revenue=200_000,
+)
+print(r.bep_revenue)              # 125 000 — ingresos en el BEP
+print(r.contribution_margin_ratio) # 0.40 — margen de contribución
+print(r.margin_of_safety_units)   # 75 000 — margen de seguridad en ingresos
+print(r.margin_of_safety_pct)     # 0.375 — porcentaje del margen de seguridad
+```
+
 ---
 
-## 12. Árboles de KPI
+## 14. Árboles de KPI
 
 Los árboles de KPI crean jerarquías interactivas visualizadas como **treemap** o **sunburst** con Plotly.
 
@@ -817,7 +1110,7 @@ fig.show()
 
 ---
 
-## 13. Solvers y optimización
+## 15. Solvers y optimización
 
 ### `solve_lam(metric, target, *, mu, model)` — Máxima tasa de llegada
 
@@ -864,7 +1157,7 @@ r.plot()   # gráfica de costo vs número de servidores
 
 ---
 
-## 14. Análisis de sensibilidad
+## 16. Análisis de sensibilidad
 
 ### `sensitivity(model_fn, param, values, **fixed_kwargs)` — Barrido paramétrico
 
@@ -895,7 +1188,7 @@ fig.show()
 
 ---
 
-## 15. Escenarios en lote (batch_model)
+## 17. Escenarios en lote (batch_model)
 
 ### `batch_model(model_fn, df, **fixed_kwargs)` — Aplicar modelo a un DataFrame
 
@@ -930,7 +1223,7 @@ print(resultado[resultado["_error"].notna()])  # filas fallidas
 
 ---
 
-## 16. Comparar múltiples resultados
+## 18. Comparar múltiples resultados
 
 ### `compare(*results, labels)` — DataFrame comparativo
 
@@ -955,7 +1248,7 @@ df2 = wl.compare(wl.mm1(1, 5), wl.mm1(2, 5), wl.mm1(3, 5))
 
 ---
 
-## 17. Gráficas
+## 19. Gráficas
 
 Todos los resultados exponen `.plot()` que devuelve una figura de Matplotlib o Plotly. También se pueden llamar directamente desde `walopy.plotting`.
 
@@ -991,7 +1284,7 @@ fig.show()
 
 ---
 
-## 18. CLI
+## 20. CLI
 
 walopy incluye una interfaz de línea de comandos para uso rápido sin escribir código.
 
@@ -1033,14 +1326,175 @@ Wq    : 0.3   (avg wait time in queue)
 
 ---
 
-## 19. Referencia de módulos
+## 12. Programación de producción (scheduling)
+
+### Máquina única — `schedule_single`
+
+Asigna *n* trabajos a una sola máquina según una regla de prioridad.
+
+```python
+import walopy as wl
+
+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
+
+r = wl.schedule_single(p, rule="SPT", due_dates=d, weights=w,
+                        names=["A","B","C","D","E"])
+print(r)
+```
+
+```
+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
+```
+
+**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) | — |
+
+**Atributos de `ScheduleResult`**
+
+| 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
+df = r.to_frame()  # columnas: Name, p, d, w, Start, C, L, T, Tardy
+```
+
+---
+
+### Flow-shop de 2 máquinas — `johnson_flowshop`
+
+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)
+```
+
+```
+Sequence : J1 → J5 → J4 → J3 → J2
+Makespan : 34
+```
+
+```python
+df = r.to_frame()
+# columnas: Job | M1 start | M1 end | M2 start | M2 end
+```
+
+---
+
+## 13. Confiabilidad — `reliability`
+
+Modelos de confiabilidad con distribución exponencial (tasa de falla constante).
+
+### Componente individual — `mtbf_analysis`
+
+```python
+r = wl.mtbf_analysis(failure_rate=0.01, mttr=5.0, t=100)
+print(r)
+```
+
+```
+Topology        : component
+Components      : 1
+Failure rates λ : ['0.01']
+MTBF            : 100
+R(t=100)        : 0.367879
+Availability    : 95.2381%
+```
+
+### Sistema en serie — `series_system`
+
+El sistema falla si **cualquier** componente falla. λ_sys = Σλi.
+
+```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
+```
+
+### Sistema en paralelo — `parallel_system`
+
+El sistema opera si **al menos uno** de los componentes opera.  
+R_sys(t) = 1 − ∏(1 − e^{−λi·t}). MTBF calculado numéricamente.
+
+```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
+```
+
+### 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).
+
+```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)
+```
+
+**Casos especiales**
+- `k=1` → equivale a `parallel_system` con n componentes idénticos.
+- `k=n` → equivale a `series_system` con n componentes idénticos.
+
+**Atributos de `ReliabilityResult`**
+
+| 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ó) |
+
+```python
+df = r.to_frame()   # columnas: Topology, Components, MTBF[, R(t), Availability]
+r.R(t=200)          # evalúa R(t) en cualquier tiempo posterior
+```
+
+---
+
+## 21. Referencia de módulos
 
 | Módulo | Funciones y clases principales |
 |---|---|
-| `queuing` | `mm1`, `mmc`, `md1`, `kingman`, `littles_law`, `QueueResult` |
-| `advanced` | `mm1k`, `mmck`, `erlang_b`, `mm1_priority`, `monte_carlo_gg1`, `takt_time`, `line_balance`, `break_even`, `queue_length_pmf`, `sojourn_cdf`, `PriorityQueueResult`, `SimulationResult`, `LineBalanceResult`, `BreakEvenResult` |
+| `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`, `reorder_point`, `newsvendor`, `EOQResult`, `ReorderResult`, `NewsvendorResult` |
+| `inventory` | `eoq`, `ebq`, `eoq_multi`, `ebq_multi`, `eoq_multi_constrained`, `lot_for_lot`, `silver_meal`, `eoq_quantity_discount`, `wagner_whitin`, `rq_policy`, `rs_policy`, `reorder_point`, `newsvendor`, `EOQResult`, `EBQResult`, `MultiItemResult`, `ConstrainedMultiEOQResult`, `LotSizingResult`, `QuantityDiscountResult`, `ReorderResult`, `NewsvendorResult`, `RQPolicyResult`, `RSPolicyResult` |
+| `scheduling` | `schedule_single`, `johnson_flowshop`, `ScheduleResult`, `JobSchedule`, `FlowShopResult` |
+| `reliability` | `mtbf_analysis`, `series_system`, `parallel_system`, `koon_system`, `ReliabilityResult` |
 | `network` | `jackson_network`, `JacksonResult`, `StationMetrics` |
 | `operations` | `oee`, `utilization_efficiency`, `unit_cost`, `OEEResult`, `UtilizationResult`, `UnitCostResult` |
 | `bottleneck` | `bottleneck_analysis`, `BottleneckResult`, `StationResult` |
@@ -1050,7 +1504,7 @@ Wq    : 0.3   (avg wait time in queue)
 
 ---
 
-## 20. Requisitos
+## 22. Requisitos
 
 ```
 Python ≥ 3.9