walopy 0.4.2__tar.gz → 0.4.4__tar.gz

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

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

@@ -164,7 +164,7 @@ from .solver import (
     solve_servers,
 )
 
-__version__ = "0.4.2"  # 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.2 → 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}'.",
@@ -584,6 +587,10 @@ EN: dict[str, str] = {
     "solver.error.solve_lam.supera_incluso_muy_baja_objetivo": "{target_metric} exceeds {target_value} even with a very low λ. The target may be infeasible for this model / μ.",
     "solver.error.solve_mu.sigue_superando_objetivo_puede_ser": "{target_metric} still exceeds {target_value} with μ = {mu_max:.4g}. The target may be numerically infeasible.",
     "solver.error.solve_servers.pudo_cumplir_hasta_servidores_considere": "Could not meet {target_metric} ≤ {target_value} with up to {c_max} servers. Consider increasing μ or relaxing the target.",
+    "solver.error.optimize_servers.sin_servidores_estables_hasta_c_max": "With λ={lam} and μ={mu} at least {c_min} servers are needed for the system to be stable, but c_max={c_max}. Increase c_max.",
+    "solver.error.sensitivity.values_no_puede_estar_vacio": "values cannot be empty.",
+    "solver.error.sensitivity.param_no_es_parametro_modelo": "{param!r} is not a parameter of {modelo}.",
+    "solver.error.compare.sin_resultados": "compare needs at least one result.",
     "solver.etiqueta.compare.escenario": "scenario_{expr}",
     "solver.etiqueta.summary.convergio": "did NOT converge",
     "solver.etiqueta.summary.convergio_2": "converged",

{walopy-0.4.2 → 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}'.",
@@ -584,6 +587,10 @@ ES: dict[str, str] = {
     "solver.error.solve_lam.supera_incluso_muy_baja_objetivo": "{target_metric} supera {target_value} incluso con λ muy baja. El objetivo puede ser infactible para este modelo / μ.",
     "solver.error.solve_mu.sigue_superando_objetivo_puede_ser": "{target_metric} sigue superando {target_value} con μ = {mu_max:.4g}. El objetivo puede ser numéricamente infactible.",
     "solver.error.solve_servers.pudo_cumplir_hasta_servidores_considere": "No se pudo cumplir {target_metric} ≤ {target_value} con hasta {c_max} servidores. Considere aumentar μ o relajar el objetivo.",
+    "solver.error.optimize_servers.sin_servidores_estables_hasta_c_max": "Con λ={lam} y μ={mu} hacen falta al menos {c_min} servidores para que el sistema sea estable, pero c_max={c_max}. Aumente c_max.",
+    "solver.error.sensitivity.values_no_puede_estar_vacio": "values no puede estar vacío.",
+    "solver.error.sensitivity.param_no_es_parametro_modelo": "{param!r} no es un parámetro de {modelo}.",
+    "solver.error.compare.sin_resultados": "compare necesita al menos un resultado.",
     "solver.etiqueta.compare.escenario": "escenario_{expr}",
     "solver.etiqueta.summary.convergio": "NO convergió",
     "solver.etiqueta.summary.convergio_2": "convergió",

{walopy-0.4.2 → 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.2 → 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.2 → 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.2 → 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.2 → walopy-0.4.4}/src/walopy/solver.py

@@ -1,6 +1,7 @@
 """Solvers: encuentran parámetros óptimos o metas definidas por la persona usuaria en modelos de colas y operaciones."""
 from __future__ import annotations
 
+import inspect
 from collections.abc import Sequence
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any, Callable
@@ -9,7 +10,7 @@ import numpy as np
 import pandas as pd
 
 from ._i18n import t as _t
-from ._utils import as_positive
+from ._utils import MAX_SERVIDORES, as_int_positive, as_positive
 
 if TYPE_CHECKING:
     import plotly.graph_objects as go
@@ -316,6 +317,14 @@ def solve_mu(
 # solve_servers — minimum c to meet a target
 # ---------------------------------------------------------------------------
 
+def _min_servidores_estables(lam: float, mu: float) -> int:
+    """Menor número de servidores *c* con ρ = λ/(c·μ) < 1 (la misma condición que exige ``mmc``)."""
+    c = max(1, int(lam / mu))
+    while lam / (c * mu) >= 1.0:
+        c += 1
+    return c
+
+
 def solve_servers(
     target_metric: str,
     target_value: float,
@@ -355,15 +364,16 @@ def solve_servers(
     --------
     >>> r = solve_servers(target_metric='Wq', target_value=0.5, lam=4.0, mu=3.0)
     >>> round(r.value, 4)
-    3.0
+    2.0
     """
     from .queuing import mmc
 
     lam = as_positive(lam, "lam")
     mu  = as_positive(mu, "mu")
     target_value = as_positive(target_value, "target_value")
+    c_max = as_int_positive(c_max, "c_max", max=MAX_SERVIDORES)
 
-    c_min_stable = int(np.ceil(lam / mu)) + 1  # min c for stability
+    c_min_stable = _min_servidores_estables(lam, mu)
 
     for c in range(c_min_stable, c_max + 1):
         result = mmc(lam, mu, c)
@@ -428,7 +438,7 @@ def optimize_servers(
     --------
     >>> r = optimize_servers(lam=4.0, mu=3.0, cost_per_server=10.0, cost_per_wait=5.0)
     >>> round(r.min_cost, 4)
-    30.7232
+    25.3333
     """
     from .queuing import mmc
 
@@ -436,8 +446,11 @@ def optimize_servers(
     mu              = as_positive(mu, "mu")
     cost_per_server = as_positive(cost_per_server, "cost_per_server")
     cost_per_wait   = as_positive(cost_per_wait, "cost_per_wait")
+    c_max           = as_int_positive(c_max, "c_max", max=MAX_SERVIDORES)
 
-    c_min = int(np.ceil(lam / mu)) + 1
+    c_min = _min_servidores_estables(lam, mu)
+    if c_min > c_max:
+        raise ValueError(_t("solver.error.optimize_servers.sin_servidores_estables_hasta_c_max", lam=lam, mu=mu, c_min=c_min, c_max=c_max))
     rows: list[dict[str, Any]] = []
 
     for c in range(c_min, c_max + 1):
@@ -518,6 +531,15 @@ def sensitivity(
     >>> import numpy as np
     >>> df = sensitivity(mm1, "lam", np.linspace(0.5, 4.5, 20), mu=5.0)
     """
+    if len(values) == 0:
+        raise ValueError(_t("solver.error.sensitivity.values_no_puede_estar_vacio"))
+    try:
+        parametros = inspect.signature(model_fn).parameters
+    except (TypeError, ValueError):   # callables sin firma inspeccionable: se intenta igualmente
+        parametros = None
+    if parametros is not None and param not in parametros and not any(p.kind is p.VAR_KEYWORD for p in parametros.values()):
+        nombre_modelo = repr(model_fn) if not hasattr(model_fn, "__name__") else model_fn.__name__
+        raise ValueError(_t("solver.error.sensitivity.param_no_es_parametro_modelo", param=param, modelo=nombre_modelo))
     rows: list[dict[str, Any]] = []
     for v in values:
         try:
@@ -601,6 +623,8 @@ def batch_model(
 
     # Pre-compute integer columns so iterrows() float-upcast can be reversed
     int_cols = {col for col in df.columns if pd.api.types.is_integer_dtype(df[col].dtype)}
+    # Una columna entera con NaN (DataFrame disperso) pasa a float64: sus valores enteros vuelven a ser int al llamar al modelo
+    sparse_int_cols = {col for col in df.columns if pd.api.types.is_float_dtype(df[col].dtype) and df[col].isna().any()}
 
     for _, row_series in df.iterrows():
         # Merge: fixed_kwargs as base, row values (non-NaN) take precedence
@@ -609,7 +633,10 @@ def batch_model(
             if isinstance(v, float) and np.isnan(v):
                 continue
             # iterrows() upcasts int64 columns to float64; reverse that cast
-            kwargs[k] = int(v) if k in int_cols else v
+            if k in int_cols or (k in sparse_int_cols and isinstance(v, (float, np.floating)) and float(v).is_integer()):
+                kwargs[k] = int(v)
+            else:
+                kwargs[k] = v
 
         try:
             result = model_fn(**kwargs)
@@ -655,7 +682,8 @@ def compare(
     ----------
     *results
         Cualquier objeto de resultado de walopy (``QueueResult``, ``SimulationResult``,
-        ``EOQResult``, etc.) o diccionarios simples.
+        ``EOQResult``, etc.) o diccionarios simples. Si la tabla ``to_frame()`` de un resultado tiene varias filas
+        (pedidos, actividades…), se comparan sus campos escalares (costo total, duración del proyecto…).
     labels : sequence of str, optional
         Etiquetas de las filas. Por defecto ``'escenario_1'``, ``'escenario_2'``, …
 
@@ -680,11 +708,14 @@ def compare(
     >>> tabla["c (servidores)"].tolist()
     [1, 2]
     """
+    if len(results) == 0:
+        raise ValueError(_t("solver.error.compare.sin_resultados"))
     rows: list[dict[str, Any]] = []
     for i, r in enumerate(results):
         label = labels[i] if (labels and i < len(labels)) else _t("solver.etiqueta.compare.escenario", expr=i + 1)
-        if hasattr(r, "to_frame"):
-            row = r.to_frame().iloc[0].to_dict()
+        tabla = r.to_frame() if hasattr(r, "to_frame") else None
+        if tabla is not None and len(tabla) == 1:
+            row = tabla.iloc[0].to_dict()
         elif isinstance(r, dict):
             row = dict(r)
         elif hasattr(r, "__dict__"):

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

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

@@ -28,11 +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
@@ -54,9 +57,12 @@ 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
 tests/test_propiedades_diferenciales.py
+tests/test_propiedades_inventario_fiabilidad.py
 tests/test_queuing.py
 tests/test_readme.py
 tests/test_referencias_externas.py
@@ -67,7 +73,10 @@ tests/test_salida_identica.py
 tests/test_salida_por_idioma.py
 tests/test_scheduling.py
 tests/test_scorecard.py
+tests/test_servidores_cmax.py
+tests/test_servidores_minimos.py
 tests/test_solver.py
+tests/test_solver_contratos.py
 tests/test_trazabilidad.py
 tests/test_version.py
 tests/test_wagner_whitin_ceros.py

{walopy-0.4.2 → 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.2 → 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)