Upload app.R

app.R

@@ -2,7 +2,7 @@ library(plumber)
 
 #* @apiTitle Effect Size Calculator API
 
-d.quantile <- function(x1, x2, degree = 4, CI = .95, silent = T) {
+d.quantile <- function(x1, x2, degree = 5, CI = NA, silent = T) {
   
   # Input validation
   if (!is.numeric(x1) || !is.numeric(x2)) {
@@ -52,8 +52,8 @@ d.quantile <- function(x1, x2, degree = 4, CI = .95, silent = T) {
   }
   
   # Step 2: Get the moments from each fitted model
-  moments1 <- get_moments_analytical(model1, group_label = "Group 1")
-  moments2 <- get_moments_analytical(model2, group_label = "Group 2")
+  moments1 <- get_moments(model1, group_label = "Group 1")
+  moments2 <- get_moments(model2, group_label = "Group 2")
   
   # Step 3: Calculate the pooled standard deviation
   weighted_pooled_variance <- (n1 * moments1$variance + n2 * moments2$variance) / (n1 + n2)
@@ -80,21 +80,18 @@ d.quantile <- function(x1, x2, degree = 4, CI = .95, silent = T) {
     group1_mean = moments1$mean,
     group1_variance = moments1$variance,
     group1_sd = sqrt(moments1$variance),
-	group1_sd_classic = sd(x1),
-	group1_m_classic = mean(x1),
     group2_mean = moments2$mean,
     group2_variance = moments2$variance,
     group2_sd = sqrt(moments2$variance),
-	group2_sd_classic = sd(x2),
-	group2_m_classic = mean(x2),
     pooled_sd = pooled_sd,
     n1 = n1,
     n2 = n2,
-    degree = degree,
     model1 = model1,
-    model2 = model2
+    model2 = model2,
+    default_degree = degree
   )
   
+  
   if(!is.na(CI)) {
     if(CI <= 0 || CI >= 1) {
       stop("CI must be between 0 and 1 (exclusive).")
@@ -124,14 +121,56 @@ d.quantile <- function(x1, x2, degree = 4, CI = .95, silent = T) {
   return(result)
 }
 
+
+#' Fit a Polynomial to the Quantile Function
+#'
+#' This helper function fits a polynomial regression model to represent the
+#' quantile function of a distribution. It models the relationship between
+#' standard normal quantiles (z-scores) and observed raw scores.
+#'
+#' @param x A numeric vector of observations.
+#' @param poly_degree The degree of the polynomial to fit.
+#' @param check_monotonicity Logical; should monotonicity be enforced by 
+#'   reducing polynomial degree if needed? (default = FALSE for speed)
+#' @param min_degree Minimum polynomial degree to try (default = 1, representing
+#'   a linear fit to a normal distribution).
+#'
+#' @return An lm model object representing x = f(z), where z ~ N(0,1).
+#'   Additional attributes:
+#'   \describe{
+#'     \item{sample_size}{Original sample size}
+#'     \item{n_unique}{Number of unique values (for tie detection)}
+#'     \item{tie_proportion}{Proportion of tied observations}
+#'     \item{poly_degree}{Actual polynomial degree used (may be reduced)}
+#'     \item{monotonic}{Logical; is the fitted function monotonic?}
+#'     \item{degree_reduced}{Logical; was degree reduced from requested?}
+#'   }
+#'
+#' @details
+#' The function uses average ranks (midrank method) to handle tied observations,
+#' which is the standard approach in rank-based statistics. Plotting positions 
+#' (rank - 0.5)/n avoid infinite z-scores at boundaries.
+#'
+#' When substantial ties are present (>10% of observations), the function may
+#' automatically reduce the polynomial degree to avoid overfitting to a small
+#' number of unique values.
+#'
+#' If check_monotonicity=TRUE, the function iteratively reduces the polynomial
+#' degree until a monotonic fit is achieved or min_degree is reached.
+#'
+#' @author Wolfgang Lenhard and Alexandra Lenhard
+#' Licensed under the MIT License
+#'
+#' Citation:
+#'   Lenhard, W. & Lenhard, A. (submitted). Distribution-Free Effect Size Estimation: 
+#'   A Robust Alternative to Cohen’s d.
+#'
+#' @export
 fit_quantile_function <- function(x, poly_degree, 
                                   check_monotonicity = FALSE,
                                   min_degree = 1) {
   
-  # ============================================================================
   # Step 1: Input validation and tie detection
-  # ============================================================================
-  
   n <- length(x)
   
   if (n < 3) {
@@ -142,10 +181,7 @@ fit_quantile_function <- function(x, poly_degree,
   n_unique <- length(unique(x))
   tie_proportion <- 1 - (n_unique / n)
   
-  # ============================================================================
   # Step 2: Adjust polynomial degree based on unique values
-  # ============================================================================
-  
   # Can't fit more parameters than unique data points
   max_possible_degree <- n_unique - 1
   
@@ -180,12 +216,8 @@ fit_quantile_function <- function(x, poly_degree,
     ), min_degree + 1)
   }
   
-  # ============================================================================
   # Step 3: Compute ranks and z-scores (handles ties via midrank)
-  # ============================================================================
-  
   # Average ranks handle ties by assigning mean rank to tied observations
-  # Example: values [1, 2, 2, 3] get ranks [1, 2.5, 2.5, 4]
   avg_ranks <- rank(x, ties.method = "average")
   
   # Convert ranks to plotting positions
@@ -194,113 +226,305 @@ fit_quantile_function <- function(x, poly_degree,
   # Transform to standard normal quantiles
   z <- qnorm(p)
   
-  # ============================================================================
   # Step 4: Fit polynomial, with optional monotonicity enforcement
-  # ============================================================================
+  check_range <- range(z)
   
   current_degree <- poly_degree
   degree_reduced <- FALSE
-  monotonic <- NULL  # Will be checked if requested
+  monotonic <- FALSE
   
   if (check_monotonicity) {
-    # Iteratively reduce degree until monotonic or min_degree reached
     while (current_degree >= min_degree) {
       
-      # Fit model at current degree
       model <- lm(x ~ poly(z, current_degree, raw = TRUE))
       
-      # Check monotonicity
-      monotonicity_check <- check_monotonicity(model)
-      monotonic <- monotonicity_check$is_monotonic
+      # Use the NEW analytic check
+      check <- check_monotonicity_analytic(model, z_range = check_range)
       
-      if (monotonic) {
-        # Success - monotonic fit achieved
+      if (check$is_monotonic) {
+        monotonic <- TRUE
         break
       }
       
-      # Not monotonic - try lower degree
+      # Reduce degree and try again
       current_degree <- current_degree - 1
       degree_reduced <- TRUE
     }
     
+    # Emergency fallback
     if (current_degree < min_degree) {
-      stop(sprintf(
-        "Could not achieve monotonic fit even with minimum degree %d. ",
-        min_degree,
-        "Data may be too irregular or have insufficient unique values."
-      ))
-    }
-    
-    if (degree_reduced) {
-      warning(sprintf(
-        "Polynomial degree reduced from %d to %d to achieve monotonicity.",
-        poly_degree, current_degree
-      ))
+      current_degree <- min_degree
+      # Fit linear even if non-monotonic (rare/impossible for degree 1 unless negative correlation)
+      model <- lm(x ~ poly(z, current_degree, raw = TRUE))
+      check <- check_monotonicity_analytic(model, z_range = check_range)
+      monotonic <- check$is_monotonic
     }
     
   } else {
-    # Just fit at requested degree without monotonicity check
     model <- lm(x ~ poly(z, current_degree, raw = TRUE))
-    
-    # Optionally check monotonicity for diagnostic purposes (don't enforce)
-    if (exists("check_monotonicity", mode = "function")) {
-      monotonicity_check <- check_monotonicity(model)
-      monotonic <- monotonicity_check$is_monotonic
-    }
+    check <- check_monotonicity(model, z_range = check_range)
+    monotonic <- check$is_monotonic
   }
   
-  # ============================================================================
-  # Step 5: Store metadata as attributes
-  # ============================================================================
-  
+  # Metadata
   attr(model, "sample_size") <- n
-  attr(model, "n_unique") <- n_unique
-  attr(model, "tie_proportion") <- tie_proportion
   attr(model, "poly_degree") <- current_degree
-  attr(model, "requested_degree") <- poly_degree
-  attr(model, "degree_reduced") <- degree_reduced
   attr(model, "monotonic") <- monotonic
-  attr(model, "has_ties") <- tie_proportion > 0.01  # Flag if >1% ties
+  attr(model, "min_derivative") <- check$min_derivative
   
   return(model)
 }
 
-check_monotonicity <- function(model, z_range = c(-3, 3), n_points = 100) {
+
+
+#' Check Monotonicity of Fitted Quantile Function
+#'
+#' Analytically checks if a polynomial quantile function is monotonic 
+#' within the observed range of the data.
+#'
+#' @param model An lm model object fitted with poly(..., raw=TRUE).
+#' @param z_range A numeric vector of length 2 defining the range [min, max]
+#'   over which to check monotonicity. If NULL, checks reasonable defaults 
+#'   based on N (-4 to 4).
+#' @param strictly_positive Logical; if TRUE, derivative must be > 0 (strict).
+#'   If FALSE, derivative can be >= 0 (allows flat regions).
+#'
+#' @return A list containing:
+#'   \item{is_monotonic}{Logical; TRUE if monotonic in range.}
+#'   \item{min_derivative}{The lowest slope found in the range.}
+#'   \item{location_min}{The z-value where the minimum slope occurs.}
+#'
+#'
+#' @author Wolfgang Lenhard and Alexandra Lenhard
+#' Licensed under the MIT License
+#'
+#' Citation:
+#'   Lenhard, W. & Lenhard, A. (submitted). Distribution-Free Effect Size Estimation: 
+#'   A Robust Alternative to Cohen’s d.
+#'   
+#' @export
+check_monotonicity <- function(model, z_range = c(-4, 4), 
+                                        strictly_positive = FALSE) {
+  
+  # Input handling
+  if (!inherits(model, "lm")) stop("model must be an lm object")
+  if (length(z_range) != 2 || z_range[1] >= z_range[2]) {
+    stop("z_range must be a vector [min, max] with min < max")
+  }
+  
+  # Extract polynomial coefficients
+  coeffs <- coef(model)
+  
+  # Handle NAs (rare cases where regression had failed)
+  if (any(is.na(coeffs))) return(list(
+    is_monotonic = FALSE, 
+    min_derivative = -Inf,
+    location_min = NA
+  ))
+  
+  degree <- length(coeffs) - 1
+  
+  # Special cases for low-degree polynomials
+  if (degree == 0) {
+    # CASE: Constant (Degree 0)
+    return(list(
+      is_monotonic = TRUE,
+      min_derivative = 0,
+      location_min = 0
+    ))
+  } else if (degree == 1) {
+    # CASE: Linear (Degree 1)
+    # f(z) = b0 + b1*z -> f'(z) = b1
+    slope <- coeffs[2]
+    return(list(
+      is_monotonic = if(strictly_positive) slope > 0 else slope >= 0,
+      min_derivative = slope,
+      location_min = 0
+    ))
+  }
+  
+  # 1. Calculate coefficients of First Derivative f'(z)
+  # f(z)  = c0 + c1*z + c2*z^2 + c3*z^3 ...
+  # f'(z) = c1 + 2*c2*z + 3*c3*z^2 ...
+  deriv1_coeffs <- numeric(degree) # Degree drops by 1
+  for (i in 1:degree) {
+    # Coeff index i+1 corresponds to power z^i in original model
+    deriv1_coeffs[i] <- coeffs[i + 1] * i 
+  }
   
-  z_seq <- seq(z_range[1], z_range[2], length.out = n_points)
+  # Define function to evaluate slope at specific z values
+  eval_deriv <- function(z, coefs) {
+    # Horner's method
+    val <- coefs[length(coefs)]
+    if (length(coefs) > 1) {
+      for (i in (length(coefs)-1):1) {
+        val <- val * z + coefs[i]
+      }
+    }
+    return(val)
+  }
   
-  # Get predictions
-  pred <- predict(model, newdata = data.frame(z = z_seq))
+  # 2. Find Critical Points of the Derivative
+  # To find where slope is minimized, we look for roots of f''(z)
   
-  # Calculate finite differences (approximate derivatives)
-  derivatives <- diff(pred) / diff(z_seq)
+  # Coefficients of f''(z)
+  degree_d1 <- degree - 1
+  if (degree_d1 >= 1) {
+    deriv2_coeffs <- numeric(degree_d1)
+    for (i in 1:degree_d1) {
+      deriv2_coeffs[i] <- deriv1_coeffs[i + 1] * i
+    }
+    
+    # Find roots (complex) of f''(z)
+    roots_complex <- polyroot(deriv2_coeffs)
+    
+    # Filter for real roots within the z_range
+    # Keep if imaginary part is negligible
+    real_indices <- abs(Im(roots_complex)) < 1e-9
+    roots_real <- Re(roots_complex)[real_indices]
+    
+    # Filter roots strictly inside our check range
+    critical_z <- roots_real[roots_real >= z_range[1] & roots_real <= z_range[2]]
+    
+  } else {
+    # If derivative is constant (should be handled by degree=1 check above)
+    critical_z <- numeric(0)
+  }
+  
+  # 3. Check Constraints (Boundaries + Critical Points)
+  # The minimum slope MUST occur either at endpoints or at a local extremum
+  
+  check_points <- unique(c(z_range[1], z_range[2], critical_z))
+  slopes <- sapply(check_points, eval_deriv, coefs = deriv1_coeffs)
   
-  # Check for violations (negative derivatives)
-  # Use small tolerance to avoid flagging numerical noise
-  tolerance <- -1e-6
-  violations <- sum(derivatives < tolerance)
+  min_slope <- min(slopes)
+  loc_min <- check_points[which.min(slopes)]
   
-  min_deriv <- min(derivatives)
-  is_monotonic <- violations == 0
+  threshold <- if(strictly_positive) 1e-9 else -1e-9
   
   return(list(
-    is_monotonic = is_monotonic,
-    min_derivative = min_deriv,
-    violations = violations,
-    proportion_violations = violations / length(derivatives),
-    z_range_checked = z_range
+    is_monotonic = min_slope >= threshold,
+    min_derivative = min_slope,
+    location_min = loc_min
   ))
 }
 
-get_moments_analytical <- function(model, group_label = "Unknown") {
+
+
+#' Calculate Moments from a Fitted Polynomial Quantile Function (Analytical)
+#'
+#' This function computes the mean and variance of the distribution represented 
+#' by a polynomial quantile function using closed-form analytical formulas 
+#' based on the raw moments of the standard normal distribution.
+#'
+#' @param model An lm model object from \code{\link{fit_quantile_function}()}.
+#'   The model should represent the relationship x = f(z) where z are standard 
+#'   normal quantiles and x are the observed values.
+#' @param group_label Optional character string label for warning messages 
+#'   (default = "Unknown"). Used to identify which group produced warnings in 
+#'   multi-group comparisons.
+#'
+#' @return A list with elements:
+#'   \item{mean}{The expected value E[X] where X = f(Z), Z ~ N(0,1).}
+#'   \item{variance}{The variance Var(X) = E[X²] - (E[X])².}
+#'
+#' @details
+#' This function provides an analytical alternative to numerical integration 
+#' for computing distributional moments. It exploits the fact that when the 
+#' quantile function is represented as a polynomial:
+#' 
+#' \deqn{f(z) = \sum_{j=0}^{k} \beta_j z^j}
+#' 
+#' the moments can be computed in closed form using the known raw moments of 
+#' the standard normal distribution.
+#' 
+#' \strong{Mathematical Foundation:}
+#' 
+#' The mean is computed as:
+#' \deqn{\mu = E[f(Z)] = \sum_{j=0}^{k} \beta_j E[Z^j]}
+#' 
+#' where \eqn{E[Z^j]} are the raw moments of the standard normal distribution:
+#' \itemize{
+#'   \item For odd j: \eqn{E[Z^j] = 0} (due to symmetry)
+#'   \item For even j: \eqn{E[Z^j] = (j-1)!!} (double factorial)
+#' }
+#' 
+#' The double factorial is defined as:
+#' \deqn{(j-1)!! = (j-1) \times (j-3) \times \ldots \times 3 \times 1}
+#' 
+#' Examples: \eqn{E[Z^0] = 1}, \eqn{E[Z^2] = 1}, \eqn{E[Z^4] = 3}, 
+#' \eqn{E[Z^6] = 15}, \eqn{E[Z^8] = 105}.
+#' 
+#' For a polynomial of degree k=5, the mean simplifies to:
+#' \deqn{\mu = \beta_0 + \beta_2 \cdot 1 + \beta_4 \cdot 3}
+#' 
+#' The variance is computed as:
+#' \deqn{\sigma^2 = E[X^2] - \mu^2}
+#' 
+#' where:
+#' \deqn{E[X^2] = E\left[\left(\sum_{i=0}^{k} \beta_i Z^i\right)^2\right] 
+#'       = \sum_{i=0}^{k} \sum_{j=0}^{k} \beta_i \beta_j E[Z^{i+j}]}
+#' 
+#' @section Theoretical Background:
+#' This approach is based on the principle that any random variable X can be 
+#' expressed as a transformation of a standard normal variable:
+#' \deqn{X = f(Z), \quad Z \sim N(0,1)}
+#' 
+#' Expectations with respect to X can then be computed as:
+#' \deqn{E[g(X)] = E[g(f(Z))] = \int_{-\infty}^{\infty} g(f(z)) \phi(z) dz}
+#' 
+#' When f is a polynomial, these integrals reduce to linear combinations of 
+#' standard normal moments, which are known analytically.
+#'
+#' @author Wolfgang Lenhard and Alexandra Lenhard
+#' Licensed under the MIT License
+#'
+#' Citation:
+#'   Lenhard, W. & Lenhard, A. (submitted). Distribution-Free Effect Size Estimation: 
+#'   A Robust Alternative to Cohen’s d.
+#'
+#' @seealso 
+#' \code{\link{get_moments}} for the numerical integration implementation.
+#' 
+#' \code{\link{fit_quantile_function}} for fitting the polynomial model.
+#' 
+#' \code{\link{d.quantile}} for the main effect size calculation.
+#'
+#' @examples
+#' # Generate sample data
+#' set.seed(123)
+#' x <- rnorm(50, mean = 100, sd = 15)
+#' 
+#' # Fit quantile function
+#' n <- length(x)
+#' avg_ranks <- rank(x, ties.method = "average")
+#' p <- (avg_ranks - 0.5) / n
+#' z <- qnorm(p)
+#' model <- lm(x ~ poly(z, 5, raw = TRUE))
+#' 
+#' # Compute moments analytically
+#' moments <- get_moments_analytical(model, group_label = "Test Group")
+#' 
+#' cat("Mean:", moments$mean, "\n")
+#' cat("Variance:", moments$variance, "\n")
+#' cat("SD:", sqrt(moments$variance), "\n")
+#' 
+#' # Compare with sample statistics
+#' cat("\nSample mean:", mean(x), "\n")
+#' cat("Sample variance:", var(x), "\n")
+#' 
+#' # The smoothed estimates will be similar but not identical,
+#' # with the analytical method providing regularization
+#' 
+#'
+#' @export
+get_moments <- function(model, group_label = "Unknown") {
   
   # Extract coefficients and determine polynomial degree
   coeffs <- coef(model)
   k <- length(coeffs) - 1  # polynomial degree
   
-  # --------------------------------------------------------------------------
   # Pre-compute standard normal raw moments: E[Z^j]
-  # --------------------------------------------------------------------------
   # For j even: E[Z^j] = (j-1)!! = (j-1) × (j-3) × ... × 3 × 1
   # For j odd:  E[Z^j] = 0 (due to symmetry)
   
@@ -321,9 +545,7 @@ get_moments_analytical <- function(model, group_label = "Unknown") {
   max_moment <- 2 * k
   moments_z <- sapply(0:max_moment, compute_moment)
   
-  # --------------------------------------------------------------------------
   # Compute mean: μ = E[X] = E[f(Z)] = Σ β_j E[Z^j]
-  # --------------------------------------------------------------------------
   # Only even-powered terms contribute due to symmetry
   
   mu <- 0
@@ -331,10 +553,8 @@ get_moments_analytical <- function(model, group_label = "Unknown") {
     mu <- mu + coeffs[j + 1] * moments_z[j + 1]
   }
   
-  # --------------------------------------------------------------------------
   # Compute variance: σ² = E[X²] - μ²
   # First calculate E[X²] = E[(Σ β_i Z^i)²] = Σ_i Σ_j β_i β_j E[Z^(i+j)]
-  # --------------------------------------------------------------------------
   
   E_X2 <- 0
   for (i in 0:k) {
@@ -348,12 +568,7 @@ get_moments_analytical <- function(model, group_label = "Unknown") {
   
   variance <- E_X2 - mu^2
   
-  # --------------------------------------------------------------------------
   # Handle numerical edge cases
-  # --------------------------------------------------------------------------
-  # Variance should always be non-negative, but numerical precision limits
-  # can occasionally produce tiny negative values
-  
   if (variance < 0) {
     if (abs(variance) < 1e-10) {
       # Likely just numerical noise - round to zero
@@ -372,10 +587,6 @@ get_moments_analytical <- function(model, group_label = "Unknown") {
     }
   }
   
-  # --------------------------------------------------------------------------
-  # Return results
-  # --------------------------------------------------------------------------
-  
   return(list(
     mean = mu, 
     variance = variance
@@ -383,6 +594,114 @@ get_moments_analytical <- function(model, group_label = "Unknown") {
 }
 
 
+
+
+#' Print Method for d_quantile Objects
+#'
+#' @param x An object of class "d_quantile"
+#' @param ... Additional arguments (not used)
+#' 
+#' @author Wolfgang Lenhard and Alexandra Lenhard
+#' Licensed under the MIT License
+#'
+#' Citation:
+#'   Lenhard, W. & Lenhard, A. (submitted). Distribution-Free Effect Size Estimation: 
+#'   A Robust Alternative to Cohen’s d.
+#'   
+#' @export
+print.d_quantile <- function(x, ...) {
+  cat("\nDistribution-Free Effect Size (d_q)\n")
+  cat("===================================\n\n")
+  cat("Effect size d_q:", round(x$d_q, 4), "\n")
+  
+  # Display CI if available
+  if (!is.null(x$ci_lower)) {
+    cat(sprintf("%d%% CI: [%.4f, %.4f]\n", 
+                round(x$ci_level * 100), 
+                x$ci_lower, 
+                x$ci_upper), "\n")
+  }
+  
+  cat("\nGroup 1: n =", x$n1, ", mean =", round(x$group1_mean, 4), 
+      ", SD =", round(x$group1_sd, 4), "\n")
+  cat("Group 2: n =", x$n2, ", mean =", round(x$group2_mean, 4), 
+      ", SD =", round(x$group2_sd, 4), "\n")
+  cat("Pooled SD:", round(x$pooled_sd, 4), "\n")
+  cat("Polynomial degree:", x$degree, "\n")
+  invisible(x)
+}
+
+#' Summary Method for d_quantile Objects
+#'
+#' Provides detailed summary statistics and diagnostic information.
+#'
+#' @param object An object of class "d_quantile"
+#' @param ... Additional arguments (not used)
+#'
+#' @author Wolfgang Lenhard and Alexandra Lenhard
+#' Licensed under the MIT License
+#'
+#' Citation:
+#'   Lenhard, W. & Lenhard, A. (submitted). Distribution-Free Effect Size Estimation: 
+#'   A Robust Alternative to Cohen’s d.
+#'   
+#' @export
+summary.d_quantile <- function(object, ...) {
+  
+  cat("\n")
+  cat("=======================================================\n")
+  cat("  Distribution-Free Effect Size Analysis (d_quantile)\n")
+  cat("=======================================================\n\n")
+  
+  cat("Effect Size:\n")
+  cat("  d_q =", round(object$d_q, 4), "\n")
+  
+  # Interpretation
+  abs_d <- abs(object$d_q)
+  interpretation <- if (abs_d < 0.2) {
+    "negligible"
+  } else if (abs_d < 0.5) {
+    "small"
+  } else if (abs_d < 0.8) {
+    "medium"
+  } else {
+    "large"
+  }
+  cat("  Interpretation:", interpretation, "\n\n")
+  
+  cat("Group 1:\n")
+  cat("  Sample size:      ", object$n1, "\n")
+  cat("  Mean (smoothed):  ", round(object$group1_mean, 4), "\n")
+  cat("  SD (smoothed):    ", round(object$group1_sd, 4), "\n")
+  cat("  Variance:         ", round(object$group1_variance, 4), "\n\n")
+  
+  cat("Group 2:\n")
+  cat("  Sample size:      ", object$n2, "\n")
+  cat("  Mean (smoothed):  ", round(object$group2_mean, 4), "\n")
+  cat("  SD (smoothed):    ", round(object$group2_sd, 4), "\n")
+  cat("  Variance:         ", round(object$group2_variance, 4), "\n\n")
+  
+  cat("Pooled Statistics:\n")
+  cat("  Pooled SD:        ", round(object$pooled_sd, 4), "\n")
+  cat("  Mean difference:  ", round(object$group2_mean - object$group1_mean, 4), "\n\n")
+  
+  cat("Model Details:\n")
+  cat("  Polynomial degree:", object$degree, "\n")
+  cat("  Model 1 R²:       ", round(summary(object$model1)$r.squared, 4), "\n")
+  cat("  Model 2 R²:       ", round(summary(object$model2)$r.squared, 4), "\n\n")
+  
+  if(!is.null(object$ci_lower) && !is.null(object$ci_upper)) {
+    cat(sprintf("Confidence Interval (%.1f%%): [%.4f, %.4f]\n\n", 
+                object$ci_level * 100, 
+                round(object$ci_lower, 4), 
+                round(object$ci_upper, 4)))
+  }
+  cat("=======================================================\n\n")
+  
+  invisible(object)
+}
+
+
 # API endpoint
 #* Calculate effect size from two groups
 #* @param group1 Comma-separated numeric values for group 1