/**
 * ConvergenceAnalysis — Grid convergence study utilities.
 *
 * Implements the methods from:
 *   Roache, P.J., "Verification and Validation in Computational Science
 *   and Engineering", Hermosa Publishers, 1998.
 *
 * Provides:
 * - Observed convergence order from error-vs-mesh-size data
 * - Richardson extrapolation for grid-independent solutions
 * - Grid Convergence Index (GCI) per Roache's method
 * - L2 and L-infinity error norms
 */
/**
 * L2 error norm: sqrt(sum((numerical - exact)^2) / N)
 */
export declare function errorL2(numerical: Float32Array | number[], exact: Float32Array | number[]): number;
/**
 * L-infinity error norm: max(|numerical - exact|)
 */
export declare function errorLinf(numerical: Float32Array | number[], exact: Float32Array | number[]): number;
/**
 * Relative L2 error norm: L2(numerical - exact) / L2(exact)
 */
export declare function relativeErrorL2(numerical: Float32Array | number[], exact: Float32Array | number[]): number;
/**
 * Compute observed convergence order from error data at multiple mesh sizes.
 *
 * Uses least-squares linear regression on log(h) vs log(error).
 * The slope is the observed convergence order p.
 *
 * For a method of order p: error = C * h^p → log(error) = log(C) + p*log(h)
 *
 * @param meshSizes  Array of characteristic mesh sizes (h)
 * @param errors     Corresponding error norms
 * @returns Observed convergence order (slope of log-log fit)
 */
export declare function computeObservedOrder(meshSizes: number[], errors: number[]): number;
/**
 * Compute convergence order from exactly two grid levels.
 * p = log(e_coarse / e_fine) / log(h_coarse / h_fine)
 */
export declare function convergenceOrderTwoLevel(hCoarse: number, errorCoarse: number, hFine: number, errorFine: number): number;
/**
 * Richardson extrapolation for grid-independent solution estimate.
 *
 * Given solutions on two grids with refinement ratio r:
 *   f_exact ≈ f_fine + (f_fine - f_coarse) / (r^p - 1)
 *
 * @param fCoarse Solution on coarser grid
 * @param fFine   Solution on finer grid
 * @param r       Grid refinement ratio (h_coarse / h_fine), typically 2
 * @param p       Observed or theoretical convergence order
 * @returns Estimated grid-independent ("exact") solution
 */
export declare function richardsonExtrapolation(fCoarse: number, fFine: number, r: number, p: number): number;
/**
 * Grid Convergence Index (GCI) per Roache's method.
 *
 * GCI provides an uncertainty band for the numerical solution.
 * The "true" solution is estimated to lie within f_fine +/- GCI.
 *
 * GCI = Fs * |epsilon| / (r^p - 1)
 *
 * where:
 *   epsilon = (f_fine - f_coarse) / f_fine  (relative error between grids)
 *   r = h_coarse / h_fine  (refinement ratio)
 *   p = observed convergence order
 *   Fs = safety factor (1.25 for 3+ grids, 3.0 for 2 grids)
 *
 * @returns GCI as a fraction (e.g., 0.02 = 2% uncertainty)
 */
export declare function gridConvergenceIndex(fCoarse: number, fFine: number, r: number, p: number, safetyFactor?: number): number;
export interface ConvergenceStudyResult {
    meshSizes: number[];
    errorsL2: number[];
    errorsLinf: number[];
    observedOrderL2: number;
    observedOrderLinf: number;
    richardsonEstimate?: number;
    gci?: number;
}
/**
 * Run a convergence study by executing a solver at multiple mesh refinement levels.
 *
 * @param runSolver  Function that takes a mesh size and returns {numerical, exact} arrays
 * @param meshSizes  Array of mesh sizes to test (e.g., [0.2, 0.1, 0.05, 0.025])
 * @param scalarExtractor  Optional function to extract a single scalar from the solution (for Richardson)
 */
export declare function runConvergenceStudy(runSolver: (h: number) => {
    numerical: Float32Array | number[];
    exact: Float32Array | number[];
}, meshSizes: number[], scalarExtractor?: (numerical: Float32Array | number[]) => number): ConvergenceStudyResult;
//# sourceMappingURL=ConvergenceAnalysis.d.ts.map