walopy 0.4.3__tar.gz → 0.4.4__tar.gz

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

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

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

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

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

@@ -39,6 +39,7 @@ EN: dict[str, str] = {
     "advanced.error.mm1_priority.sistema_inestable_total": "Unstable system: ρ_total = {rho_total:.4g} ≥ 1.",
     "advanced.error.mmck.capacidad_sistema_debe_ser_servidores": "'K' (system capacity) must be ≥ c (servers); got K={K}, c={c}.",
     "advanced.error.monte_carlo_gg1.sistema_inestable": "Unstable system: ρ = {rho:.4g} ≥ 1.",
+    "advanced.aviso.monte_carlo_gg1.estimacion_imprecisa": "The estimate Wq = {wq:.4g} has a 95 % half-width of ±{semiancho:.3g} ({relativo:.0%}) (means of 20 batches) with {n} customers: increase n_customers or average several replications (different seeds).",
     "advanced.error.queue_length_pmf.max_debe_estar_entre_recibio": "'n_max' must be between 0 and {MAX_ESTADOS}, got {n_max!r}.",
     "advanced.error.queue_length_pmf.max_debe_ser_entero_recibio": "'n_max' must be an integer >= 0, got {__name__!r}.",
     "advanced.etiqueta.summary.margen_contribucion": "Contribution margin          : {contribution_margin:.4g}",
@@ -231,6 +232,7 @@ EN: dict[str, str] = {
     "inventory.error.mrp.periods_debe_tener_misma_longitud": "'periods' must have the same length as 'gross_requirements'.",
     "inventory.error.mrp.scheduled_receipts_debe_tener_misma": "'scheduled_receipts' must have the same length as 'gross_requirements'.",
     "inventory.error.newsvendor.cost_debe_ser_menor_price": "'cost' must be less than 'price' (otherwise Cu ≤ 0).",
+    "inventory.aviso.newsvendor.demanda_normal_cv_alto": "The normal demand has CV = {cv:.2f} > 0.5: the model assigns P(D < 0) = {p_negativa:.1%} and Q* may be biased. With such variable demand a non-negative distribution (lognormal, gamma or empirical) is preferable.",
     "inventory.error.newsvendor.salvage_debe_ser_menor_cost": "'salvage' must be less than 'cost' (otherwise Co ≤ 0).",
     "inventory.error.reorder_point.service_level_debe_estar_estrictamente": "'service_level' must be strictly between 0 and 1.",
     "inventory.error.safety_stock_curve.indique_como_maximo_uno_target": "Provide at most one of 'target_service_level' or 'target_ss_investment'.",
@@ -483,6 +485,7 @@ EN: dict[str, str] = {
     "project.error.leer_actividades.activities_predecessors_debe_ser_lista": "activities[{i}]['predecessors'] must be a list of names.",
     "project.error.leer_actividades.nombre_actividad_duplicado_cada_actividad": "Duplicate activity name: '{nm}'. Each activity must have a unique name.",
     "project.error.pert.actividad_falta_clave": "Activity '{nm}': missing key '{clave}'.",
+    "project.aviso.pert.rutas_casi_criticas": "{n} activities outside the critical path used have total float ≤ the project σ ({sigma:.3g}): {actividades}. The PERT probability considers a single path and is optimistic when other near-critical paths merge; consider a Monte Carlo simulation.",
     "project.error.pert.actividad_requiere_optimistic_most_likely": "Activity '{nm}': optimistic ≤ most_likely ≤ pessimistic is required.",
     "project.error.probability.probability_requiere_resultado_pert_varianza": "probability() requires a PERT result with nonzero variance.",
     "project.error.toposort_and_succ.actividad_referencia_predecesor_desconocido": "Activity '{name}' references an unknown predecessor '{pred}'.",

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

@@ -39,6 +39,7 @@ ES: dict[str, str] = {
     "advanced.error.mm1_priority.sistema_inestable_total": "Sistema inestable: ρ_total = {rho_total:.4g} ≥ 1.",
     "advanced.error.mmck.capacidad_sistema_debe_ser_servidores": "'K' (capacidad del sistema) debe ser ≥ c (servidores); se recibió K={K}, c={c}.",
     "advanced.error.monte_carlo_gg1.sistema_inestable": "Sistema inestable: ρ = {rho:.4g} ≥ 1.",
+    "advanced.aviso.monte_carlo_gg1.estimacion_imprecisa": "La estimación Wq = {wq:.4g} tiene un semiancho de ±{semiancho:.3g} ({relativo:.0%}) al 95 % (medias de 20 lotes) con {n} clientes: aumente n_customers o promedie varias réplicas (seed distintas).",
     "advanced.error.queue_length_pmf.max_debe_estar_entre_recibio": "'n_max' debe estar entre 0 y {MAX_ESTADOS}, se recibió {n_max!r}.",
     "advanced.error.queue_length_pmf.max_debe_ser_entero_recibio": "'n_max' debe ser un entero >= 0, se recibió {__name__!r}.",
     "advanced.etiqueta.summary.margen_contribucion": "Margen de contribución        : {contribution_margin:.4g}",
@@ -231,6 +232,7 @@ ES: dict[str, str] = {
     "inventory.error.mrp.periods_debe_tener_misma_longitud": "'periods' debe tener la misma longitud que 'gross_requirements'.",
     "inventory.error.mrp.scheduled_receipts_debe_tener_misma": "'scheduled_receipts' debe tener la misma longitud que 'gross_requirements'.",
     "inventory.error.newsvendor.cost_debe_ser_menor_price": "'cost' debe ser menor que 'price' (de lo contrario Cu ≤ 0).",
+    "inventory.aviso.newsvendor.demanda_normal_cv_alto": "La demanda normal tiene CV = {cv:.2f} > 0,5: el modelo asigna P(D < 0) = {p_negativa:.1%} y Q* puede estar sesgada. Con demanda tan variable conviene una distribución no negativa (lognormal, gamma o empírica).",
     "inventory.error.newsvendor.salvage_debe_ser_menor_cost": "'salvage' debe ser menor que 'cost' (de lo contrario Co ≤ 0).",
     "inventory.error.reorder_point.service_level_debe_estar_estrictamente": "'service_level' debe estar estrictamente entre 0 y 1.",
     "inventory.error.safety_stock_curve.indique_como_maximo_uno_target": "Indique como máximo uno de 'target_service_level' o 'target_ss_investment'.",
@@ -483,6 +485,7 @@ ES: dict[str, str] = {
     "project.error.leer_actividades.activities_predecessors_debe_ser_lista": "activities[{i}]['predecessors'] debe ser una lista de nombres.",
     "project.error.leer_actividades.nombre_actividad_duplicado_cada_actividad": "Nombre de actividad duplicado: '{nm}'. Cada actividad debe tener un nombre único.",
     "project.error.pert.actividad_falta_clave": "Actividad '{nm}': falta la clave '{clave}'.",
+    "project.aviso.pert.rutas_casi_criticas": "Hay {n} actividades fuera de la ruta crítica usada con holgura ≤ σ del proyecto ({sigma:.3g}): {actividades}. La probabilidad PERT solo considera una ruta y es optimista cuando otras rutas casi críticas convergen; considere una simulación Monte Carlo.",
     "project.error.pert.actividad_requiere_optimistic_most_likely": "Actividad '{nm}': se requiere optimistic ≤ most_likely ≤ pessimistic.",
     "project.error.probability.probability_requiere_resultado_pert_varianza": "probability() requiere un resultado PERT con varianza distinta de cero.",
     "project.error.toposort_and_succ.actividad_referencia_predecesor_desconocido": "La actividad '{name}' referencia un predecesor desconocido '{pred}'.",

{walopy-0.4.3 → walopy-0.4.4}/src/walopy/advanced.py

@@ -2,6 +2,7 @@
 from __future__ import annotations
 
 import math
+import warnings
 from collections.abc import Sequence
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING
@@ -226,6 +227,11 @@ class SimulationResult:
         return plot_simulation(self, **kwargs)
 
 
+LOTES_MC = 20             # lotes para el intervalo de confianza de Wq por medias de lotes
+T_975_19 = 2.093          # cuantil 0,975 de la t de Student con 19 grados de libertad
+PRECISION_RELATIVA_MC = 0.10  # avisar si el semiancho al 95 % supera el 10 % de Wq
+
+
 def monte_carlo_gg1(
     lam: float,
     mu: float,
@@ -271,9 +277,9 @@ def monte_carlo_gg1(
 
     Examples
     --------
-    >>> r = monte_carlo_gg1(lam=2.0, mu=3.0, ca2=1.0, cs2=1.0, n_customers=500, seed=1)
+    >>> r = monte_carlo_gg1(lam=2.0, mu=3.0, ca2=1.0, cs2=1.0, n_customers=50_000, seed=1)
     >>> round(r.L, 4)
-    2.0427
+    2.0169
     """
     lam         = as_positive(lam, "lam")
     mu          = as_positive(mu, "mu")
@@ -311,6 +317,17 @@ def monte_carlo_gg1(
     sojourn    = depart - arrival
     pct        = np.percentile(wait, [50, 90, 95, 99])
 
+    # Precisión de Wq por medias de lotes (20 lotes, t de Student con 19 g.l. al 95 %); una sola réplica puede engañar
+    lotes = wait[: n_customers - n_customers % LOTES_MC].reshape(LOTES_MC, -1).mean(axis=1) if n_customers >= LOTES_MC else None
+    if lotes is not None and wait.mean() > 0:
+        semiancho = T_975_19 * float(lotes.std(ddof=1)) / math.sqrt(LOTES_MC)
+        if semiancho > PRECISION_RELATIVA_MC * wait.mean():
+            warnings.warn(
+                _t("advanced.aviso.monte_carlo_gg1.estimacion_imprecisa", wq=float(wait.mean()), semiancho=semiancho,
+                   relativo=semiancho / float(wait.mean()), n=n_customers),
+                UserWarning, stacklevel=2,
+            )
+
     return SimulationResult(
         model=_t("advanced.modelo.monte_carlo_gg1.simulacion_ca2_cs2", ca2=ca2, cs2=cs2),
         lam=lam,

{walopy-0.4.3 → walopy-0.4.4}/src/walopy/inventory.py

@@ -253,12 +253,14 @@ def reorder_point(
     lead_time : float
         Tiempo de entrega medio L̄ (en las mismas unidades de tiempo que demand_rate).
     demand_std : float
-        Desviación estándar de la demanda por periodo σ_D (por defecto 0).
+        Desviación estándar de la demanda por periodo σ_D (por defecto 0). Si la demanda se pronostica, use la
+        desviación del error de pronóstico por periodo (p. ej. el RMSE), que es la incertidumbre que cubre el stock
+        de seguridad.
     lead_time_std : float
         Desviación estándar del tiempo de entrega σ_L (por defecto 0).
     service_level : float
-        Probabilidad de no tener faltante por ciclo de reposición ∈ (0, 1).
-        Por defecto 0.95.
+        Nivel de servicio por ciclo (tipo 1): probabilidad de no tener faltante en un ciclo de reposición ∈ (0, 1).
+        No es la tasa de llenado (fracción de la demanda servida desde inventario), que suele ser mayor. Por defecto 0.95.
 
     Returns
     -------
@@ -368,6 +370,9 @@ class NewsvendorResult:
         }])
 
 
+CV_MAX_NEWSVENDOR_NORMAL = 0.5  # con CV = σ/μ > 0,5 la normal da P(D < 0) > 2,3 %
+
+
 def newsvendor(
     demand_mean: float,
     demand_std: float,
@@ -425,6 +430,13 @@ def newsvendor(
     if s >= c:
         raise ValueError(_t("inventory.error.newsvendor.salvage_debe_ser_menor_cost"))
 
+    if sig > CV_MAX_NEWSVENDOR_NORMAL * mu:
+        # La normal asigna probabilidad apreciable a demanda negativa: Q* y las ventas esperadas pierden sentido
+        warnings.warn(
+            _t("inventory.aviso.newsvendor.demanda_normal_cv_alto", cv=sig / mu, p_negativa=NormalDist().cdf(-mu / sig)),
+            UserWarning, stacklevel=2,
+        )
+
     Cu = p - c          # underage cost (opportunity loss)
     Co = c - s          # overage cost  (holding/disposal loss)
     CR = Cu / (Cu + Co) # critical ratio
@@ -1587,11 +1599,14 @@ def rq_policy(
     lead_time : float
         Tiempo de entrega medio de reposición L̄.
     demand_std : float
-        Desviación estándar de la demanda por periodo σ_D (por defecto 0).
+        Desviación estándar de la demanda por periodo σ_D (por defecto 0). Si la demanda se pronostica, use la
+        desviación del error de pronóstico por periodo (p. ej. el RMSE), que es la incertidumbre que cubre el stock
+        de seguridad.
     lead_time_std : float
         Desviación estándar del tiempo de entrega σ_L (por defecto 0).
     service_level : float
-        Nivel de servicio por ciclo ∈ (0, 1). Por defecto 0.95.
+        Nivel de servicio por ciclo (tipo 1): probabilidad de no tener faltante en un ciclo de reposición ∈ (0, 1).
+        No es la tasa de llenado (fracción de la demanda servida desde inventario), que suele ser mayor. Por defecto 0.95.
 
     Returns
     -------
@@ -1730,11 +1745,14 @@ def rs_policy(
     review_period : float
         Intervalo de revisión R (periodos entre revisiones de inventario).
     demand_std : float
-        Desviación estándar de la demanda por periodo σ_D (por defecto 0).
+        Desviación estándar de la demanda por periodo σ_D (por defecto 0). Si la demanda se pronostica, use la
+        desviación del error de pronóstico por periodo (p. ej. el RMSE), que es la incertidumbre que cubre el stock
+        de seguridad.
     lead_time_std : float
         Desviación estándar del tiempo de entrega σ_L (por defecto 0).
     service_level : float
-        Nivel de servicio por ciclo ∈ (0, 1). Por defecto 0.95.
+        Nivel de servicio por ciclo (tipo 1): probabilidad de no tener faltante en un ciclo de reposición ∈ (0, 1).
+        No es la tasa de llenado (fracción de la demanda servida desde inventario), que suele ser mayor. Por defecto 0.95.
 
     Returns
     -------
@@ -2078,7 +2096,8 @@ def safety_stock_curve(
     items : list of dict
         Cada diccionario debe contener:
 
-        - ``demand_std`` (float) — desviación estándar de la demanda por unidad de tiempo.
+        - ``demand_std`` (float) — desviación estándar de la demanda por unidad de tiempo (o del error de
+          pronóstico, si la demanda se pronostica).
         - ``lead_time`` (float) — tiempo de entrega de reposición (misma unidad de tiempo).
 
         Claves opcionales:

{walopy-0.4.3 → walopy-0.4.4}/src/walopy/project.py

@@ -2,6 +2,7 @@
 from __future__ import annotations
 
 import math
+import warnings
 from collections import deque
 from dataclasses import dataclass
 from statistics import NormalDist
@@ -211,6 +212,33 @@ def _forward_backward(acts: dict, durations: dict) -> tuple:
     return ES, EF, LS, LF, T, succ
 
 
+def _ruta_critica_de_mayor_varianza(acts: dict, crit: list, variances: dict, ES: dict, EF: dict, T: float) -> tuple:
+    """Ruta crítica (de inicio a fin) con la mayor varianza y esa varianza.
+
+    Con varias rutas críticas empatadas, la varianza del proyecto es la de **una** ruta (la convención es la de mayor
+    varianza), no la suma de todas las actividades críticas.
+    """
+    criticas = set(crit)
+    mejor: dict[str, float] = {}
+    previa: dict[str, str | None] = {}
+    for nm in [n for n in _toposort_and_succ(acts)[0] if n in criticas]:
+        candidatas = [p for p in acts[nm]["predecessors"] if p in criticas and abs(EF[p] - ES[nm]) < 1e-9]
+        p_max = max(candidatas, key=lambda p: mejor[p], default=None)
+        mejor[nm] = variances[nm] + (mejor[p_max] if p_max is not None else 0.0)
+        previa[nm] = p_max
+    finales = [nm for nm in mejor if abs(EF[nm] - T) < 1e-9]
+    if not finales:
+        return [], 0.0
+    final = max(finales, key=lambda n: mejor[n])
+    varianza = mejor[final]
+    nodo: str | None = final
+    ruta: list[str] = []
+    while nodo is not None:
+        ruta.append(nodo)
+        nodo = previa[nodo]
+    return ruta[::-1], varianza
+
+
 def _build_results(acts: dict, durations: dict, ES, EF, LS, LF, T, succ,
                    opt=None, ml=None, pess=None, variances=None) -> list:
     results = []
@@ -382,7 +410,14 @@ def pert(activities: list) -> ProjectResult:
     results = _build_results(acts, durations, ES, EF, LS, LF, T, succ,
                              opt=opt_d, ml=ml_d, pess=pess_d, variances=variances)
     crit     = [a.name for a in results if a.is_critical]
-    proj_var = sum(variances[nm] for nm in crit)
+    ruta, proj_var = _ruta_critica_de_mayor_varianza(acts, crit, variances, ES, EF, T)
+    sigma = math.sqrt(proj_var)
+    casi_criticas = [a.name for a in results if a.name not in ruta and a.total_float <= sigma + 1e-9]
+    if sigma > 0 and casi_criticas:
+        warnings.warn(
+            _t("project.aviso.pert.rutas_casi_criticas", n=len(casi_criticas), actividades=", ".join(casi_criticas[:5]), sigma=sigma),
+            UserWarning, stacklevel=2,
+        )
 
     return ProjectResult(
         activities=results,

{walopy-0.4.3 → walopy-0.4.4}/src/walopy/reliability.py

@@ -199,7 +199,8 @@ def series_system(
     t : float, optional
         Tiempo para evaluar R(t).
     mttr : float, optional
-        Tiempo medio de reparación para calcular la disponibilidad.
+        Tiempo medio de reparación. Disponibilidad A = MTBF / (MTBF + MTTR) del sistema: mientras se repara el
+        componente que falló el sistema está detenido y los demás no fallan.
 
     Returns
     -------
@@ -237,6 +238,11 @@ def series_system(
     )
 
 
+def _disponibilidad_componente(lam: float, mttr: float) -> float:
+    """Disponibilidad en régimen de un componente reparable: MTBF / (MTBF + MTTR) = 1 / (1 + λ·MTTR)."""
+    return 1.0 / (1.0 + lam * mttr)
+
+
 def parallel_system(
     failure_rates: Sequence[float],
     *,
@@ -256,7 +262,9 @@ def parallel_system(
     t : float, optional
         Tiempo para evaluar R(t).
     mttr : float, optional
-        Tiempo medio de reparación para calcular la disponibilidad.
+        Tiempo medio de reparación de cada componente. La disponibilidad supone que cada componente se repara
+        en cuanto falla, de forma independiente: A = 1 − ∏(1 − Aᵢ), con Aᵢ = MTBFᵢ / (MTBFᵢ + MTTR). El MTBF
+        del resultado es el tiempo medio hasta la falla del sistema sin reparación.
 
     Returns
     -------
@@ -283,7 +291,8 @@ def parallel_system(
         return _r_system("parallel", lams, None, tt)
 
     mtbf_val = _mtbf_numeric(R_func, min(lams))
-    avail = mtbf_val / (mtbf_val + mttr) if mttr is not None else None
+    # Disponibilidad en régimen con reparación independiente de cada componente: A = 1 − ∏(1 − Aᵢ)
+    avail = 1.0 - math.prod(1.0 - _disponibilidad_componente(lam, mttr) for lam in lams) if mttr is not None else None
     R_t = R_func(t) if t is not None else None
     return ReliabilityResult(
         topology="parallel",
@@ -326,7 +335,10 @@ def koon_system(
     t : float, optional
         Tiempo para evaluar R(t).
     mttr : float, optional
-        Tiempo medio de reparación para calcular la disponibilidad.
+        Tiempo medio de reparación de cada componente. La disponibilidad supone reparación independiente de cada
+        componente: A = Σ_{j=k}^{n} C(n,j)·aʲ·(1 − a)ⁿ⁻ʲ, con a = MTBF / (MTBF + MTTR) de un componente. El MTBF
+        del resultado es el tiempo medio hasta la falla del sistema sin reparación. Con k = n, ``series_system``
+        supone en cambio que los demás componentes no fallan mientras el sistema está detenido.
 
     Returns
     -------
@@ -357,7 +369,12 @@ def koon_system(
     # Exact MTBF for k-of-n identical exponential:  (1/λ) * Σ_{j=k}^{n} 1/j
     mtbf_val = (1.0 / lam) * sum(1.0 / j for j in range(k, n + 1))
 
-    avail = mtbf_val / (mtbf_val + mttr) if mttr is not None else None
+    if mttr is not None:
+        # Reparación independiente: cada componente está disponible con probabilidad a, y el sistema si funcionan ≥ k
+        a = _disponibilidad_componente(lam, mttr)
+        avail: float | None = sum(math.comb(n, j) * a**j * (1.0 - a) ** (n - j) for j in range(k, n + 1))
+    else:
+        avail = None
     R_t = _r_system("k-of-n", lams, k, t) if t is not None else None
     return ReliabilityResult(
         topology="k-of-n",

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

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

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

@@ -28,12 +28,14 @@ src/walopy.egg-info/requires.txt
 src/walopy.egg-info/top_level.txt
 tests/test_abc_xyz.py
 tests/test_advanced.py
+tests/test_avisos_validez.py
 tests/test_bottleneck.py
 tests/test_cli.py
 tests/test_complejidad.py
 tests/test_contrato_entradas.py
 tests/test_cpm_pert.py
 tests/test_dibujo_plotly.py
+tests/test_disponibilidad_redundante.py
 tests/test_documentacion.py
 tests/test_documentacion_ingles.py
 tests/test_ejemplos.py
@@ -55,6 +57,7 @@ tests/test_network.py
 tests/test_new_models.py
 tests/test_notas_release.py
 tests/test_operations.py
+tests/test_pert_varianza.py
 tests/test_plotting.py
 tests/test_politicas_inventario.py
 tests/test_propiedades_algoritmos.py

{walopy-0.4.3 → walopy-0.4.4}/tests/test_advanced.py

@@ -76,6 +76,7 @@ def test_monte_carlo_gg1_deterministic_service():
     assert r_sim.Wq_mean == pytest.approx(r_analytic.Wq, rel=0.05)
 
 
+@pytest.mark.filterwarnings("ignore::UserWarning")  # solo el orden de los percentiles; la precisión avisa aparte
 def test_monte_carlo_percentiles_ordered():
     r = monte_carlo_gg1(lam=3.0, mu=5.0, ca2=1.0, cs2=1.0,
                          n_customers=10_000, seed=7)

walopy-0.4.4/tests/test_avisos_validez.py

@@ -0,0 +1,46 @@
+"""Avisos de validez (0.4.4): el modelo se usa fuera del rango en que su resultado es fiable.
+
+* ``newsvendor`` con demanda normal y CV > 0,5: la normal asigna probabilidad apreciable a demanda negativa.
+* ``monte_carlo_gg1``: el semiancho al 95 % de Wq (medias de 20 lotes) supera el 10 %; una réplica puede engañar.
+* ``pert``: ver ``test_pert_varianza.py``.
+"""
+from __future__ import annotations
+
+import warnings
+
+import pytest
+
+import walopy as wl
+
+
+def test_newsvendor_avisa_con_cv_alto():
+    with pytest.warns(UserWarning) as avisos:
+        wl.newsvendor(20.0, 20.0, 10.0, 4.0)
+    assert "15.9%" in str(avisos[0].message) or "15,9" in str(avisos[0].message)  # P(D < 0) del modelo
+
+
+def test_newsvendor_no_avisa_con_cv_moderado():
+    with warnings.catch_warnings():
+        warnings.simplefilter("error")
+        wl.newsvendor(100.0, 30.0, 10.0, 4.0)
+        wl.newsvendor(100.0, 50.0, 10.0, 4.0)  # CV = 0,5 justo en el límite
+
+
+def test_simulacion_avisa_si_la_estimacion_es_imprecisa():
+    with pytest.warns(UserWarning) as avisos:
+        wl.monte_carlo_gg1(0.95, 1.0, 1.0, 1.0, n_customers=20_000, seed=1)
+    assert "n_customers" in str(avisos[0].message)
+
+
+def test_simulacion_no_avisa_si_la_estimacion_es_precisa():
+    with warnings.catch_warnings():
+        warnings.simplefilter("error")
+        wl.monte_carlo_gg1(2.0, 3.0, 1.0, 1.0, n_customers=50_000, seed=1)
+
+
+def test_el_aviso_no_cambia_el_resultado():
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore", UserWarning)
+        a = wl.monte_carlo_gg1(0.95, 1.0, 1.0, 1.0, n_customers=5_000, seed=3)
+        b = wl.newsvendor(20.0, 20.0, 10.0, 4.0)
+    assert a.Wq_mean > 0 and b.optimal_qty > 0

{walopy-0.4.3 → walopy-0.4.4}/tests/test_cpm_pert.py

@@ -119,34 +119,40 @@ def test_cpm_empty_raises():
 
 # ─── PERT ─────────────────────────────────────────────────────────────────────
 
+def _pert_red_de_prueba():
+    # A→C y B→D duran lo mismo (5): dos rutas críticas empatadas, así que pert avisa de rutas casi críticas
+    with pytest.warns(UserWarning):
+        return wl.pert(PERT_ACTS)
+
+
 def test_pert_returns_result():
-    r = wl.pert(PERT_ACTS)
+    r = _pert_red_de_prueba()
     assert isinstance(r, wl.ProjectResult)
 
 
 def test_pert_method():
-    r = wl.pert(PERT_ACTS)
+    r = _pert_red_de_prueba()
     assert r.method == "PERT"
 
 
 def test_pert_expected_duration():
-    r = wl.pert(PERT_ACTS)
+    r = _pert_red_de_prueba()
     assert r.project_duration == pytest.approx(5.0, abs=1e-9)
 
 
 def test_pert_has_variance():
-    r = wl.pert(PERT_ACTS)
+    r = _pert_red_de_prueba()
     assert r.project_variance is not None
     assert r.project_variance > 0
 
 
 def test_pert_std_is_sqrt_variance():
-    r = wl.pert(PERT_ACTS)
+    r = _pert_red_de_prueba()
     assert r.project_std == pytest.approx(math.sqrt(r.project_variance), rel=1e-9)
 
 
 def test_pert_activity_variance_formula():
-    r = wl.pert(PERT_ACTS)
+    r = _pert_red_de_prueba()
     for a in r.activities:
         if a.variance is not None:
             expected = ((a.pessimistic - a.optimistic) / 6.0) ** 2
@@ -154,12 +160,12 @@ def test_pert_activity_variance_formula():
 
 
 def test_pert_probability_below_mean_is_50pct():
-    r = wl.pert(PERT_ACTS)
+    r = _pert_red_de_prueba()
     assert r.probability(r.project_duration) == pytest.approx(0.5, abs=1e-6)
 
 
 def test_pert_probability_increases_with_target():
-    r = wl.pert(PERT_ACTS)
+    r = _pert_red_de_prueba()
     assert r.probability(r.project_duration + 1) > r.probability(r.project_duration)
 
 

walopy-0.4.4/tests/test_disponibilidad_redundante.py

@@ -0,0 +1,63 @@
+"""W-33: la disponibilidad de los sistemas redundantes suponía que nada se repara hasta que cae todo el sistema.
+
+``parallel_system`` y ``koon_system`` calculaban ``A = MTTF_sistema / (MTTF_sistema + MTTR)``: con dos componentes en paralelo
+(λ = 0,01, MTTR = 10) daban 0,9375, cuando con reparación independiente de cada componente es 1 − (1 − Aᵢ)² = 0,9917
+(8 veces menos indisponibilidad). Ahora se usa la disponibilidad en régimen con reparación independiente.
+"""
+from __future__ import annotations
+
+import math
+import random
+
+import pytest
+
+import walopy as wl
+
+
+def _a(lam: float, mttr: float) -> float:
+    return (1 / lam) / (1 / lam + mttr)
+
+
+def test_paralelo_de_dos_con_reparacion_independiente():
+    r = wl.parallel_system([0.01, 0.01], mttr=10.0)
+    assert r.availability == pytest.approx(1 - (1 - 100 / 110) ** 2)  # 0,9917; antes 0,9375
+
+
+def test_k_de_n_es_la_binomial_de_la_disponibilidad_de_cada_componente():
+    a = _a(0.01, 10.0)
+    r = wl.koon_system(n=3, k=2, failure_rate=0.01, mttr=10.0)
+    assert r.availability == pytest.approx(3 * a**2 * (1 - a) + a**3)
+
+
+@pytest.mark.parametrize("semilla", range(40))
+def test_paralelo_y_k_de_n_contra_formulas_independientes(semilla):
+    r = random.Random(3300 + semilla)
+    lams = [r.uniform(1e-4, 0.1) for _ in range(r.randint(2, 5))]
+    mttr = r.uniform(0.1, 50)
+    esperado = 1 - math.prod(1 - _a(x, mttr) for x in lams)
+    assert wl.parallel_system(lams, mttr=mttr).availability == pytest.approx(esperado, rel=1e-12)
+    n = r.randint(2, 6)
+    k = r.randint(1, n - 1)
+    a = _a(lams[0], mttr)
+    binomial = sum(math.comb(n, j) * a**j * (1 - a) ** (n - j) for j in range(k, n + 1))
+    assert wl.koon_system(n=n, k=k, failure_rate=lams[0], mttr=mttr).availability == pytest.approx(binomial, rel=1e-12)
+
+
+def test_redundancia_nunca_es_menos_disponible_que_un_componente():
+    for lam, mttr in ((0.01, 10.0), (0.2, 3.0), (1e-3, 100.0)):
+        a = _a(lam, mttr)
+        assert wl.parallel_system([lam, lam], mttr=mttr).availability > a
+        assert wl.koon_system(n=3, k=1, failure_rate=lam, mttr=mttr).availability > a
+
+
+def test_un_solo_componente_y_la_serie_no_cambian():
+    # Guarda: un componente (paralelo de 1 o 1-de-1) y la serie conservan A = MTBF / (MTBF + MTTR)
+    assert wl.parallel_system([0.01], mttr=10.0).availability == pytest.approx(_a(0.01, 10.0))
+    assert wl.koon_system(n=1, k=1, failure_rate=0.01, mttr=10.0).availability == pytest.approx(_a(0.01, 10.0))
+    assert wl.series_system([0.01, 0.02], mttr=10.0).availability == pytest.approx(1 / (1 + 0.03 * 10.0))
+
+
+def test_sin_mttr_no_hay_disponibilidad():
+    # Guarda
+    assert wl.parallel_system([0.01, 0.02]).availability is None
+    assert wl.koon_system(n=3, k=2, failure_rate=0.01).availability is None

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

@@ -135,6 +135,9 @@ AÑADIDAS_TRAS_V030 = {
     "solver.error.sensitivity.values_no_puede_estar_vacio",   # W-32
     "solver.error.sensitivity.param_no_es_parametro_modelo",
     "solver.error.compare.sin_resultados",   # W-31
+    "project.aviso.pert.rutas_casi_criticas",   # 0.4.4: avisos de validez de los modelos
+    "inventory.aviso.newsvendor.demanda_normal_cv_alto",
+    "advanced.aviso.monte_carlo_gg1.estimacion_imprecisa",
     "project.cabecera.to_frame.ht",    # «HT»/«HL» (holgura total/libre): acrónimos españoles que el extractor no veía; ya existían en v0.3.0
     "project.cabecera.to_frame.hl",
 }

walopy-0.4.4/tests/test_pert_varianza.py

@@ -0,0 +1,74 @@
+"""W-34: con varias rutas críticas empatadas, ``pert`` sumaba las varianzas de **todas** las actividades críticas.
+
+La varianza del proyecto en PERT es la de una ruta (la convención, con empates, es la de mayor varianza). Con 5 rutas
+idénticas de 3 actividades, σ salía 3,23 en lugar de 1,44 (√5 veces mayor). Además ``pert`` avisa cuando hay rutas casi
+críticas, porque entonces la probabilidad PERT (una sola ruta) es optimista.
+"""
+from __future__ import annotations
+
+import warnings
+
+import pytest
+
+import walopy as wl
+
+
+def _rutas_paralelas(n_rutas: int = 5) -> list[dict]:
+    acts = []
+    for p in range(n_rutas):
+        previa: list[str] = []
+        for j in range(3):
+            nombre = f"P{p}A{j}"
+            acts.append({"name": nombre, "optimistic": 4, "most_likely": 5, "pessimistic": 9, "predecessors": previa})
+            previa = [nombre]
+    acts.append({"name": "FIN", "optimistic": 1, "most_likely": 1, "pessimistic": 1, "predecessors": [f"P{p}A2" for p in range(n_rutas)]})
+    return acts
+
+
+def _pert(acts):
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore", UserWarning)
+        return wl.pert(acts)
+
+
+def test_rutas_empatadas_usan_la_varianza_de_una_ruta():
+    r = _pert(_rutas_paralelas())
+    assert r.project_variance == pytest.approx(3 * (5 / 6) ** 2)  # antes 15 · (5/6)² = 10,42
+    assert len(r.critical_path) == 16  # el conjunto de actividades críticas no cambia
+
+
+def test_con_empate_se_elige_la_ruta_de_mayor_varianza():
+    acts = [
+        {"name": "A", "optimistic": 2, "most_likely": 5, "pessimistic": 8, "predecessors": []},   # var 1
+        {"name": "B", "optimistic": 4, "most_likely": 5, "pessimistic": 6, "predecessors": []},   # var 1/9
+        {"name": "C", "optimistic": 1, "most_likely": 1, "pessimistic": 1, "predecessors": ["A", "B"]},
+    ]
+    assert _pert(acts).project_variance == pytest.approx(1.0)  # antes 1 + 1/9
+
+
+def test_una_sola_ruta_critica_no_cambia():
+    # Guarda: sin empates la varianza es la de la ruta crítica, como siempre
+    acts = [
+        {"name": "A", "optimistic": 2, "most_likely": 4, "pessimistic": 6, "predecessors": []},
+        {"name": "B", "optimistic": 1, "most_likely": 1, "pessimistic": 1, "predecessors": []},
+        {"name": "C", "optimistic": 1, "most_likely": 2, "pessimistic": 3, "predecessors": ["A", "B"]},
+    ]
+    r = wl.pert(acts)
+    assert r.project_variance == pytest.approx((4 / 6) ** 2 + (2 / 6) ** 2)
+
+
+def test_avisa_si_hay_rutas_casi_criticas():
+    with pytest.warns(UserWarning) as avisos:
+        wl.pert(_rutas_paralelas())
+    assert "P1A0" in str(avisos[0].message)
+
+
+def test_no_avisa_si_las_demas_rutas_tienen_holgura_amplia():
+    acts = [
+        {"name": "Larga", "optimistic": 20, "most_likely": 22, "pessimistic": 24, "predecessors": []},
+        {"name": "Corta", "optimistic": 1, "most_likely": 2, "pessimistic": 3, "predecessors": []},
+        {"name": "Fin", "optimistic": 1, "most_likely": 1, "pessimistic": 1, "predecessors": ["Larga", "Corta"]},
+    ]
+    with warnings.catch_warnings():
+        warnings.simplefilter("error")
+        wl.pert(acts)

{walopy-0.4.3 → walopy-0.4.4}/tests/test_plotting.py

@@ -37,7 +37,7 @@ RESULTADOS = {
     "break_even_sales_real": lambda: wl.break_even_sales(1000.0, 0.4, actual_revenue=3000.0),
     "eoq": lambda: wl.eoq(1000.0, 50.0, 2.0),
     "optimize_servers": lambda: wl.optimize_servers(4.0, 3.0, cost_per_server=10.0, cost_per_wait=5.0),
-    "monte_carlo": lambda: wl.monte_carlo_gg1(2.0, 3.0, 1.0, 1.0, n_customers=2000, seed=1),
+    "monte_carlo": lambda: wl.monte_carlo_gg1(2.0, 3.0, 1.0, 1.0, n_customers=50_000, seed=1),  # sin aviso de precisión
     "oee_arbol": lambda: wl.oee_kpi_tree(0.9, 0.9, 0.9),
     "throughput_arbol": lambda: wl.throughput_kpi_tree(80.0, 100.0, 0.05),
     "roi_arbol": lambda: wl.roi_kpi_tree(1000.0, 200.0, 3.0, 100.0, 500.0),