pccpy 0.4.3__py3-none-any.whl

pccpy-0.4.3.dist-info/METADATA

@@ -0,0 +1,319 @@
+Metadata-Version: 2.4
+Name: pccpy
+Version: 0.4.3
+Summary: Control Estadístico de Procesos (SPC) en Python: cartas de control, capacidad y pruebas al estilo Minitab
+Author-email: LeoSanta15 <angelsanta1@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/LeoSanta15/pccpy
+Project-URL: Issues, https://github.com/LeoSanta15/pccpy/issues
+Project-URL: Changelog, https://github.com/LeoSanta15/pccpy/blob/main/CHANGELOG.md
+Keywords: spc,control estadístico de procesos,cartas de control,capacidad,minitab,six sigma
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.22
+Requires-Dist: scipy>=1.9
+Requires-Dist: pandas>=1.4
+Requires-Dist: matplotlib>=3.5
+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"
+Provides-Extra: docs
+Requires-Dist: sphinx>=7; extra == "docs"
+Requires-Dist: sphinx-rtd-theme>=2; extra == "docs"
+Requires-Dist: myst-parser>=2; extra == "docs"
+Dynamic: license-file
+
+# spyc
+
+**Control Estadístico de Procesos (SPC) en Python, al estilo Minitab.**
+
+Cartas de control, pruebas de causas especiales, análisis de capacidad, prueba de
+normalidad y Pareto, con salidas y convenciones (LCS/LCI, LEI/LES, Cp/Cpk/Pp/Ppk,
+Z.Bench, PPM, Anderson-Darling) pensadas para quien viene de Minitab.
+
+Todo en español: nombres de columnas, mensajes, descripciones de pruebas y gráficos.
+
+## Instalación
+
+Desde GitHub:
+
+```bash
+pip install git+https://github.com/TU_USUARIO/spyc.git
+```
+
+Desarrollo local:
+
+```bash
+git clone https://github.com/TU_USUARIO/spyc.git
+cd spyc
+pip install -e ".[dev]"
+pytest --cov=spyc              # pruebas + cobertura (97% al momento de escribir esto)
+ruff check src/                # estilo y errores comunes
+mypy src/spyc                  # tipos
+```
+
+Ver [`CHANGELOG.md`](CHANGELOG.md) para el historial de versiones.
+
+## Documentación
+
+Hay documentación construida con Sphinx en `docs/`, con una página por cada grupo
+de cartas (generadas a partir de los docstrings, así que siempre coinciden con el
+código instalado). Para generarla y abrirla en tu máquina:
+
+```bash
+pip install -e ".[docs]"
+sphinx-build -b html docs/source docs/build
+```
+
+Abre `docs/build/index.html`. Una vez el repositorio esté en GitHub, puedes conectarlo
+en [readthedocs.org](https://readthedocs.org) para tenerla publicada automáticamente
+en cada push; el archivo `.readthedocs.yaml` ya está listo para eso.
+
+Requiere Python ≥ 3.9 (numpy, scipy, pandas, matplotlib).
+
+## Inicio rápido
+
+```python
+import numpy as np
+import spyc
+
+rng = np.random.default_rng(1)
+x = rng.normal(100, 2, 60)
+x[40:] += 3                                   # el proceso se desplaza
+
+carta = spyc.imr_chart(x, tests=(1, 2, 3, 4, 5, 6, 7, 8))
+print(carta.summary())                        # resumen tipo sesión de Minitab
+carta.violations()                            # DataFrame: panel, punto, prueba, descripción
+carta.to_frame()                              # todos los valores, límites y pruebas fallidas
+carta.plot()                                  # figura de matplotlib
+```
+
+## Cartas de control
+
+| Minitab | Función | Notas |
+|---|---|---|
+| I-MR | `imr_chart(x)` | `sigma_method`: `'mr'`, `'median_mr'`, `'mssd'`; `span` configurable |
+| Xbar-R | `xbar_r_chart(datos)` | `sigma_method`: `'rbar'`, `'pooled'` |
+| Xbar-S | `xbar_s_chart(datos)` | `sigma_method`: `'sbar'`, `'pooled'` |
+| P | `p_chart(defectuosos, n)` | límites variables con `n` variable |
+| NP | `np_chart(defectuosos, n)` | |
+| C | `c_chart(defectos)` | |
+| U | `u_chart(defectos, n)` | |
+| Laney P' / U' | `laney_p_chart`, `laney_u_chart` | corrige sobredispersión |
+| EWMA | `ewma_chart(datos, weight=0.2, k=3)` | límites exactos (se ensanchan al inicio) |
+| CUSUM | `cusum_chart(datos, h=4, k=0.5)` | tabular, sumas superior e inferior |
+| Media móvil | `ma_chart(datos, length=3)` | límites más anchos en los primeros `length-1` puntos |
+| Z-MR | `zmr_chart(x, partes)` | corridas cortas; ver más abajo |
+| I-MR-R/S (entre/dentro) | `imr_rs_chart(datos, within='r')` | variación entre y dentro de subgrupos |
+| G | `g_chart(entre_eventos)` | eventos raros, geométrica |
+| T | `t_chart(tiempos)` | eventos raros, Weibull o exponencial |
+| T² de Hotelling | `t2_chart(matriz)` | Fase I / Fase II, con diagnóstico por variable |
+| Varianza generalizada | `generalized_variance_chart(matriz, subgroup_size=n)` | dispersión multivariada, `\|S\|` |
+| MEWMA | `mewma_chart(matriz)` | límite por ARL (por defecto 200) |
+
+Los datos de variables aceptan una matriz 2D (filas = subgrupos), un vector con
+`subgroup_size=5`, o un vector con `subgroup=identificadores` (subgrupos de tamaño desigual).
+
+```python
+datos = rng.normal(50, 1, size=(25, 5))
+spyc.xbar_r_chart(datos, tests=(1, 2, 3, 4)).summary()
+
+vector = datos.ravel()                         # mismos datos en un solo vector
+ids = np.repeat(np.arange(25), 5)              # identificador de subgrupo de cada dato
+spyc.xbar_r_chart(vector, subgroup_size=5)
+spyc.xbar_s_chart(vector, subgroup=ids)
+```
+
+**Parámetros históricos y etapas** (equivalentes a *Opciones de estimación* y *Etapas* de Minitab):
+
+```python
+spyc.imr_chart(x, mu=100, sigma=2)                      # parámetros conocidos
+spyc.imr_chart(x, stages=["antes"] * 40 + ["después"] * 20)   # límites por etapa
+```
+
+**Atributos:**
+
+```python
+defectuosos = rng.binomial(200, 0.05, 30)
+spyc.p_chart(defectuosos, n=200)
+spyc.laney_p_chart(defectuosos, n=200)
+```
+
+## Cartas avanzadas
+
+```python
+# Z-MR: partes con medias y variaciones distintas en una sola carta (corridas cortas)
+partes = ["A"] * 10 + ["B"] * 10 + ["A"] * 10
+medidas = np.r_[rng.normal(50, 1, 10), rng.normal(80, 2, 10), rng.normal(50, 1, 10)]
+spyc.zmr_chart(medidas, partes, sigma_method="by_part")   # 'constant', 'relative', 'by_part', 'by_run'
+
+# I-MR-R/S: la variación entre subgrupos no genera falsas alarmas como en Xbar-R
+sub = rng.normal(20, 1, (25, 5)) + rng.normal(0, 1.5, (25, 1))
+c = spyc.imr_rs_chart(sub, within="s")
+c.params[0]     # sigma_dentro, sigma_entre, sigma_entre_dentro
+
+# Eventos raros
+spyc.g_chart(rng.geometric(0.02, 40) - 1)                 # casos entre eventos
+spyc.t_chart(rng.weibull(1.5, 40) * 30)                   # tiempo entre eventos
+
+# Media móvil
+spyc.ma_chart(x, length=5)
+```
+
+`zmr_chart` estandariza cada observación con la media de su parte y una sigma estimada
+con el rango móvil *dentro de cada corrida* (bloque consecutivo de la misma parte);
+`mu={parte: valor}` y `sigma=` aceptan valores históricos o nominales.
+
+## Cartas multivariadas
+
+```python
+Sigma = [[1, .6, .3], [.6, 1, .2], [.3, .2, 1]]
+historico = rng.multivariate_normal([0, 0, 0], Sigma, 100)
+nuevos = rng.multivariate_normal([0, 0, 0], Sigma, 40)
+nuevos[25:, 2] += 4                                       # la variable 3 se desplaza
+
+# Fase I: parámetros estimados de los mismos datos
+spyc.t2_chart(historico).summary()
+
+# Fase II: parámetros históricos (n_hist = observaciones con que se estimaron)
+c = spyc.t2_chart(nuevos, mu=historico.mean(axis=0), cov=np.cov(historico, rowvar=False),
+                  n_hist=100)
+c.violations()
+c.contributions(31)                                       # ¿qué variable explica la señal?
+
+# Subgrupos: matriz N x p con subgroup_size, o array 3-D (subgrupos x n x p)
+spyc.t2_chart(nuevos[:40], subgroup_size=4)
+spyc.generalized_variance_chart(nuevos[:40], subgroup_size=8)
+
+# MEWMA: cambios pequeños y sostenidos
+spyc.mewma_chart(nuevos, mu=historico.mean(axis=0), cov=np.cov(historico, rowvar=False))
+spyc.mewma_limit(p=2, weight=0.1, arl=200)                # límite H para un ARL dado (≈ 8.64)
+```
+
+Los datos pueden ser un `DataFrame` (los nombres de columna se usan en `contributions`).
+El límite de T² usa por defecto α = 0.00135 (cola de 3 sigmas, como Minitab). Sin `mu`/`cov`
+se usan límites de **Fase I** (Beta para individuales, F para subgrupos); con `mu`/`cov` y
+`n_hist`, de **Fase II**; con `mu`/`cov` sin `n_hist` los parámetros se toman como conocidos (χ²).
+
+### Etapas y Box-Cox
+
+Las 4 cartas multivariadas (T², varianza generalizada, MEWMA y MCUSUM) aceptan `stages`
+y `boxcox`, igual que las cartas univariadas:
+
+```python
+etapas = [1] * 40 + [2] * 40                              # p. ej. antes/después de un ajuste
+
+# Sin mu/cov: la media y la covarianza se vuelven a estimar dentro de cada etapa
+c = spyc.t2_chart(nuevos_con_dos_etapas, stages=etapas)
+c.stage_mean[1], c.stage_mean[2]                          # medias distintas por etapa
+c.contributions(45)                                       # usa la media/cov de la etapa del punto 45
+
+# Con mu/cov históricos: los mismos parámetros en todas las etapas
+spyc.t2_chart(nuevos_con_dos_etapas, mu=mu, cov=cov, n_hist=100, stages=etapas)
+
+# MEWMA y MCUSUM: el acumulador reinicia al empezar cada etapa
+spyc.mewma_chart(nuevos_con_dos_etapas, stages=etapas)
+spyc.mcusum_chart(nuevos_con_dos_etapas, stages=etapas)
+
+# Box-Cox: una lambda por variable (no se puede combinar con mu/cov históricos)
+c = spyc.t2_chart(datos_positivos, boxcox=True)
+c.params[0]["lambda_boxcox"]                              # {'X1': ..., 'X2': ..., 'X3': ...}
+spyc.generalized_variance_chart(datos_positivos, subgroup_size=6, boxcox=True)
+spyc.mewma_chart(datos_positivos, boxcox=True)
+spyc.mcusum_chart(datos_positivos, boxcox=True)
+```
+
+## Pruebas de causas especiales
+
+Las 8 pruebas de Minitab (1 a 8) con sus parámetros por defecto
+(`K` = 3, 9, 6, 14, 2, 4, 15, 8). Se piden con `tests=(...)` y se ajustan con `test_params`:
+
+```python
+spyc.imr_chart(x, tests=(1, 2, 5), test_params={2: 7})   # prueba 2 con 7 puntos
+```
+
+Cada tipo de carta aplica el subconjunto que corresponde (completo en I, Xbar y Z;
+básicas 1-4 en MR, R, S, G, T y cartas de atributos; solo la 1 en EWMA, CUSUM, MA y las
+multivariadas). En G y T la prueba 1 usa los percentiles de su distribución.
+Las funciones individuales están en `spyc.rules`.
+
+## Capacidad del proceso
+
+```python
+datos = rng.normal(10, 0.1, 100)
+res = spyc.capability_analysis(datos, lsl=9.7, usl=10.3, subgroup_size=5)
+print(res.summary())      # Cp, CPL, CPU, Cpk, Pp, PPL, PPU, Ppk, Cpm, Z.Bench, PPM, IC
+res.to_frame()
+res.plot()
+```
+
+Como en Minitab, **Cp/Cpk usan la desviación estándar dentro de subgrupos** y
+**Pp/Ppk la desviación general**; por eso Cpk ≠ Ppk cuando el proceso se desplaza o hay variación entre subgrupos.
+
+Datos no normales:
+
+```python
+spyc.capability_nonnormal(x, lsl=1, usl=20, distribution="weibull")
+spyc.capability_boxcox(x, lsl=1, usl=20)
+```
+
+Distribuciones: `normal`, `lognormal`, `weibull`, `gamma`, `exponential`,
+`loglogistic`, `logistic`, `largest_extreme`, `smallest_extreme` (método de percentiles).
+
+`spyc.capability_sixpack(datos, lsl, usl, subgroup_size=5)` genera el **Capability Sixpack**.
+
+## Normalidad, Pareto y constantes
+
+```python
+spyc.normality_test(x)                    # Anderson-Darling (por defecto), 'shapiro', 'dagostino'
+spyc.probability_plot(x)
+
+tabla = spyc.pareto(["rayón", "abolladura", "rayón", "otro"])
+spyc.plot_pareto(tabla)
+
+spyc.control_chart_constants(5)           # d2, d3, c4, c5, A2, A3, D3, D4, B3, B4
+```
+
+Las constantes se calculan por integración numérica para **cualquier** `n ≥ 2` (no solo tablas hasta 25).
+
+## Validación
+
+ pruebas automatizadas. Las referencias son independientes de spyc:
+
+- Constantes d2, d3, c4 frente a las tablas publicadas (Montgomery).
+- Límites I-MR, Xbar-R y Xbar-S frente al cálculo manual con A2, D3, D4, A3, B3, B4.
+- Anderson-Darling frente a `statsmodels.stats.diagnostic.normal_ad` (coincide a 9 decimales).
+- EWMA y CUSUM frente a la recursión manual.
+- Las 8 pruebas de causas especiales frente a casos construidos a mano, incluidos los casos límite.
+- T²: valores frente a `scipy.spatial.distance.mahalanobis`; los límites de Fase I y II
+  (Beta y F) por simulación Monte Carlo (tasa de falsa alarma y valor esperado).
+- Varianza generalizada: constantes b1 y b2 por simulación de matrices de covarianza.
+- MEWMA: el límite para p=2, λ=0.1, ARL=200 da 8.63 (publicado: 8.64, Prabhu y Runger 1997)
+  y el ARL se comprueba por simulación.
+- G y T: cuantiles frente a `scipy.stats`, y máxima verosimilitud Weibull por su ecuación de score.
+- Constantes de Z-MR (1.128 y 3.686) frente a las que documenta Minitab.
+
+> **Importante:** spyc no se ha comparado corrida a corrida contra el software Minitab
+> (no hay licencia disponible en el desarrollo). Sigue las fórmulas y convenciones que
+> Minitab documenta. Si encuentras una diferencia, abre un issue (ver `CONTRIBUTING.md`).
+
+## Fuera de alcance (por ahora)
+
+Cartas multivariadas (T² de Hotelling), cartas de corridas cortas, Z-MR, I-MR-R/S
+(entre/dentro), transformación de Johnson, MSA/Gage R&R.
+
+## Licencia
+
+MIT.

pccpy-0.4.3.dist-info/RECORD

@@ -0,0 +1,22 @@
+pccpy-0.4.3.dist-info/licenses/LICENSE,sha256=nHoS7zkyH9dODTc-wkgXuXUTdSSqPNTrFz6gBO0WgVk,1072
+spyc/__init__.py,sha256=H9V4zs5zsVbHyooRXcRvN4u-j8fb-8zNsFmEWxcBnm4,1900
+spyc/_constants.py,sha256=jsOTg062VXtxUn3K5SjZ2fhrOFbc4zOmMQFFIqWnN_A,2729
+spyc/_data.py,sha256=jjIjGZn_fYvYH2dWyMzavkoSEVpS7zU6gUWYTWRJaYg,4011
+spyc/_sigma.py,sha256=7cUFK2Z48RzYFXR82llm7ERS7Xv1AP4Pbe-5jaLmrtM,3445
+spyc/capability.py,sha256=-3aVL1V-43agzfVUYWwAVR91K7hlMGzaRca4Am4-wuo,15944
+spyc/multivariate.py,sha256=pZfkc6HVnbxF83vRaMOZjbu8U1PuFNTew1DBUD5vDjs,24031
+spyc/normality.py,sha256=QCHFeLqTn10xsvX2IRPoS9e-qWIlRxqIRtjSYq5k92Y,2712
+spyc/plotting.py,sha256=ljaorhxaTh55bMla0i3i1J5jYzkq2ZOYFsBI4crzQXI,10037
+spyc/quality_tools.py,sha256=FTNkkXrwzgynMvW_xY_qU-Q53jS9IyRyBGp39Iv9Q_E,2397
+spyc/results.py,sha256=tR9FVakg2-oZ6QGUTGou41p5DwOKExxWGuQYKhUppZU,7580
+spyc/rules.py,sha256=rlGlzlVh_gHJYBvFoTEpTcgB2qMzMMn0D8oBpyi6aeI,6086
+spyc/charts/__init__.py,sha256=U0u3Dw3i-AZZ7fGgzQLmCXp9HqjD6-vN6JNa-hQRjMc,600
+spyc/charts/_engine.py,sha256=tvsQUuuedGAvqxgxeiAV8cAM8ebR0AEkKdiWg2BLv_w,3618
+spyc/charts/advanced.py,sha256=y0Fxu4WE78BwM65tEzh47FEE9D1WNb9WCDzqEoqot-I,21558
+spyc/charts/attributes.py,sha256=JvJQe3iLJSTWCqgJP0yKNKtsQpLXwyACi8hMvDY3D9s,5387
+spyc/charts/timeweighted.py,sha256=M3r4O5QKjRVXuIgqLzqnUok5R9k5VpTAocmzRPeKWLM,4205
+spyc/charts/variables.py,sha256=ORuEfaipD7t8rJfX1C8GoAO1GbBY2U0M7qYGNYxTnFo,5599
+pccpy-0.4.3.dist-info/METADATA,sha256=9gWY6z7syZ1HqWw703ziSSXlStmh1iP3OcTVKuRlWEU,13363
+pccpy-0.4.3.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+pccpy-0.4.3.dist-info/top_level.txt,sha256=LTiaF0UW38bvJzBsmdnooNa5uCV1C_tb6vkbv0p3T_k,5
+pccpy-0.4.3.dist-info/RECORD,,

pccpy-0.4.3.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pccpy-0.4.3.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Autores de spyc
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pccpy-0.4.3.dist-info/top_level.txt

@@ -0,0 +1 @@
+spyc

spyc/__init__.py

@@ -0,0 +1,89 @@
+"""spyc - Control Estadístico de Procesos (SPC) en Python, al estilo Minitab."""
+from ._constants import c4, c5, control_chart_constants, d2, d3
+from .capability import (
+    CapabilityResult,
+    NonNormalCapabilityResult,
+    capability_analysis,
+    capability_boxcox,
+    capability_nonnormal,
+)
+from .charts import (
+    c_chart,
+    cusum_chart,
+    ewma_chart,
+    g_chart,
+    imr_chart,
+    imr_rs_chart,
+    laney_p_chart,
+    laney_u_chart,
+    ma_chart,
+    np_chart,
+    p_chart,
+    t_chart,
+    u_chart,
+    xbar_r_chart,
+    xbar_s_chart,
+    zmr_chart,
+    zone_chart,
+)
+from .multivariate import (
+    generalized_variance_chart,
+    mcusum_chart,
+    mcusum_limit,
+    mewma_chart,
+    mewma_limit,
+    t2_chart,
+)
+from .normality import NormalityResult, normality_test
+from .plotting import capability_sixpack, plot_capability, plot_control_chart, probability_plot
+from .quality_tools import pareto, plot_pareto
+from .results import ControlChart, MultivariateChart, Panel
+
+__version__ = "0.4.3"
+
+__all__ = [
+    "CapabilityResult",
+    "ControlChart",
+    "MultivariateChart",
+    "NonNormalCapabilityResult",
+    "NormalityResult",
+    "Panel",
+    "c4",
+    "c5",
+    "c_chart",
+    "capability_analysis",
+    "capability_boxcox",
+    "capability_nonnormal",
+    "capability_sixpack",
+    "control_chart_constants",
+    "cusum_chart",
+    "d2",
+    "d3",
+    "ewma_chart",
+    "g_chart",
+    "generalized_variance_chart",
+    "imr_chart",
+    "imr_rs_chart",
+    "laney_p_chart",
+    "laney_u_chart",
+    "ma_chart",
+    "mcusum_chart",
+    "mcusum_limit",
+    "mewma_chart",
+    "mewma_limit",
+    "normality_test",
+    "np_chart",
+    "p_chart",
+    "pareto",
+    "plot_capability",
+    "plot_control_chart",
+    "plot_pareto",
+    "probability_plot",
+    "t2_chart",
+    "t_chart",
+    "u_chart",
+    "xbar_r_chart",
+    "xbar_s_chart",
+    "zmr_chart",
+    "zone_chart",
+]

spyc/_constants.py

@@ -0,0 +1,101 @@
+"""Constantes de control estadístico de procesos (d2, d3, c4, c5, A2, D3, D4, ...).
+
+Se calculan numéricamente para *cualquier* tamaño de subgrupo n >= 2, en lugar
+de depender de una tabla finita. Los valores coinciden con las tablas
+publicadas (p. ej. Montgomery, Apéndice VI) a los decimales publicados.
+"""
+from __future__ import annotations
+
+import math
+from functools import cache
+
+import numpy as np
+from scipy import integrate
+from scipy.special import gammaln
+
+_SQRT2PI = math.sqrt(2.0 * math.pi)
+
+
+def _phi(t: float) -> float:
+    return math.exp(-0.5 * t * t) / _SQRT2PI
+
+
+def _Phi(t: float) -> float:
+    return 0.5 * math.erfc(-t / math.sqrt(2.0))
+
+
+def _check_n(n: int) -> int:
+    n = int(n)
+    if n < 2:
+        raise ValueError(f"El tamaño de subgrupo debe ser >= 2 (recibido: {n}).")
+    return n
+
+
+@cache
+def d2(n: int) -> float:
+    """Media del rango relativo W = R/sigma para n observaciones normales."""
+    n = _check_n(n)
+
+    def f(x: float) -> float:
+        p = _Phi(x)
+        return 1.0 - p**n - (1.0 - p) ** n
+
+    val, _ = integrate.quad(f, -np.inf, np.inf, epsabs=1e-13, epsrel=1e-13, limit=200)
+    return float(val)
+
+
+@cache
+def d3(n: int) -> float:
+    """Desviación estándar del rango relativo W = R/sigma."""
+    n = _check_n(n)
+    lim = 9.0 + math.log(n)
+
+    def joint(y: float, x: float) -> float:
+        # densidad conjunta (mínimo x, máximo y) por (y - x)^2
+        return (
+            (y - x) ** 2
+            * n
+            * (n - 1)
+            * _phi(x)
+            * _phi(y)
+            * (_Phi(y) - _Phi(x)) ** (n - 2)
+        )
+
+    ex2, _ = integrate.dblquad(
+        joint, -lim, lim, lambda x: x, lambda x: lim, epsabs=1e-11, epsrel=1e-11
+    )
+    return math.sqrt(max(ex2 - d2(n) ** 2, 0.0))
+
+
+@cache
+def c4(n: int) -> float:
+    """Factor de corrección de sesgo de la desviación estándar muestral."""
+    n = _check_n(n)
+    return math.sqrt(2.0 / (n - 1)) * math.exp(gammaln(n / 2.0) - gammaln((n - 1) / 2.0))
+
+
+@cache
+def c5(n: int) -> float:
+    """Desviación estándar de s / sigma: sqrt(1 - c4^2)."""
+    return math.sqrt(1.0 - c4(n) ** 2)
+
+
+def control_chart_constants(n: int) -> dict[str, float]:
+    """Devuelve todas las constantes para un tamaño de subgrupo ``n``.
+
+    Claves: d2, d3, c4, c5, A2, A3, D3, D4, B3, B4.
+    """
+    n = _check_n(n)
+    _d2, _d3, _c4, _c5 = d2(n), d3(n), c4(n), c5(n)
+    return {
+        "d2": _d2,
+        "d3": _d3,
+        "c4": _c4,
+        "c5": _c5,
+        "A2": 3.0 / (_d2 * math.sqrt(n)),
+        "A3": 3.0 / (_c4 * math.sqrt(n)),
+        "D3": max(0.0, 1.0 - 3.0 * _d3 / _d2),
+        "D4": 1.0 + 3.0 * _d3 / _d2,
+        "B3": max(0.0, 1.0 - 3.0 * _c5 / _c4),
+        "B4": 1.0 + 3.0 * _c5 / _c4,
+    }

spyc/_data.py

@@ -0,0 +1,106 @@
+"""Conversión y validación de datos de entrada."""
+from __future__ import annotations
+
+import numpy as np
+import pandas as pd
+
+
+def as_1d(x, name: str = "x", allow_nan: bool = False) -> np.ndarray:
+    """Convierte ``x`` (lista, array, Series) a un array float 1-D."""
+    arr = np.asarray(x, dtype=float)
+    if arr.ndim == 0:
+        arr = arr.reshape(1)
+    if arr.ndim != 1:
+        raise ValueError(f"'{name}' debe ser unidimensional (recibido: {arr.ndim}-D).")
+    if arr.size == 0:
+        raise ValueError(f"'{name}' está vacío.")
+    if not allow_nan and not np.all(np.isfinite(arr)):
+        raise ValueError(f"'{name}' contiene valores faltantes o infinitos.")
+    return arr
+
+
+def to_subgroups(
+    data,
+    subgroup_size: int | None = None,
+    subgroup=None,
+) -> np.ndarray:
+    """Devuelve una matriz (k subgrupos x m columnas) rellena con NaN.
+
+    Formatos aceptados (los mismos que ofrece Minitab):
+
+    * ``data`` 2-D (array o DataFrame): cada **fila** es un subgrupo.
+    * ``data`` 1-D + ``subgroup_size``: observaciones consecutivas se agrupan de
+      a ``subgroup_size``.
+    * ``data`` 1-D + ``subgroup`` (identificadores, misma longitud): cada valor
+      distinto de ``subgroup`` define un subgrupo, en orden de aparición. Permite
+      subgrupos de tamaño desigual.
+    """
+    arr = np.asarray(data, dtype=float)
+    if arr.ndim == 2:
+        if subgroup_size is not None or subgroup is not None:
+            raise ValueError(
+                "Con datos 2-D no se debe indicar 'subgroup_size' ni 'subgroup'."
+            )
+        mat = arr
+    elif arr.ndim == 1:
+        if subgroup is not None:
+            ids = np.asarray(subgroup)
+            if ids.shape != arr.shape:
+                raise ValueError("'subgroup' debe tener la misma longitud que los datos.")
+            groups = [g.to_numpy(dtype=float) for _, g in pd.Series(arr).groupby(ids, sort=False)]
+            m = max(len(g) for g in groups)
+            mat = np.full((len(groups), m), np.nan)
+            for i, g in enumerate(groups):
+                mat[i, : len(g)] = g
+        elif subgroup_size is not None:
+            m = int(subgroup_size)
+            if m < 1:
+                raise ValueError("'subgroup_size' debe ser >= 1.")
+            if arr.size % m != 0:
+                raise ValueError(
+                    f"{arr.size} observaciones no se pueden dividir en subgrupos de {m}."
+                )
+            mat = arr.reshape(-1, m)
+        else:
+            raise ValueError(
+                "Datos 1-D: indique 'subgroup_size' o 'subgroup', o pase una matriz 2-D."
+            )
+    else:
+        raise ValueError("Los datos deben ser 1-D o 2-D.")
+
+    if mat.shape[0] == 0 or mat.shape[1] == 0:
+        raise ValueError("No hay datos.")
+    if np.any(np.isinf(mat)):
+        raise ValueError("Los datos contienen valores infinitos.")
+    if np.any(np.all(np.isnan(mat), axis=1)):
+        raise ValueError("Hay subgrupos sin ninguna observación válida.")
+    return mat
+
+
+def stage_slices(n_points: int, stages) -> list:
+    """Lista de (etiqueta, índices) con las etapas en orden de aparición.
+
+    Cada etapa debe ser un bloque contiguo (como exige Minitab).
+    """
+    if stages is None:
+        return [(1, np.arange(n_points))]
+    st = np.asarray(stages)
+    if st.shape != (n_points,):
+        raise ValueError(
+            f"'stages' debe tener una etiqueta por punto graficado ({n_points}); "
+            f"recibido: {st.shape}."
+        )
+    out, seen = [], set()
+    start = 0
+    for i in range(1, n_points + 1):
+        if i == n_points or st[i] != st[start]:
+            label = st[start].item() if hasattr(st[start], "item") else st[start]
+            if label in seen:
+                raise ValueError(
+                    f"La etapa {label!r} aparece en bloques separados; "
+                    "cada etapa debe ser contigua."
+                )
+            seen.add(label)
+            out.append((label, np.arange(start, i)))
+            start = i
+    return out