statslibx 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

statslib/utils.py

@@ -1,889 +0,0 @@
-import numpy as np
-import pandas as pd
-import matplotlib.pyplot as plt
-from typing import Union, List, Optional, Literal, Tuple
-import warnings
-import os
-from scipy import stats
-import seaborn as sns
-
-
-class UtilsStats:
-    """
-    Clase utilitaria para operaciones estadísticas comunes y visualización
-    
-    Esta clase proporciona métodos para validación de datos, análisis estadísticos
-    básicos y visualización de resultados.
-    
-    Examples:
-    ---------
-    >>> utils = UtilsStats()
-    >>> data = np.random.normal(0, 1, 100)
-    >>> utils.check_normality(data)
-    >>> utils.plot_distribution(data)
-    """
-    
-    def __init__(self):
-        """Inicializar la clase utilitaria"""
-        self._plot_backend = 'seaborn'
-        self._default_figsize = (12, 5)
-        self._save_fig = False
-        self._fig_format = 'png'
-        self._fig_dpi = 300
-        self._figures_dir = 'figures'
-        
-        # Configuración de estilo para matplotlib
-        plt.style.use('default')
-        self._setup_plotting_style()
-    
-    def _setup_plotting_style(self):
-        """Configurar estilos de plotting por defecto"""
-        plt.rcParams['figure.figsize'] = [self._default_figsize[0], self._default_figsize[1]]
-        plt.rcParams['figure.dpi'] = self._fig_dpi
-        plt.rcParams['savefig.dpi'] = self._fig_dpi
-        plt.rcParams['font.size'] = 10
-        plt.rcParams['axes.grid'] = True
-        plt.rcParams['grid.alpha'] = 0.3
-        plt.rcParams['lines.linewidth'] = 2
-    
-    def set_plot_backend(self, backend: Literal['matplotlib', 'seaborn', 'plotly']):
-        """
-        Establecer el backend de visualización por defecto
-        """
-        self._plot_backend = backend
-    
-    def set_default_figsize(self, figsize: Tuple[int, int]):
-        """
-        Establecer el tamaño de figura por defecto
-        """
-        self._default_figsize = figsize
-        plt.rcParams['figure.figsize'] = [figsize[0], figsize[1]]
-    
-    def set_save_fig_options(self, save_fig: Optional[bool] = False, 
-                           fig_format: str = 'png', 
-                           fig_dpi: int = 300,
-                           figures_dir: str = 'figures'):
-        """
-        Configurar opciones para guardar figuras
-        """
-        self._save_fig = save_fig
-        self._fig_format = fig_format
-        self._fig_dpi = fig_dpi
-        self._figures_dir = figures_dir
-    
-    def _save_figure(self, fig, filename: str, **kwargs):
-        """
-        Guardar figura si save_fig está activado
-        """
-        if self._save_fig:
-            try:
-                os.makedirs(self._figures_dir, exist_ok=True)
-                filepath = os.path.join(self._figures_dir, f"{filename}.{self._fig_format}")
-                
-                fig.savefig(
-                    filepath, 
-                    format=self._fig_format,
-                    dpi=self._fig_dpi,
-                    bbox_inches='tight',
-                    facecolor='white',
-                    **kwargs
-                )
-                print(f"✓ Figura guardada: {filepath}")
-                
-            except Exception as e:
-                print(f"✗ Error guardando figura: {e}")
-
-    # ============= MÉTODOS DE ANÁLISIS ESTADÍSTICO =============
-
-    def validate_dataframe(self, data: Union[pd.DataFrame, np.ndarray, list]) -> pd.DataFrame:
-        """Valida y convierte datos a DataFrame"""
-        if isinstance(data, pd.DataFrame):
-            return data
-        elif isinstance(data, np.ndarray):
-            if data.ndim == 1:
-                return pd.DataFrame({'var': data})
-            elif data.ndim == 2:
-                return pd.DataFrame(data, columns=[f'var_{i}' for i in range(data.shape[1])])
-            else:
-                raise ValueError("Solo se soportan arrays 1D y 2D")
-        elif isinstance(data, list):
-            return pd.DataFrame(data)
-        else:
-            raise TypeError(f"Tipo de dato no soportado: {type(data)}")
-
-    def format_number(self, num: float, decimals: int = 6, scientific: bool = False) -> str:
-        """Formatea un número con decimales especificados"""
-        if scientific and abs(num) < 0.001:
-            return f"{num:.{decimals}e}"
-        return f"{num:.{decimals}f}"
-
-    def check_normality(self, data: Union[pd.Series, np.ndarray], alpha: float = 0.05) -> dict:
-        """Verifica si los datos siguen distribución normal usando Shapiro-Wilk"""
-        if isinstance(data, pd.Series):
-            data = data.dropna().values
-        else:
-            data = np.array(data)
-            data = data[~np.isnan(data)]
-        
-        shapiro_stat, shapiro_p = stats.shapiro(data)
-        
-        return {
-            'is_normal': shapiro_p > alpha,
-            'shapiro_statistic': shapiro_stat,
-            'shapiro_pvalue': shapiro_p,
-            'alpha': alpha,
-            'interpretation': 'Normal' if shapiro_p > alpha else 'No Normal'
-        }
-
-    def calculate_confidence_intervals(self, data: Union[pd.Series, np.ndarray], 
-                                     confidence_level: float = 0.95,
-                                     method: str = 'parametric') -> dict:
-        """
-        Calcula intervalos de confianza para la media
-        """
-        if isinstance(data, pd.Series):
-            data_clean = data.dropna().values
-        else:
-            data_clean = data[~np.isnan(data)]
-        
-        n = len(data_clean)
-        mean = np.mean(data_clean)
-        std = np.std(data_clean, ddof=1)
-        
-        if method == 'parametric':
-            se = std / np.sqrt(n)
-            z_value = stats.t.ppf((1 + confidence_level) / 2, n - 1)
-            margin_error = z_value * se
-            
-            ci_lower = mean - margin_error
-            ci_upper = mean + margin_error
-            
-        elif method == 'bootstrap':
-            n_bootstraps = 1000
-            bootstrap_means = []
-            
-            for _ in range(n_bootstraps):
-                bootstrap_sample = np.random.choice(data_clean, size=n, replace=True)
-                bootstrap_means.append(np.mean(bootstrap_sample))
-            
-            alpha = 1 - confidence_level
-            ci_lower = np.percentile(bootstrap_means, (alpha / 2) * 100)
-            ci_upper = np.percentile(bootstrap_means, (1 - alpha / 2) * 100)
-            margin_error = (ci_upper - ci_lower) / 2
-            
-        else:
-            raise ValueError("Método debe ser 'parametric' o 'bootstrap'")
-        
-        return {
-            'mean': mean,
-            'std': std,
-            'n': n,
-            'confidence_level': confidence_level,
-            'ci_lower': ci_lower,
-            'ci_upper': ci_upper,
-            'margin_error': margin_error,
-            'method': method
-        }
-
-    def detect_outliers(self, data: Union[pd.Series, np.ndarray], 
-                       method: Literal['iqr', 'zscore', 'isolation_forest'] = 'iqr',
-                       **kwargs) -> np.ndarray:
-        """
-        Detecta outliers usando diferentes métodos
-        
-        Parameters:
-        -----------
-        data : array-like
-            Datos a analizar
-        method : str
-            'iqr', 'zscore', o 'isolation_forest'
-        
-        Returns:
-        --------
-        np.ndarray
-            Array booleano indicando outliers
-        """
-        if isinstance(data, pd.Series):
-            data = data.values
-        
-        data_clean = data[~np.isnan(data)]
-        
-        if method == 'iqr':
-            q1 = np.percentile(data_clean, 25)
-            q3 = np.percentile(data_clean, 75)
-            iqr = q3 - q1
-            lower_bound = q1 - 1.5 * iqr
-            upper_bound = q3 + 1.5 * iqr
-            outliers = (data_clean < lower_bound) | (data_clean > upper_bound)
-            
-        elif method == 'zscore':
-            threshold = kwargs.get('threshold', 3)
-            z_scores = np.abs((data_clean - np.mean(data_clean)) / np.std(data_clean))
-            outliers = z_scores > threshold
-            
-        elif method == 'isolation_forest':
-            from sklearn.ensemble import IsolationForest
-            contamination = kwargs.get('contamination', 0.1)
-            X = data_clean.reshape(-1, 1)
-            clf = IsolationForest(contamination=contamination, random_state=42)
-            outliers = clf.fit_predict(X) == -1
-            
-        else:
-            raise ValueError("Método debe ser 'iqr', 'zscore', o 'isolation_forest'")
-        
-        return outliers
-
-    def calculate_effect_size(self, group1: np.ndarray, group2: np.ndarray, 
-                             method: Literal['cohen', 'hedges'] = 'cohen') -> dict:
-        """
-        Calcula el tamaño del efecto entre dos grupos
-        """
-        mean1, mean2 = np.mean(group1), np.mean(group2)
-        std1, std2 = np.std(group1, ddof=1), np.std(group2, ddof=1)
-        n1, n2 = len(group1), len(group2)
-        
-        pooled_std = np.sqrt(((n1 - 1) * std1**2 + (n2 - 1) * std2**2) / (n1 + n2 - 2))
-        cohens_d = (mean1 - mean2) / pooled_std
-        
-        if method == 'hedges':
-            correction = 1 - (3 / (4 * (n1 + n2) - 9))
-            effect_size = cohens_d * correction
-        else:
-            effect_size = cohens_d
-        
-        abs_effect = abs(effect_size)
-        if abs_effect < 0.2:
-            interpretation = "Muy pequeño"
-        elif abs_effect < 0.5:
-            interpretation = "Pequeño"
-        elif abs_effect < 0.8:
-            interpretation = "Mediano"
-        else:
-            interpretation = "Grande"
-        
-        return {
-            'effect_size': effect_size,
-            'method': method,
-            'interpretation': interpretation,
-            'mean_diff': mean1 - mean2,
-            'pooled_std': pooled_std
-        }
-
-    # ============= MÉTODOS DE VISUALIZACIÓN COMPLETOS =============
-
-    def _plot_distribution_seaborn(self, data, plot_type, bins, figsize, title, **kwargs):
-        """Implementación con seaborn"""
-        if plot_type == 'all':
-            fig, axes = plt.subplots(2, 2, figsize=(15, 12))
-            
-            # Histograma
-            sns.histplot(data, bins=bins, kde=True, ax=axes[0, 0])
-            axes[0, 0].set_title('Histograma con KDE')
-            
-            # Box plot
-            sns.boxplot(y=data, ax=axes[0, 1])
-            axes[0, 1].set_title('Box Plot')
-            
-            # Violin plot
-            sns.violinplot(y=data, ax=axes[1, 0])
-            axes[1, 0].set_title('Violin Plot')
-            
-            # Q-Q plot
-            stats.probplot(data, dist="norm", plot=axes[1, 1])
-            axes[1, 1].set_title('Q-Q Plot')
-            
-            fig.suptitle(title, fontsize=16, y=1.00)
-            plt.tight_layout()
-            
-        else:
-            fig, ax = plt.subplots(figsize=figsize)
-            
-            if plot_type == 'hist':
-                sns.histplot(data, bins=bins, kde=True, ax=ax, **kwargs)
-            elif plot_type == 'kde':
-                sns.kdeplot(data, ax=ax, **kwargs)
-            elif plot_type == 'box':
-                sns.boxplot(y=data, ax=ax, **kwargs)
-            elif plot_type == 'violin':
-                sns.violinplot(y=data, ax=ax, **kwargs)
-            
-            ax.set_title(title)
-            plt.tight_layout()
-        
-        return fig
-
-    def _plot_distribution_matplotlib(self, data, plot_type, bins, figsize, title, **kwargs):
-        """Implementación con matplotlib puro"""
-        if plot_type == 'all':
-            fig, axes = plt.subplots(2, 2, figsize=(15, 12))
-            
-            # Histograma
-            axes[0, 0].hist(data, bins=bins, alpha=0.7, edgecolor='black', density=True)
-            axes[0, 0].set_title('Histograma')
-            axes[0, 0].set_ylabel('Densidad')
-            
-            # Box plot
-            axes[0, 1].boxplot(data)
-            axes[0, 1].set_title('Box Plot')
-            
-            # KDE
-            from scipy.stats import gaussian_kde
-            kde = gaussian_kde(data)
-            x_range = np.linspace(data.min(), data.max(), 100)
-            axes[1, 0].plot(x_range, kde(x_range))
-            axes[1, 0].fill_between(x_range, kde(x_range), alpha=0.3)
-            axes[1, 0].set_title('KDE')
-            axes[1, 0].set_ylabel('Densidad')
-            
-            # Q-Q plot
-            stats.probplot(data, dist="norm", plot=axes[1, 1])
-            axes[1, 1].set_title('Q-Q Plot')
-            
-            fig.suptitle(title, fontsize=16)
-            plt.tight_layout()
-            
-        else:
-            fig, ax = plt.subplots(figsize=figsize)
-            
-            if plot_type == 'hist':
-                ax.hist(data, bins=bins, edgecolor='black', alpha=0.7, **kwargs)
-                ax.set_ylabel('Frecuencia')
-            elif plot_type == 'box':
-                ax.boxplot(data, vert=True)
-            elif plot_type == 'kde':
-                from scipy.stats import gaussian_kde
-                kde = gaussian_kde(data)
-                x_range = np.linspace(data.min(), data.max(), 100)
-                ax.plot(x_range, kde(x_range), **kwargs)
-                ax.fill_between(x_range, kde(x_range), alpha=0.3)
-                ax.set_ylabel('Densidad')
-        
-            ax.set_title(title)
-            ax.grid(True, alpha=0.3)
-            plt.tight_layout()
-        
-        return fig
-
-    def plot_distribution(self, data: Union[pd.DataFrame, pd.Series, np.ndarray],
-                         column: Optional[str] = None,
-                         plot_type: Literal['hist', 'kde', 'box', 'violin', 'all'] = 'hist',
-                         backend: Optional[Literal['matplotlib', 'seaborn', 'plotly']] = "seaborn",
-                         bins: int = 30,
-                         figsize: Optional[Tuple[int, int]] = None,
-                         save_fig: Optional[bool] = None,
-                         filename: Optional[str] = None,
-                         **kwargs):
-        """
-        Graficar distribución de una variable
-        
-        Parameters:
-        -----------
-        data : DataFrame, Series o ndarray
-            Datos a graficar
-        column : str, optional
-            Columna a graficar (si data es DataFrame)
-        plot_type : str
-            Tipo de gráfico
-        backend : str, optional
-            Backend de visualización
-        bins : int
-            Número de bins para histograma
-        figsize : tuple, optional
-            Tamaño de la figura
-        save_fig : bool, optional
-            Si guardar la figura
-        filename : str, optional
-            Nombre del archivo
-        """
-        backend = backend or self._plot_backend
-        figsize = figsize or self._default_figsize
-        save_fig = save_fig if save_fig is not None else self._save_fig
-        
-        # Extraer datos
-        if isinstance(data, pd.DataFrame):
-            if column is None:
-                raise ValueError("Debe especificar 'column' cuando data es DataFrame")
-            plot_data = data[column].dropna()
-            title = f"Distribución de {column}"
-            default_filename = f"distribucion_{column}"
-        elif isinstance(data, pd.Series):
-            plot_data = data.dropna()
-            title = f"Distribución de {data.name if data.name else 'Variable'}"
-            default_filename = f"distribucion_{data.name if data.name else 'variable'}"
-        else:
-            plot_data = pd.Series(data).dropna()
-            title = "Distribución"
-            default_filename = "distribucion"
-        
-        filename = filename or default_filename
-        
-        try:
-            if backend == 'seaborn':
-                fig = self._plot_distribution_seaborn(plot_data, plot_type, bins, figsize, title, **kwargs)
-            elif backend == 'matplotlib':
-                fig = self._plot_distribution_matplotlib(plot_data, plot_type, bins, figsize, title, **kwargs)
-            elif backend == 'plotly':
-                fig = self._plot_distribution_plotly(plot_data, plot_type, bins, title, **kwargs)
-            else:
-                raise ValueError(f"Backend '{backend}' no soportado")
-            
-            # Guardar figura si está activado
-            if save_fig and backend != 'plotly':
-                self._save_figure(fig, filename)
-            
-            return fig
-            
-        except Exception as e:
-            print(f"Error en plot_distribution: {e}")
-            raise
-
-    def _plot_distribution_plotly(self, data, plot_type, bins, title, **kwargs):
-        """Implementación con plotly"""
-        try:
-            import plotly.graph_objects as go
-            import plotly.express as px
-            from plotly.subplots import make_subplots
-        except ImportError:
-            raise ImportError("Plotly no está instalado. Instale con: pip install plotly")
-        
-        if plot_type == 'all':
-            fig = make_subplots(
-                rows=2, cols=2,
-                subplot_titles=('Histograma', 'Box Plot', 'Violin Plot', 'Distribución Acumulada')
-            )
-            
-            # Histograma
-            fig.add_trace(go.Histogram(x=data, nbinsx=bins, name='Histograma'), row=1, col=1)
-            
-            # Box plot
-            fig.add_trace(go.Box(y=data, name='Box Plot'), row=1, col=2)
-            
-            # Violin plot
-            fig.add_trace(go.Violin(y=data, name='Violin Plot'), row=2, col=1)
-            
-            # Distribución acumulada
-            hist, bin_edges = np.histogram(data, bins=bins, density=True)
-            cdf = np.cumsum(hist * np.diff(bin_edges))
-            fig.add_trace(go.Scatter(x=bin_edges[1:], y=cdf, name='CDF'), row=2, col=2)
-            
-        else:
-            if plot_type == 'hist':
-                fig = px.histogram(data, nbins=bins, title=title)
-            elif plot_type == 'box':
-                fig = px.box(y=data, title=title)
-            elif plot_type == 'violin':
-                fig = px.violin(y=data, title=title, box=True)
-            else:
-                fig = px.histogram(data, nbins=bins, title=title)
-        
-        return fig
-
-    def plot_correlation_matrix(self, data: pd.DataFrame,
-                               method: str = 'pearson',
-                               backend: Optional[Literal['seaborn', 'plotly']] = None,
-                               figsize: Optional[Tuple[int, int]] = None,
-                               save_fig: Optional[bool] = None,
-                               filename: Optional[str] = None,
-                               **kwargs):
-        """
-        Visualizar matriz de correlación
-        
-        Parameters:
-        -----------
-        data : DataFrame
-            Datos para calcular correlación
-        method : str
-            'pearson', 'spearman' o 'kendall'
-        backend : str, optional
-            Backend de visualización
-        """
-        backend = backend or self._plot_backend
-        figsize = figsize or self._default_figsize
-        save_fig = save_fig if save_fig is not None else self._save_fig
-        filename = filename or "matriz_correlacion"
-        
-        # Calcular matriz de correlación
-        corr_matrix = data.corr(method=method)
-        
-        if backend == 'seaborn':
-            fig, ax = plt.subplots(figsize=figsize)
-            mask = np.triu(np.ones_like(corr_matrix, dtype=bool))
-            
-            sns.heatmap(corr_matrix, mask=mask, annot=True, fmt='.2f', 
-                       cmap='coolwarm', center=0, ax=ax,
-                       square=True, linewidths=0.5, **kwargs)
-            ax.set_title(f'Matriz de Correlación ({method})', fontsize=14, pad=20)
-            plt.tight_layout()
-            
-        elif backend == 'plotly':
-            import plotly.graph_objects as go
-            
-            fig = go.Figure(data=go.Heatmap(
-                z=corr_matrix.values,
-                x=corr_matrix.columns,
-                y=corr_matrix.index,
-                colorscale='RdBu',
-                zmid=0,
-                text=corr_matrix.values,
-                texttemplate='%{text:.2f}',
-                textfont={"size": 10},
-                **kwargs
-            ))
-            
-            fig.update_layout(
-                title=f'Matriz de Correlación ({method})',
-                xaxis_title='Variables',
-                yaxis_title='Variables',
-                width=figsize[0]*100,
-                height=figsize[1]*100
-            )
-        
-        # Guardar figura
-        if save_fig:
-            if backend == 'seaborn':
-                self._save_figure(fig, filename)
-            elif backend == 'plotly':
-                try:
-                    os.makedirs(self._figures_dir, exist_ok=True)
-                    filepath = os.path.join(self._figures_dir, f"{filename}.{self._fig_format}")
-                    fig.write_image(filepath)
-                    print(f"✓ Figura Plotly guardada: {filepath}")
-                except Exception as e:
-                    print(f"✗ Error guardando figura Plotly: {e}")
-        
-        return fig
-
-    def plot_scatter_matrix(self, data: pd.DataFrame,
-                           columns: Optional[List[str]] = None,
-                           backend: Optional[Literal['seaborn', 'plotly', 'pandas']] = None,
-                           figsize: Optional[Tuple[int, int]] = None,
-                           save_fig: Optional[bool] = None,
-                           filename: Optional[str] = None,
-                           **kwargs):
-        """
-        Matriz de gráficos de dispersión (pairplot)
-        """
-        backend = backend or self._plot_backend
-        figsize = figsize or self._default_figsize
-        save_fig = save_fig if save_fig is not None else self._save_fig
-        filename = filename or "scatter_matrix"
-        
-        if columns:
-            data = data[columns]
-        
-        if backend == 'seaborn':
-            fig = sns.pairplot(data, **kwargs)
-            fig.fig.suptitle('Matriz de Dispersión', y=1.02)
-            
-        elif backend == 'plotly':
-            import plotly.express as px
-            fig = px.scatter_matrix(data, **kwargs)
-            fig.update_layout(title='Matriz de Dispersión')
-            
-        elif backend == 'pandas':
-            from pandas.plotting import scatter_matrix
-            fig, ax = plt.subplots(figsize=figsize)
-            scatter_matrix(data, ax=ax, **kwargs)
-        
-        # Guardar figura
-        if save_fig:
-            if backend in ['seaborn', 'pandas']:
-                self._save_figure(fig.figure if hasattr(fig, 'figure') else fig, filename)
-            elif backend == 'plotly':
-                try:
-                    os.makedirs(self._figures_dir, exist_ok=True)
-                    filepath = os.path.join(self._figures_dir, f"{filename}.{self._fig_format}")
-                    fig.write_image(filepath)
-                    print(f"✓ Figura Plotly guardada: {filepath}")
-                except Exception as e:
-                    print(f"✗ Error guardando figura Plotly: {e}")
-        
-        return fig
-
-    # ============= GRÁFICOS CON INTERVALOS DE CONFIANZA =============
-
-    def plot_distribution_with_ci(self, 
-                                 data: Union[pd.DataFrame, pd.Series, np.ndarray],
-                                 column: Optional[str] = None,
-                                 confidence_level: float = 0.95,
-                                 ci_method: str = 'parametric',
-                                 bins: int = 30,
-                                 figsize: Optional[Tuple[int, int]] = None,
-                                 save_fig: Optional[bool] = None,
-                                 filename: Optional[str] = None,
-                                 **kwargs) -> plt.Figure:
-        """
-        Grafica la distribución junto con intervalos de confianza
-        """
-        # Extraer y limpiar datos
-        if isinstance(data, pd.DataFrame):
-            if column is None:
-                raise ValueError("Debe especificar 'column' cuando data es DataFrame")
-            plot_data = data[column].dropna()
-            data_name = column
-        elif isinstance(data, pd.Series):
-            plot_data = data.dropna()
-            data_name = data.name if data.name else 'Variable'
-        else:
-            plot_data = pd.Series(data).dropna()
-            data_name = 'Variable'
-        
-        data_array = plot_data.values
-        default_filename = f"distribucion_ci_{data_name.lower().replace(' ', '_')}"
-        filename = filename or default_filename
-        
-        # Calcular estadísticas e intervalos de confianza
-        ci_result = self.calculate_confidence_intervals(data_array, confidence_level, ci_method)
-        normality_result = self.check_normality(data_array)
-        
-        # Crear figura con dos subgráficas
-        fig, (ax1, ax2) = plt.subplots(1, 2, figsize=figsize or (14, 6))
-        
-        # ===== PRIMERA GRÁFICA: Distribución básica =====
-        n, bins, patches = ax1.hist(data_array, bins=bins, alpha=0.7, 
-                                   color='skyblue', edgecolor='black', 
-                                   density=True, label='Histograma')
-        
-        # KDE
-        kde = stats.gaussian_kde(data_array)
-        x_range = np.linspace(data_array.min(), data_array.max(), 200)
-        ax1.plot(x_range, kde(x_range), 'r-', linewidth=2, label='KDE')
-        
-        # Línea vertical en la media
-        ax1.axvline(ci_result['mean'], color='red', linestyle='--', 
-                   linewidth=2, label=f'Media: {ci_result["mean"]:.2f}')
-        
-        ax1.set_xlabel('Valores')
-        ax1.set_ylabel('Densidad')
-        ax1.set_title(f'Distribución de {data_name}\n'
-                     f'Media: {ci_result["mean"]:.2f}, '
-                     f'Desv. Est.: {ci_result["std"]:.2f}')
-        ax1.legend()
-        ax1.grid(True, alpha=0.3)
-        
-        # ===== SEGUNDA GRÁFICA: Distribución con intervalos de confianza =====
-        n, bins, patches = ax2.hist(data_array, bins=bins, alpha=0.7, 
-                                   color='lightgreen', edgecolor='black', 
-                                   density=True, label='Histograma')
-        
-        # KDE
-        ax2.plot(x_range, kde(x_range), 'r-', linewidth=2, label='KDE')
-        
-        # Media y intervalos de confianza
-        ax2.axvline(ci_result['mean'], color='red', linestyle='-', 
-                   linewidth=3, label=f'Media: {ci_result["mean"]:.2f}')
-        
-        # Intervalo de confianza
-        ax2.axvspan(ci_result['ci_lower'], ci_result['ci_upper'], 
-                   alpha=0.3, color='orange', 
-                   label=f'IC {confidence_level*100}%: [{ci_result["ci_lower"]:.2f}, {ci_result["ci_upper"]:.2f}]')
-        
-        # Líneas para los límites del IC
-        ax2.axvline(ci_result['ci_lower'], color='orange', linestyle='--', linewidth=2)
-        ax2.axvline(ci_result['ci_upper'], color='orange', linestyle='--', linewidth=2)
-        
-        # Distribución normal teórica (si los datos son normales)
-        if normality_result['is_normal']:
-            normal_x = np.linspace(data_array.min(), data_array.max(), 200)
-            normal_y = stats.norm.pdf(normal_x, ci_result['mean'], ci_result['std'])
-            ax2.plot(normal_x, normal_y, 'g--', linewidth=2, alpha=0.7, 
-                    label='Distribución Normal Teórica')
-        
-        ax2.set_xlabel('Valores')
-        ax2.set_ylabel('Densidad')
-        ax2.set_title(f'Distribución con Intervalos de Confianza\n'
-                     f'Método: {ci_method}, n={ci_result["n"]}')
-        ax2.legend()
-        ax2.grid(True, alpha=0.3)
-        
-        # Información adicional como texto
-        info_text = (f'Estadísticas:\n'
-                    f'• Media: {ci_result["mean"]:.3f}\n'
-                    f'• Desv. Est.: {ci_result["std"]:.3f}\n'
-                    f'• n: {ci_result["n"]}\n'
-                    f'• IC {confidence_level*100}%: [{ci_result["ci_lower"]:.3f}, {ci_result["ci_upper"]:.3f}]\n'
-                    f'• Margen Error: ±{ci_result["margin_error"]:.3f}\n'
-                    f'• Normalidad: {normality_result["interpretation"]}\n'
-                    f'• p-value: {normality_result["shapiro_pvalue"]:.4f}')
-        
-        fig.text(0.02, 0.02, info_text, fontsize=9, 
-                bbox=dict(boxstyle="round,pad=0.5", facecolor="lightgray", alpha=0.7),
-                verticalalignment='bottom')
-        
-        plt.tight_layout()
-        
-        # Guardar figura si está activado
-        save_fig = save_fig if save_fig is not None else self._save_fig
-        if save_fig:
-            self._save_figure(fig, filename)
-        
-        return fig
-
-    def plot_multiple_distributions_with_ci(self, 
-                                           data_dict: dict,
-                                           confidence_level: float = 0.95,
-                                           figsize: Optional[Tuple[int, int]] = None,
-                                           save_fig: Optional[bool] = None,
-                                           filename: Optional[str] = None,
-                                           **kwargs) -> plt.Figure:
-        """
-        Grafica múltiples distribuciones con sus intervalos de confianza
-        """
-        n_distributions = len(data_dict)
-        fig, axes = plt.subplots(n_distributions, 2, 
-                               figsize=figsize or (14, 5 * n_distributions))
-        
-        if n_distributions == 1:
-            axes = axes.reshape(1, -1)
-        
-        colors = plt.cm.Set3(np.linspace(0, 1, n_distributions))
-        
-        for idx, (name, data) in enumerate(data_dict.items()):
-            ax1, ax2 = axes[idx]
-            
-            if isinstance(data, pd.Series):
-                data_array = data.dropna().values
-            else:
-                data_array = np.array(data)
-                data_array = data_array[~np.isnan(data_array)]
-            
-            # Calcular estadísticas
-            ci_result = self.calculate_confidence_intervals(data_array, confidence_level)
-            
-            # Gráfica izquierda: Distribución básica
-            ax1.hist(data_array, bins=30, alpha=0.7, color=colors[idx], 
-                    edgecolor='black', density=True)
-            
-            kde = stats.gaussian_kde(data_array)
-            x_range = np.linspace(data_array.min(), data_array.max(), 200)
-            ax1.plot(x_range, kde(x_range), 'k-', linewidth=2)
-            ax1.axvline(ci_result['mean'], color='red', linestyle='--', linewidth=2)
-            
-            ax1.set_title(f'{name}\nMedia: {ci_result["mean"]:.2f}')
-            ax1.grid(True, alpha=0.3)
-            
-            # Gráfica derecha: Con intervalos de confianza
-            ax2.hist(data_array, bins=30, alpha=0.7, color=colors[idx], 
-                    edgecolor='black', density=True)
-            ax2.plot(x_range, kde(x_range), 'k-', linewidth=2)
-            
-            ax2.axvline(ci_result['mean'], color='red', linestyle='-', linewidth=3)
-            ax2.axvspan(ci_result['ci_lower'], ci_result['ci_upper'], 
-                       alpha=0.3, color='orange')
-            ax2.axvline(ci_result['ci_lower'], color='orange', linestyle='--', linewidth=2)
-            ax2.axvline(ci_result['ci_upper'], color='orange', linestyle='--', linewidth=2)
-            
-            ax2.set_title(f'{name} con IC {confidence_level*100}%')
-            ax2.grid(True, alpha=0.3)
-        
-        plt.tight_layout()
-        
-        # Guardar figura si está activado
-        save_fig = save_fig if save_fig is not None else self._save_fig
-        if save_fig:
-            filename = filename or "multiples_distribuciones_ci"
-            self._save_figure(fig, filename)
-        
-        return fig
-
-    # ============= MÉTODOS UTILITARIOS ADICIONALES =============
-
-    def get_descriptive_stats(self, data: Union[pd.DataFrame, pd.Series, np.ndarray],
-                             column: Optional[str] = None) -> dict:
-        """
-        Obtiene estadísticas descriptivas completas
-        """
-        if isinstance(data, pd.DataFrame):
-            if column is None:
-                raise ValueError("Debe especificar 'column' cuando data es DataFrame")
-            data_series = data[column]
-        elif isinstance(data, pd.Series):
-            data_series = data
-        else:
-            data_series = pd.Series(data)
-        
-        data_clean = data_series.dropna()
-        
-        return {
-            'count': len(data_clean),
-            'mean': np.mean(data_clean),
-            'median': np.median(data_clean),
-            'mode': stats.mode(data_clean)[0][0] if len(data_clean) > 0 else np.nan,
-            'std': np.std(data_clean, ddof=1),
-            'variance': np.var(data_clean, ddof=1),
-            'min': np.min(data_clean),
-            'max': np.max(data_clean),
-            'q1': np.percentile(data_clean, 25),
-            'q3': np.percentile(data_clean, 75),
-            'iqr': np.percentile(data_clean, 75) - np.percentile(data_clean, 25),
-            'skewness': stats.skew(data_clean),
-            'kurtosis': stats.kurtosis(data_clean),
-            'range': np.max(data_clean) - np.min(data_clean)
-        }
-
-    def help(self):
-        """
-        Muestra ayuda completa de la clase UtilsStats
-        """
-        help_text = """
-            📊 CLASE UtilsStats - AYUDA COMPLETA
-
-            Clase utilitaria para análisis estadísticos y visualización de datos.
-
-            🔧 MÉTODOS PRINCIPALES:
-
-            1. 📈 ANÁLISIS ESTADÍSTICO:
-            • check_normality()           # Test de normalidad
-            • calculate_confidence_intervals()  # Intervalos de confianza
-            • detect_outliers()           # Detección de outliers
-            • calculate_effect_size()     # Tamaño del efecto
-            • get_descriptive_stats()     # Estadísticas descriptivas
-
-            2. 🎨 VISUALIZACIÓN:
-            • plot_distribution()         # Gráficos de distribución
-            • plot_distribution_with_ci() # Distribución con IC
-            • plot_multiple_distributions_with_ci() # Múltiples distribuciones
-            • plot_correlation_matrix()   # Matriz de correlación
-            • plot_scatter_matrix()       # Matriz de dispersión
-
-            3. ⚙️ CONFIGURACIÓN:
-            • set_plot_backend()          # Backend de visualización
-            • set_default_figsize()       # Tamaño de figura
-            • set_save_fig_options()      # Opciones para guardar
-
-            4. 🛠️ UTILIDADES:
-            • validate_dataframe()        # Validación de datos
-            • format_number()             # Formateo de números
-
-            💡 EJEMPLOS DE USO:
-
-            # Inicializar
-            utils = UtilsStats()
-
-            # Análisis de normalidad
-            normalidad = utils.check_normality(mis_datos)
-
-            # Gráfico con intervalos de confianza
-            fig = utils.plot_distribution_with_ci(
-                data=mis_datos,
-                confidence_level=0.95,
-                bins=20
-            )
-
-            # Matriz de correlación
-            fig_corr = utils.plot_correlation_matrix(
-                data=mi_dataframe,
-                method='pearson'
-            )
-
-            # Estadísticas descriptivas
-            stats = utils.get_descriptive_stats(mis_datos)
-
-            🎯 CARACTERÍSTICAS:
-            • Múltiples backends: matplotlib, seaborn, plotly
-            • Guardado automático de figuras
-            • Manejo robusto de datos faltantes
-            • Visualizaciones profesionales listas para publicación
-            • Integración perfecta con Jupyter notebooks
-            """
-        print(help_text)