numopt-js 0.3.0 → 0.4.0

package/dist/index.cjs

@@ -59,7 +59,7 @@ function matrixToFloat64Array2D(matrix) {
  * Computes the L2 (Euclidean) norm of a Float64Array vector.
  * Used for convergence checks and gradient norm calculations.
  */
-function vectorNorm(vector) {
+function vectorNorm$1(vector) {
     let sumOfSquares = 0.0;
     for (let i = 0; i < vector.length; i++) {
         const value = vector[i];
@@ -99,7 +99,7 @@ function addVectors(vectorA, vectorB) {
  * Subtracts vectorB from vectorA element-wise.
  * Returns a new Float64Array with the result.
  */
-function subtractVectors(vectorA, vectorB) {
+function subtractVectors$1(vectorA, vectorB) {
     if (vectorA.length !== vectorB.length) {
         throw new Error('Vectors must have the same length for subtraction');
     }
@@ -131,20 +131,17 @@ function computeSumOfSquaredResiduals(residualNorm) {
 }
 
 /**
- * This file implements line search algorithms for determining optimal step sizes
- * in optimization algorithms. The implementation follows the backtracking
- * Armijo line search described in Nocedal & Wright, "Numerical Optimization"
- * (2nd ed.), Algorithm 3.1.
+ * This file implements line search algorithms for determining step sizes.
  *
  * Role in system:
- * - Used by gradient descent to find appropriate step sizes
- * - Implements backtracking line search with Armijo condition
- * - Critical for convergence of gradient-based methods
+ * - Provides step size selection for gradient-based optimizers
+ * - Backtracking Armijo: simple and robust default (used by gradient descent)
+ * - Strong Wolfe: preferred for quasi-Newton methods (BFGS / L-BFGS) to help satisfy
+ *   the curvature condition \(s^T y > 0\), improving Hessian approximation stability
  *
  * For first-time readers:
- * - Start with backtrackingLineSearch function
- * - Understand Armijo condition (sufficient decrease)
- * - Line search prevents overshooting the minimum
+ * - Start with `backtrackingLineSearch` (simpler)
+ * - Then read `strongWolfeLineSearch` and `zoom` (more subtle but more powerful)
  */
 const DEFAULT_INITIAL_STEP_SIZE = 1.0;
 const GRADIENT_NORM_THRESHOLD = 1e-10; // Threshold below which we use default step size to avoid numerical instability
@@ -152,8 +149,133 @@ const GRADIENT_NORM_THRESHOLD = 1e-10; // Threshold below which we use default s
 const DEFAULT_CONTRACTION_FACTOR = 0.5;
 const DEFAULT_ARMIJO_PARAMETER = 1e-4;
 const DEFAULT_MAX_LINE_SEARCH_ITERATIONS = 50;
-const INVALID_STEP_SIZE = 0.0; // Returned when search direction is not a descent direction
+const INVALID_STEP_SIZE$2 = 0.0; // Returned when search direction is not a descent direction
 const NON_DESCENT_DIRECTION_THRESHOLD = 0.0; // Threshold for directional derivative: >= 0 means not a descent direction
+// Typical Strong Wolfe defaults (Nocedal & Wright, 2nd ed.)
+const DEFAULT_WOLFE_C1 = 1e-4;
+const DEFAULT_WOLFE_C2 = 0.9;
+const DEFAULT_MAX_STRONG_WOLFE_ITERATIONS = 25;
+const DEFAULT_MAX_ZOOM_ITERATIONS = 25;
+const DEFAULT_STEP_SIZE_GROWTH_FACTOR = 2.0;
+const DEFAULT_STRONG_WOLFE_INITIAL_STEP_SIZE = 1.0;
+const MINIMUM_STEP_SIZE = 1e-20; // Prevents infinite loops when step size underflows
+const MAXIMUM_STEP_SIZE = 1e20; // Prevents overflow in x + alpha * p
+function clampStepSize(stepSize) {
+    if (!isFinite(stepSize))
+        return DEFAULT_INITIAL_STEP_SIZE;
+    if (stepSize < MINIMUM_STEP_SIZE)
+        return MINIMUM_STEP_SIZE;
+    if (stepSize > MAXIMUM_STEP_SIZE)
+        return MAXIMUM_STEP_SIZE;
+    return stepSize;
+}
+function computeTrialParameters(currentParameters, searchDirection, stepSize) {
+    const trialParameters = new Float64Array(currentParameters.length);
+    for (let index = 0; index < currentParameters.length; index++) {
+        trialParameters[index] = currentParameters[index] + stepSize * searchDirection[index];
+    }
+    return trialParameters;
+}
+function evaluateCostAndDirectionalDerivative(costFunction, gradientFunction, currentParameters, searchDirection, stepSize) {
+    const clampedStepSize = clampStepSize(stepSize);
+    const trialParameters = computeTrialParameters(currentParameters, searchDirection, clampedStepSize);
+    const trialCost = costFunction(trialParameters);
+    const trialGradient = gradientFunction(trialParameters);
+    const trialDirectionalDerivative = dotProduct(trialGradient, searchDirection);
+    return { stepSize: clampedStepSize, cost: trialCost, directionalDerivative: trialDirectionalDerivative };
+}
+function determineInitialStepSize(providedInitialStepSize, currentGradient) {
+    if (providedInitialStepSize !== undefined) {
+        return clampStepSize(providedInitialStepSize);
+    }
+    return DEFAULT_STRONG_WOLFE_INITIAL_STEP_SIZE;
+}
+function satisfiesArmijoCondition(trialCost, currentCost, wolfeC1, stepSize, directionalDerivativeAtZero) {
+    const armijoThreshold = currentCost + wolfeC1 * stepSize * directionalDerivativeAtZero;
+    return trialCost <= armijoThreshold;
+}
+function satisfiesStrongWolfeCurvatureCondition(trialDirectionalDerivative, wolfeC2, directionalDerivativeAtZero) {
+    const leftSide = Math.abs(trialDirectionalDerivative);
+    const rightSide = wolfeC2 * Math.abs(directionalDerivativeAtZero);
+    return leftSide <= rightSide;
+}
+function computeBisectionStepSize(stepSizeLow, stepSizeHigh) {
+    return 0.5 * (stepSizeLow + stepSizeHigh);
+}
+function zoom(costFunction, gradientFunction, currentParameters, searchDirection, currentCost, directionalDerivativeAtZero, wolfeC1, wolfeC2, stepSizeLowInitial, stepSizeHighInitial, costAtStepSizeLowInitial, maxZoomIterations) {
+    let stepSizeLow = stepSizeLowInitial;
+    let stepSizeHigh = stepSizeHighInitial;
+    let costAtStepSizeLow = costAtStepSizeLowInitial;
+    for (let zoomIteration = 0; zoomIteration < maxZoomIterations; zoomIteration++) {
+        const trialStepSize = computeBisectionStepSize(stepSizeLow, stepSizeHigh);
+        const evaluation = evaluateCostAndDirectionalDerivative(costFunction, gradientFunction, currentParameters, searchDirection, trialStepSize);
+        if (!satisfiesArmijoCondition(evaluation.cost, currentCost, wolfeC1, evaluation.stepSize, directionalDerivativeAtZero)) {
+            stepSizeHigh = evaluation.stepSize;
+            continue;
+        }
+        if (evaluation.cost >= costAtStepSizeLow) {
+            stepSizeHigh = evaluation.stepSize;
+            continue;
+        }
+        if (satisfiesStrongWolfeCurvatureCondition(evaluation.directionalDerivative, wolfeC2, directionalDerivativeAtZero)) {
+            return evaluation.stepSize;
+        }
+        const bracketWidth = stepSizeHigh - stepSizeLow;
+        const shouldSwapBracketSide = evaluation.directionalDerivative * bracketWidth >= 0.0;
+        if (shouldSwapBracketSide) {
+            stepSizeHigh = stepSizeLow;
+        }
+        stepSizeLow = evaluation.stepSize;
+        costAtStepSizeLow = evaluation.cost;
+    }
+    // If zoom fails to find a point satisfying Strong Wolfe, return the best-known lower bound.
+    return clampStepSize(stepSizeLow);
+}
+/**
+ * Strong Wolfe line search (Nocedal & Wright, 2nd ed., Algorithm 3.5).
+ *
+ * WHY: For quasi-Newton methods, satisfying the curvature condition improves the chance that
+ * the update will maintain a stable approximation (e.g., positive definiteness).
+ */
+function strongWolfeLineSearch(costFunction, gradientFunction, currentParameters, searchDirection, options = {}) {
+    const wolfeC1 = options.wolfeC1 ?? DEFAULT_WOLFE_C1;
+    const wolfeC2 = options.wolfeC2 ?? DEFAULT_WOLFE_C2;
+    const maxIterations = options.maxIterations ?? DEFAULT_MAX_STRONG_WOLFE_ITERATIONS;
+    const maxZoomIterations = options.maxZoomIterations ?? DEFAULT_MAX_ZOOM_ITERATIONS;
+    const stepSizeGrowthFactor = options.stepSizeGrowthFactor ?? DEFAULT_STEP_SIZE_GROWTH_FACTOR;
+    const currentCost = costFunction(currentParameters);
+    const currentGradient = gradientFunction(currentParameters);
+    const directionalDerivativeAtZero = dotProduct(currentGradient, searchDirection);
+    // Strong Wolfe requires a descent direction (phi'(0) < 0). Otherwise, a line search is ill-posed.
+    if (directionalDerivativeAtZero >= NON_DESCENT_DIRECTION_THRESHOLD) {
+        return INVALID_STEP_SIZE$2;
+    }
+    let previousStepSize = 0.0;
+    let previousCost = currentCost;
+    let stepSize = determineInitialStepSize(options.initialStepSize);
+    for (let iteration = 0; iteration < maxIterations; iteration++) {
+        const evaluation = evaluateCostAndDirectionalDerivative(costFunction, gradientFunction, currentParameters, searchDirection, stepSize);
+        const violatesArmijo = !satisfiesArmijoCondition(evaluation.cost, currentCost, wolfeC1, evaluation.stepSize, directionalDerivativeAtZero);
+        const isNotImprovingEnough = iteration > 0 && evaluation.cost >= previousCost;
+        if (violatesArmijo || isNotImprovingEnough) {
+            return zoom(costFunction, gradientFunction, currentParameters, searchDirection, currentCost, directionalDerivativeAtZero, wolfeC1, wolfeC2, previousStepSize, evaluation.stepSize, previousCost, maxZoomIterations);
+        }
+        if (satisfiesStrongWolfeCurvatureCondition(evaluation.directionalDerivative, wolfeC2, directionalDerivativeAtZero)) {
+            return evaluation.stepSize;
+        }
+        if (evaluation.directionalDerivative >= 0.0) {
+            const stepSizeLow = Math.min(previousStepSize, evaluation.stepSize);
+            const stepSizeHigh = Math.max(previousStepSize, evaluation.stepSize);
+            const costAtStepSizeLow = stepSizeLow === previousStepSize ? previousCost : evaluation.cost;
+            return zoom(costFunction, gradientFunction, currentParameters, searchDirection, currentCost, directionalDerivativeAtZero, wolfeC1, wolfeC2, stepSizeLow, stepSizeHigh, costAtStepSizeLow, maxZoomIterations);
+        }
+        previousStepSize = evaluation.stepSize;
+        previousCost = evaluation.cost;
+        stepSize = clampStepSize(evaluation.stepSize * stepSizeGrowthFactor);
+    }
+    // If we couldn't satisfy Strong Wolfe within the iteration limit, return the last tried step size.
+    return clampStepSize(stepSize);
+}
 /**
  * Performs backtracking line search to find a step size that satisfies
  * the Armijo condition (sufficient decrease). This follows the textbook
@@ -192,7 +314,7 @@ function backtrackingLineSearch(costFunction, gradientFunction, currentParameter
     else {
         // Scale initial step size by gradient norm: 1.0 / ||gradient||
         // This prevents steps from being too large when gradients are large
-        const gradientNorm = vectorNorm(currentGradient);
+        const gradientNorm = vectorNorm$1(currentGradient);
         // Handle edge cases: very small or zero gradient norm
         if (gradientNorm < GRADIENT_NORM_THRESHOLD) {
             initialStepSize = DEFAULT_INITIAL_STEP_SIZE;
@@ -206,14 +328,11 @@ function backtrackingLineSearch(costFunction, gradientFunction, currentParameter
         }
     }
     // Compute directional derivative: ∇f(x)^T * d
-    let directionalDerivative = 0.0;
-    for (let i = 0; i < currentGradient.length; i++) {
-        directionalDerivative += currentGradient[i] * searchDirection[i];
-    }
+    const directionalDerivative = dotProduct(currentGradient, searchDirection);
     // Early return if search direction is not a descent direction
     // Directional derivative >= 0 means moving in this direction increases the cost
     if (directionalDerivative >= NON_DESCENT_DIRECTION_THRESHOLD) {
-        return INVALID_STEP_SIZE;
+        return INVALID_STEP_SIZE$2;
     }
     let stepSize = initialStepSize;
     for (let iteration = 0; iteration < maxIterations; iteration++) {
@@ -267,24 +386,21 @@ function createConvergenceResult(finalParameters, iteration, converged, finalCos
  * Returns true if gradient is small enough (algorithm has found a stationary point).
  */
 function checkGradientConvergence(gradientNorm, tolerance, iteration) {
-    // Skip convergence check on first iteration (no step taken yet)
-    return iteration > 0 && gradientNorm < tolerance;
+    return gradientNorm < tolerance;
 }
 /**
  * Checks if step size indicates convergence.
  * Returns true if step is small enough (algorithm is making minimal progress).
  */
 function checkStepSizeConvergence(stepNorm, tolerance, iteration) {
-    // Skip convergence check on first iteration (no step taken yet)
-    return iteration > 0 && stepNorm < tolerance;
+    return stepNorm < tolerance;
 }
 /**
  * Checks if residual norm indicates convergence.
  * Returns true if residual is small enough (problem is solved to desired accuracy).
  */
 function checkResidualConvergence(residualNorm, tolerance, iteration) {
-    // Skip convergence check on first iteration (no step taken yet)
-    return iteration > 0 && residualNorm < tolerance;
+    return residualNorm < tolerance;
 }
 
 /**
@@ -519,12 +635,12 @@ class Logger {
  * - Understand how it uses line search or fixed step size
  * - Check convergence criteria implementation
  */
-const DEFAULT_MAX_ITERATIONS$5 = 1000;
-const DEFAULT_TOLERANCE$3 = 1e-6;
+const DEFAULT_MAX_ITERATIONS$8 = 1000;
+const DEFAULT_TOLERANCE$5 = 1e-6;
 const DEFAULT_STEP_SIZE$2 = 0.01;
-const DEFAULT_USE_LINE_SEARCH$1 = true;
+const DEFAULT_USE_LINE_SEARCH$3 = true;
 const ZERO_STEP_SIZE$1 = 0.0; // Indicates line search found no valid step (not a descent direction)
-const NEGATIVE_GRADIENT_DIRECTION$1 = -1; // Multiplier for negative gradient direction (steepest descent)
+const NEGATIVE_GRADIENT_DIRECTION$3 = -1; // Multiplier for negative gradient direction (steepest descent)
 /**
  * Determines the step size for gradient descent iteration.
  * Uses line search if enabled, otherwise uses fixed step size.
@@ -536,7 +652,7 @@ function determineStepSize$1(currentGradient, currentParameters, costFunction, g
         return { stepSize: fixedStepSize ?? DEFAULT_STEP_SIZE$2, usedLineSearch: false };
     }
     // Use line search when enabled and no fixed step size provided
-    const searchDirection = scaleVector(currentGradient, NEGATIVE_GRADIENT_DIRECTION$1);
+    const searchDirection = scaleVector(currentGradient, NEGATIVE_GRADIENT_DIRECTION$3);
     // Backtracking line search with Armijo condition (Boyd & Vandenberghe, Sec. 9.3)
     // to choose a step satisfying sufficient decrease (Nocedal & Wright, Ch. 2)
     const stepSize = backtrackingLineSearch(costFunction, gradientFunction, currentParameters, searchDirection);
@@ -547,7 +663,7 @@ function determineStepSize$1(currentGradient, currentParameters, costFunction, g
  * Returns the new parameters and the step vector.
  */
 function updateParametersWithGradientStep(currentParameters, currentGradient, stepSize) {
-    const negativeStepSize = NEGATIVE_GRADIENT_DIRECTION$1 * stepSize;
+    const negativeStepSize = NEGATIVE_GRADIENT_DIRECTION$3 * stepSize;
     const step = scaleVector(currentGradient, negativeStepSize);
     const newParameters = addVectors(currentParameters, step);
     return { newParameters, step };
@@ -557,7 +673,7 @@ function updateParametersWithGradientStep(currentParameters, currentGradient, st
  * Early return pattern to reduce nesting.
  */
 function checkGradientConvergenceAndReturn$1(currentParameters, iteration, currentCost, gradientNorm, tolerance, usedLineSearchFlag, logger) {
-    if (checkGradientConvergence(gradientNorm, tolerance, iteration)) {
+    if (checkGradientConvergence(gradientNorm, tolerance)) {
         logger.info('gradientDescent', iteration, 'Converged', [
             { key: 'Cost:', value: currentCost },
             { key: 'Gradient norm:', value: gradientNorm }
@@ -571,7 +687,7 @@ function checkGradientConvergenceAndReturn$1(currentParameters, iteration, curre
  * Handles line search failure case.
  * Returns convergence result indicating failure.
  */
-function handleLineSearchFailure$1(currentParameters, iteration, currentCost, gradientNorm, logger) {
+function handleLineSearchFailure$3(currentParameters, iteration, currentCost, gradientNorm, logger) {
     logger.warn('gradientDescent', iteration, 'Line search failed', [
         { key: 'Cost:', value: currentCost },
         { key: 'Gradient norm:', value: gradientNorm }
@@ -594,7 +710,7 @@ function handleLineSearchFailure$1(currentParameters, iteration, currentCost, gr
  * Early return pattern to reduce nesting.
  */
 function checkStepSizeConvergenceAndReturn$1(currentParameters, iteration, currentCost, gradientNorm, stepNorm, tolerance, newUsedLineSearch, logger) {
-    if (checkStepSizeConvergence(stepNorm, tolerance, iteration)) {
+    if (checkStepSizeConvergence(stepNorm, tolerance)) {
         logger.info('gradientDescent', iteration, 'Converged', [
             { key: 'Cost:', value: currentCost },
             { key: 'Gradient norm:', value: gradientNorm },
@@ -611,7 +727,7 @@ function checkStepSizeConvergenceAndReturn$1(currentParameters, iteration, curre
  */
 function performGradientDescentIteration(iteration, currentParameters, currentCost, costFunction, gradientFunction, tolerance, useLineSearch, fixedStepSize, onIteration, logger, usedLineSearchFlag) {
     const currentGradient = gradientFunction(currentParameters);
-    const gradientNorm = vectorNorm(currentGradient); // Uses Euclidean norm for steepest descent direction (Nocedal & Wright, Ch. 2)
+    const gradientNorm = vectorNorm$1(currentGradient); // Uses Euclidean norm for steepest descent direction (Nocedal & Wright, Ch. 2)
     // Handle callback (different behavior for first iteration)
     if (onIteration) {
         const callbackIteration = iteration === 0 ? 0 : iteration;
@@ -626,7 +742,7 @@ function performGradientDescentIteration(iteration, currentParameters, currentCo
     const stepSizeResult = determineStepSize$1(currentGradient, currentParameters, costFunction, gradientFunction, useLineSearch, fixedStepSize);
     // Early return: line search failed
     if (stepSizeResult.stepSize === ZERO_STEP_SIZE$1) {
-        const failureResult = handleLineSearchFailure$1(currentParameters, iteration, currentCost, gradientNorm, logger);
+        const failureResult = handleLineSearchFailure$3(currentParameters, iteration, currentCost, gradientNorm, logger);
         return failureResult;
     }
     const newUsedLineSearch = usedLineSearchFlag || stepSizeResult.usedLineSearch;
@@ -634,7 +750,7 @@ function performGradientDescentIteration(iteration, currentParameters, currentCo
     const { newParameters, step } = updateParametersWithGradientStep(currentParameters, currentGradient, stepSizeResult.stepSize);
     const newCost = costFunction(newParameters);
     // Check step size convergence - early return
-    const stepNorm = vectorNorm(step); // Step length via 2-norm for step-size convergence (Boyd & Vandenberghe, Sec. 9.3)
+    const stepNorm = vectorNorm$1(step); // Step length via 2-norm for step-size convergence (Boyd & Vandenberghe, Sec. 9.3)
     const stepSizeConvergenceResult = checkStepSizeConvergenceAndReturn$1(currentParameters, iteration, currentCost, gradientNorm, stepNorm, tolerance, newUsedLineSearch, logger);
     if (stepSizeConvergenceResult.converged && stepSizeConvergenceResult.result) {
         return { converged: true, result: stepSizeConvergenceResult.result };
@@ -663,10 +779,10 @@ function performGradientDescentIteration(iteration, currentParameters, currentCo
  * - Maximum iterations reached
  */
 function gradientDescent(initialParameters, costFunction, gradientFunction, options = {}) {
-    const maxIterations = options.maxIterations ?? DEFAULT_MAX_ITERATIONS$5;
-    const tolerance = options.tolerance ?? DEFAULT_TOLERANCE$3;
+    const maxIterations = options.maxIterations ?? DEFAULT_MAX_ITERATIONS$8;
+    const tolerance = options.tolerance ?? DEFAULT_TOLERANCE$5;
     const stepSize = options.stepSize;
-    const useLineSearch = options.useLineSearch ?? DEFAULT_USE_LINE_SEARCH$1;
+    const useLineSearch = options.useLineSearch ?? DEFAULT_USE_LINE_SEARCH$3;
     const onIteration = options.onIteration;
     const logger = new Logger(options.logLevel, options.verbose);
     let currentParameters = new Float64Array(initialParameters);
@@ -687,7 +803,7 @@ function gradientDescent(initialParameters, costFunction, gradientFunction, opti
     }
     // Maximum iterations reached
     const finalGradient = gradientFunction(currentParameters);
-    const finalGradientNorm = vectorNorm(finalGradient);
+    const finalGradientNorm = vectorNorm$1(finalGradient);
     logger.warn('gradientDescent', undefined, 'Maximum iterations reached', [
         { key: 'Iterations:', value: maxIterations },
         { key: 'Final cost:', value: currentCost },
@@ -1116,8 +1232,8 @@ function computeJacobianMatrix(jacobianFunction, residualFunction, parameters, u
  * - Understand how it solves normal equations: (J^T J) δ = -J^T r
  * - This is a special case of Newton's method for least squares
  */
-const DEFAULT_MAX_ITERATIONS$4 = 1000;
-const DEFAULT_TOLERANCE$2 = 1e-6;
+const DEFAULT_MAX_ITERATIONS$7 = 1000;
+const DEFAULT_TOLERANCE$4 = 1e-6;
 const DEFAULT_USE_NUMERIC_JACOBIAN$1 = true;
 const DEFAULT_JACOBIAN_STEP$1 = 1e-6;
 const NEGATIVE_COEFFICIENT$5 = -1; // Coefficient for negative right-hand side in normal equations: (J^T J) δ = -J^T r
@@ -1137,8 +1253,8 @@ const NEGATIVE_COEFFICIENT$5 = -1; // Coefficient for negative right-hand side i
 function gaussNewton(initialParameters, residualFunction, options = {}) {
     const actualOptions = options;
     const jacobianFunction = actualOptions.jacobian;
-    const maxIterations = actualOptions.maxIterations ?? DEFAULT_MAX_ITERATIONS$4;
-    const tolerance = actualOptions.tolerance ?? DEFAULT_TOLERANCE$2;
+    const maxIterations = actualOptions.maxIterations ?? DEFAULT_MAX_ITERATIONS$7;
+    const tolerance = actualOptions.tolerance ?? DEFAULT_TOLERANCE$4;
     const useNumericJacobian = actualOptions.useNumericJacobian ?? DEFAULT_USE_NUMERIC_JACOBIAN$1;
     const jacobianStep = actualOptions.jacobianStep ?? DEFAULT_JACOBIAN_STEP$1;
     const onIteration = actualOptions.onIteration;
@@ -1147,7 +1263,7 @@ function gaussNewton(initialParameters, residualFunction, options = {}) {
     for (let iteration = 0; iteration < maxIterations; iteration++) {
         // Compute residual vector
         const residual = residualFunction(currentParameters);
-        const residualNorm = vectorNorm(residual);
+        const residualNorm = vectorNorm$1(residual);
         const cost = computeSumOfSquaredResiduals(residualNorm);
         // Call progress callback if provided
         if (onIteration) {
@@ -1195,8 +1311,8 @@ function gaussNewton(initialParameters, residualFunction, options = {}) {
             return { ...result, finalResidualNorm: residualNorm };
         }
         // Check convergence: step size is small enough
-        const stepNorm = vectorNorm(step);
-        if (checkStepSizeConvergence(stepNorm, tolerance, iteration)) {
+        const stepNorm = vectorNorm$1(step);
+        if (checkStepSizeConvergence(stepNorm, tolerance)) {
             logger.info('gaussNewton', iteration, 'Converged', [
                 { key: 'Cost:', value: cost },
                 { key: 'Residual norm:', value: residualNorm },
@@ -1212,10 +1328,10 @@ function gaussNewton(initialParameters, residualFunction, options = {}) {
         }
         // Compute residual for new parameters
         const newResidual = residualFunction(newParameters);
-        const newResidualNorm = vectorNorm(newResidual);
+        const newResidualNorm = vectorNorm$1(newResidual);
         const newCost = computeSumOfSquaredResiduals(newResidualNorm);
         // Check convergence: residual norm is small enough
-        if (checkResidualConvergence(newResidualNorm, tolerance, iteration)) {
+        if (checkResidualConvergence(newResidualNorm, tolerance)) {
             logger.info('gaussNewton', iteration, 'Converged', [
                 { key: 'Cost:', value: newCost },
                 { key: 'Residual norm:', value: newResidualNorm }
@@ -1232,7 +1348,7 @@ function gaussNewton(initialParameters, residualFunction, options = {}) {
     }
     // Maximum iterations reached
     const finalResidual = residualFunction(currentParameters);
-    const finalResidualNorm = vectorNorm(finalResidual);
+    const finalResidualNorm = vectorNorm$1(finalResidual);
     const finalCost = computeSumOfSquaredResiduals(finalResidualNorm);
     logger.warn('gaussNewton', undefined, 'Maximum iterations reached', [
         { key: 'Iterations:', value: maxIterations },
@@ -1267,7 +1383,7 @@ function gaussNewton(initialParameters, residualFunction, options = {}) {
  * - Check convergence criteria implementation
  * - Debug features (callbacks, verbose logging) are top priority
  */
-const DEFAULT_MAX_ITERATIONS$3 = 1000;
+const DEFAULT_MAX_ITERATIONS$6 = 1000;
 const DEFAULT_LAMBDA_INITIAL$1 = 1e-3;
 const DEFAULT_LAMBDA_FACTOR$1 = 10.0;
 const DEFAULT_TOL_GRADIENT$1 = 1e-6;
@@ -1341,7 +1457,7 @@ function tryLevenbergMarquardtStep(jtj, jtr, currentParameters, currentLambda, l
             stepMatrix = mlMatrix.solve(dampedHessian, negativeJtr);
         }
         const step = matrixToFloat64Array(stepMatrix);
-        const stepNorm = vectorNorm(step);
+        const stepNorm = vectorNorm$1(step);
         // Check step size convergence (termination test suggested in Lourakis 2005, Section 5)
         if (checkStepSizeConvergence(stepNorm, tolStep, iteration)) {
             return { stepAccepted: false, newLambda: currentLambda, stepNorm };
@@ -1352,7 +1468,7 @@ function tryLevenbergMarquardtStep(jtj, jtr, currentParameters, currentLambda, l
             newParameters[i] = currentParameters[i] + step[i];
         }
         const newResidual = residualFunction(newParameters);
-        const newResidualNorm = vectorNorm(newResidual);
+        const newResidualNorm = vectorNorm$1(newResidual);
         const newCost = computeSumOfSquaredResiduals(newResidualNorm);
         // Check if step improved the cost
         if (newCost < currentCost) {
@@ -1405,7 +1521,7 @@ function tryLevenbergMarquardtStep(jtj, jtr, currentParameters, currentLambda, l
 function levenbergMarquardt(initialParameters, residualFunction, options = {}) {
     const actualOptions = options;
     const jacobianFunction = actualOptions.jacobian;
-    const maxIterations = actualOptions.maxIterations ?? DEFAULT_MAX_ITERATIONS$3;
+    const maxIterations = actualOptions.maxIterations ?? DEFAULT_MAX_ITERATIONS$6;
     const lambdaInitial = actualOptions.lambdaInitial ?? DEFAULT_LAMBDA_INITIAL$1;
     const lambdaFactor = actualOptions.lambdaFactor ?? DEFAULT_LAMBDA_FACTOR$1;
     const tolGradient = actualOptions.tolGradient ?? DEFAULT_TOL_GRADIENT$1;
@@ -1422,7 +1538,7 @@ function levenbergMarquardt(initialParameters, residualFunction, options = {}) {
     for (let iteration = 0; iteration < maxIterations; iteration++) {
         // Compute residual vector
         const residual = residualFunction(currentParameters);
-        const residualNorm = vectorNorm(residual);
+        const residualNorm = vectorNorm$1(residual);
         const cost = computeSumOfSquaredResiduals(residualNorm);
         // Track best solution so far
         if (cost < bestCost) {
@@ -1440,9 +1556,9 @@ function levenbergMarquardt(initialParameters, residualFunction, options = {}) {
         const { jtj, jtr } = computeNormalEquationsMatrices$1(jacobianMatrix, residual);
         // Compute gradient norm: ||J^T r||
         const gradientVector = matrixToFloat64Array(jtr);
-        const gradientNorm = vectorNorm(gradientVector);
+        const gradientNorm = vectorNorm$1(gradientVector);
         // Check convergence: gradient norm is small enough (Moré 1978, Section 4 termination test; Lourakis 2005, Section 5)
-        if (checkGradientConvergence(gradientNorm, tolGradient, iteration)) {
+        if (checkGradientConvergence(gradientNorm, tolGradient)) {
             logger.info('levenbergMarquardt', iteration, 'Converged', [
                 { key: 'Cost:', value: cost },
                 { key: 'Gradient norm:', value: gradientNorm },
@@ -1460,7 +1576,7 @@ function levenbergMarquardt(initialParameters, residualFunction, options = {}) {
                 return createConvergenceResultForLM$1(bestParameters, iteration, false, bestCost, gradientNorm, residualNorm, stepResult.newLambda);
             }
             // Early return: step size convergence (Lourakis 2005, Section 5)
-            if (stepResult.stepNorm !== undefined && checkStepSizeConvergence(stepResult.stepNorm, tolStep, iteration)) {
+            if (stepResult.stepNorm !== undefined && checkStepSizeConvergence(stepResult.stepNorm, tolStep)) {
                 logger.info('levenbergMarquardt', iteration, 'Converged', [
                     { key: 'Cost:', value: cost },
                     { key: 'Gradient norm:', value: gradientNorm },
@@ -1486,18 +1602,18 @@ function levenbergMarquardt(initialParameters, residualFunction, options = {}) {
                 { key: 'Best cost:', value: bestCost }
             ]);
             const finalResidual = residualFunction(bestParameters);
-            const finalResidualNorm = vectorNorm(finalResidual);
+            const finalResidualNorm = vectorNorm$1(finalResidual);
             const finalGradient = jacobianFunction
                 ? matrixToFloat64Array(jacobianFunction(bestParameters).transpose().mmul(float64ArrayToMatrix(finalResidual)))
                 : undefined;
-            const finalGradientNorm = finalGradient ? vectorNorm(finalGradient) : undefined;
+            const finalGradientNorm = finalGradient ? vectorNorm$1(finalGradient) : undefined;
             return createConvergenceResultForLM$1(bestParameters, iteration, false, bestCost, finalGradientNorm ?? gradientNorm, finalResidualNorm, currentLambda);
         }
         // Check residual norm convergence (Moré 1978, Section 4 stopping rule; Lourakis 2005, Section 5)
         const currentResidual = residualFunction(currentParameters);
-        const currentResidualNorm = vectorNorm(currentResidual);
+        const currentResidualNorm = vectorNorm$1(currentResidual);
         const currentCost = computeSumOfSquaredResiduals(currentResidualNorm);
-        if (checkResidualConvergence(currentResidualNorm, tolResidual, iteration)) {
+        if (checkResidualConvergence(currentResidualNorm, tolResidual)) {
             logger.info('levenbergMarquardt', iteration, 'Converged', [
                 { key: 'Cost:', value: currentCost },
                 { key: 'Gradient norm:', value: gradientNorm },
@@ -1509,11 +1625,11 @@ function levenbergMarquardt(initialParameters, residualFunction, options = {}) {
     }
     // Maximum iterations reached - return best solution found
     const finalResidual = residualFunction(bestParameters);
-    const finalResidualNorm = vectorNorm(finalResidual);
+    const finalResidualNorm = vectorNorm$1(finalResidual);
     const finalGradient = jacobianFunction
         ? matrixToFloat64Array(jacobianFunction(bestParameters).transpose().mmul(float64ArrayToMatrix(finalResidual)))
         : undefined;
-    const finalGradientNorm = finalGradient ? vectorNorm(finalGradient) : undefined;
+    const finalGradientNorm = finalGradient ? vectorNorm$1(finalGradient) : undefined;
     logger.warn('levenbergMarquardt', undefined, 'Maximum iterations reached', [
         { key: 'Iterations:', value: maxIterations },
         { key: 'Final cost:', value: bestCost },
@@ -1533,6 +1649,1102 @@ function levenbergMarquardt(initialParameters, residualFunction, options = {}) {
     };
 }
 
+/**
+ * This file implements the (dense) BFGS algorithm for unconstrained smooth optimization.
+ *
+ * Role in system:
+ * - Quasi-Newton optimizer for scalar cost functions with user-provided gradients
+ * - Uses Strong Wolfe line search to encourage curvature conditions needed for stable updates
+ * - Dense method: stores a full inverse Hessian approximation (O(n^2) memory)
+ *
+ * For first-time readers:
+ * - Start with `bfgs` (main entry point)
+ * - Then read `updateInverseHessianApproximation` (core BFGS update)
+ * - Finally, check safeguard helpers (descent direction / curvature checks)
+ */
+const DEFAULT_MAX_ITERATIONS$5 = 1000;
+const DEFAULT_TOLERANCE$3 = 1e-6;
+const DEFAULT_USE_LINE_SEARCH$2 = true;
+const DEFAULT_FIXED_STEP_SIZE$1 = 1.0;
+const INVALID_STEP_SIZE$1 = 0.0;
+const NEGATIVE_GRADIENT_DIRECTION$2 = -1;
+const MINIMUM_CURVATURE_THRESHOLD$1 = 1e-10;
+function createIdentityMatrix$1(dimension) {
+    // NOTE: Provide both dimensions to stay compatible with our (older) local typing history
+    // and with ml-matrix's API where `columns` is optional.
+    return mlMatrix.Matrix.eye(dimension, dimension);
+}
+function multiplyMatrixVector(matrix, vector) {
+    const result = new Float64Array(vector.length);
+    for (let rowIndex = 0; rowIndex < matrix.rows; rowIndex++) {
+        let sum = 0.0;
+        for (let columnIndex = 0; columnIndex < matrix.columns; columnIndex++) {
+            sum += matrix.get(rowIndex, columnIndex) * vector[columnIndex];
+        }
+        result[rowIndex] = sum;
+    }
+    return result;
+}
+function computeBfgsSearchDirection(inverseHessianApproximation, currentGradient) {
+    const approximateNewtonDirection = multiplyMatrixVector(inverseHessianApproximation, currentGradient);
+    return scaleVector(approximateNewtonDirection, NEGATIVE_GRADIENT_DIRECTION$2);
+}
+function ensureDescentDirectionOrFallback$1(currentGradient, proposedSearchDirection, currentInverseHessianApproximation, logger, iteration, currentCost) {
+    const directionalDerivative = dotProduct(currentGradient, proposedSearchDirection);
+    const isDescentDirection = directionalDerivative < 0.0;
+    if (isDescentDirection) {
+        return { searchDirection: proposedSearchDirection, inverseHessianApproximation: currentInverseHessianApproximation };
+    }
+    // WHY: If numerical issues yield a non-descent direction, reset H to identity and fall back to -g.
+    logger.warn('bfgs', iteration, 'Non-descent direction detected; resetting inverse Hessian and using negative gradient.', [
+        { key: 'Cost:', value: currentCost },
+        { key: 'Directional derivative:', value: directionalDerivative }
+    ]);
+    return {
+        searchDirection: scaleVector(currentGradient, NEGATIVE_GRADIENT_DIRECTION$2),
+        inverseHessianApproximation: createIdentityMatrix$1(currentGradient.length)
+    };
+}
+function updateInverseHessianApproximation(inverseHessianApproximation, stepVector, gradientChangeVector, logger, iteration, currentCost) {
+    const stepDotGradientChange = dotProduct(stepVector, gradientChangeVector);
+    const curvatureIsTooWeak = stepDotGradientChange <= MINIMUM_CURVATURE_THRESHOLD$1;
+    if (curvatureIsTooWeak) {
+        // WHY: If curvature is weak/negative, the BFGS update can break positive definiteness.
+        logger.warn('bfgs', iteration, 'Curvature condition too weak; resetting inverse Hessian approximation.', [
+            { key: 'Cost:', value: currentCost },
+            { key: 'stepDotGradientChange:', value: stepDotGradientChange }
+        ]);
+        return createIdentityMatrix$1(stepVector.length);
+    }
+    const curvatureScaling = 1.0 / stepDotGradientChange;
+    const stepMatrix = mlMatrix.Matrix.columnVector(Array.from(stepVector));
+    const gradientChangeMatrix = mlMatrix.Matrix.columnVector(Array.from(gradientChangeVector));
+    const identityMatrix = createIdentityMatrix$1(stepVector.length);
+    const stepGradientOuterProduct = stepMatrix.mmul(gradientChangeMatrix.transpose()).mul(curvatureScaling);
+    const gradientStepOuterProduct = gradientChangeMatrix.mmul(stepMatrix.transpose()).mul(curvatureScaling);
+    const leftFactor = identityMatrix.sub(stepGradientOuterProduct);
+    const rightFactor = identityMatrix.sub(gradientStepOuterProduct);
+    const rankTwoPart = leftFactor.mmul(inverseHessianApproximation).mmul(rightFactor);
+    const rankOnePart = stepMatrix.mmul(stepMatrix.transpose()).mul(curvatureScaling);
+    return rankTwoPart.add(rankOnePart);
+}
+function computeNextParameters$1(currentParameters, searchDirection, stepSize) {
+    const stepVector = scaleVector(searchDirection, stepSize);
+    return addVectors(currentParameters, stepVector);
+}
+function handleLineSearchFailure$2(currentParameters, iteration, currentCost, gradientNorm, logger) {
+    logger.warn('bfgs', iteration, 'Line search failed (non-descent direction).', [
+        { key: 'Cost:', value: currentCost },
+        { key: 'Gradient norm:', value: gradientNorm }
+    ]);
+    return {
+        finalParameters: currentParameters,
+        parameters: currentParameters,
+        iterations: iteration + 1,
+        converged: false,
+        finalCost: currentCost,
+        finalGradientNorm: gradientNorm
+    };
+}
+function bfgs(initialParameters, costFunction, gradientFunction, options = {}) {
+    const maxIterations = options.maxIterations ?? DEFAULT_MAX_ITERATIONS$5;
+    const tolerance = options.tolerance ?? DEFAULT_TOLERANCE$3;
+    const useLineSearch = options.useLineSearch ?? DEFAULT_USE_LINE_SEARCH$2;
+    const fixedStepSize = options.stepSize ?? DEFAULT_FIXED_STEP_SIZE$1;
+    const onIteration = options.onIteration;
+    const logger = new Logger(options.logLevel, options.verbose);
+    let currentParameters = new Float64Array(initialParameters);
+    let currentCost = costFunction(currentParameters);
+    let inverseHessianApproximation = createIdentityMatrix$1(currentParameters.length);
+    for (let iteration = 0; iteration < maxIterations; iteration++) {
+        const currentGradient = gradientFunction(currentParameters);
+        const gradientNorm = vectorNorm$1(currentGradient);
+        if (onIteration)
+            onIteration(iteration, currentCost, currentParameters);
+        if (checkGradientConvergence(gradientNorm, tolerance)) {
+            logger.info('bfgs', iteration, 'Converged', [
+                { key: 'Cost:', value: currentCost },
+                { key: 'Gradient norm:', value: gradientNorm }
+            ]);
+            return createConvergenceResult(currentParameters, iteration, true, currentCost, gradientNorm);
+        }
+        const proposedSearchDirection = computeBfgsSearchDirection(inverseHessianApproximation, currentGradient);
+        const descentResult = ensureDescentDirectionOrFallback$1(currentGradient, proposedSearchDirection, inverseHessianApproximation, logger, iteration, currentCost);
+        const searchDirection = descentResult.searchDirection;
+        inverseHessianApproximation = descentResult.inverseHessianApproximation;
+        const stepSize = useLineSearch
+            ? strongWolfeLineSearch(costFunction, gradientFunction, currentParameters, searchDirection, options.lineSearchOptions)
+            : fixedStepSize;
+        if (stepSize === INVALID_STEP_SIZE$1) {
+            return handleLineSearchFailure$2(currentParameters, iteration, currentCost, gradientNorm, logger);
+        }
+        const newParameters = computeNextParameters$1(currentParameters, searchDirection, stepSize);
+        const stepVector = subtractVectors$1(newParameters, currentParameters);
+        const stepNorm = vectorNorm$1(stepVector);
+        const newCost = costFunction(newParameters);
+        const newGradient = gradientFunction(newParameters);
+        const gradientChangeVector = subtractVectors$1(newGradient, currentGradient);
+        inverseHessianApproximation = updateInverseHessianApproximation(inverseHessianApproximation, stepVector, gradientChangeVector, logger, iteration, newCost);
+        logger.debug('bfgs', iteration, 'Progress', [
+            { key: 'Cost:', value: currentCost },
+            { key: 'Gradient norm:', value: gradientNorm },
+            { key: 'Step size:', value: stepSize },
+            { key: 'Step norm:', value: stepNorm }
+        ]);
+        currentParameters = new Float64Array(newParameters);
+        currentCost = newCost;
+    }
+    const finalGradient = gradientFunction(currentParameters);
+    const finalGradientNorm = vectorNorm$1(finalGradient);
+    logger.warn('bfgs', undefined, 'Maximum iterations reached', [
+        { key: 'Iterations:', value: maxIterations },
+        { key: 'Final cost:', value: currentCost },
+        { key: 'Final gradient norm:', value: finalGradientNorm }
+    ]);
+    return {
+        finalParameters: currentParameters,
+        parameters: currentParameters,
+        iterations: maxIterations,
+        converged: false,
+        finalCost: currentCost,
+        finalGradientNorm: finalGradientNorm
+    };
+}
+
+/**
+ * This file implements the L-BFGS (Limited-memory BFGS) algorithm for unconstrained
+ * smooth optimization.
+ *
+ * Role in system:
+ * - Quasi-Newton optimizer for scalar cost functions with user-provided gradients
+ * - Uses Strong Wolfe line search to obtain steps that typically satisfy curvature conditions
+ * - Memory-efficient alternative to dense BFGS for medium/large parameter counts
+ *
+ * For first-time readers:
+ * - Start with `lbfgs` (main entry point)
+ * - Then read `computeLbfgsSearchDirection` (two-loop recursion)
+ * - Finally, check safeguard helpers (descent direction / curvature checks)
+ */
+const DEFAULT_MAX_ITERATIONS$4 = 1000;
+const DEFAULT_TOLERANCE$2 = 1e-6;
+const DEFAULT_HISTORY_SIZE = 10;
+const DEFAULT_USE_LINE_SEARCH$1 = true;
+const DEFAULT_FIXED_STEP_SIZE = 1.0;
+const INVALID_STEP_SIZE = 0.0;
+const NEGATIVE_GRADIENT_DIRECTION$1 = -1;
+const MINIMUM_CURVATURE_THRESHOLD = 1e-10;
+const DEFAULT_INITIAL_SCALING_FACTOR = 1.0;
+function createEmptyHistory() {
+    return { stepVectorHistory: [], gradientChangeVectorHistory: [], reciprocalCurvatureHistory: [] };
+}
+function clearHistory(history) {
+    history.stepVectorHistory.length = 0;
+    history.gradientChangeVectorHistory.length = 0;
+    history.reciprocalCurvatureHistory.length = 0;
+}
+function computeInitialScalingFactor(history) {
+    const historyLength = history.stepVectorHistory.length;
+    if (historyLength === 0)
+        return DEFAULT_INITIAL_SCALING_FACTOR;
+    const lastIndex = historyLength - 1;
+    const lastStepVector = history.stepVectorHistory[lastIndex];
+    const lastGradientChangeVector = history.gradientChangeVectorHistory[lastIndex];
+    const stepDotGradientChange = dotProduct(lastStepVector, lastGradientChangeVector);
+    const gradientChangeDotGradientChange = dotProduct(lastGradientChangeVector, lastGradientChangeVector);
+    if (stepDotGradientChange <= 0.0)
+        return DEFAULT_INITIAL_SCALING_FACTOR;
+    if (gradientChangeDotGradientChange <= 0.0)
+        return DEFAULT_INITIAL_SCALING_FACTOR;
+    const scalingFactor = stepDotGradientChange / gradientChangeDotGradientChange;
+    if (!isFinite(scalingFactor) || scalingFactor <= 0.0)
+        return DEFAULT_INITIAL_SCALING_FACTOR;
+    return scalingFactor;
+}
+function computeLbfgsSearchDirection(currentGradient, history) {
+    const historyLength = history.stepVectorHistory.length;
+    if (historyLength === 0) {
+        return scaleVector(currentGradient, NEGATIVE_GRADIENT_DIRECTION$1);
+    }
+    // NOTE: Avoid `new Float64Array(existingFloat64Array)` because TS can infer
+    // `ArrayBufferLike` for the resulting buffer, which conflicts with stricter lib types.
+    const qVectorInitial = new Float64Array(currentGradient.length);
+    qVectorInitial.set(currentGradient);
+    let qVector = qVectorInitial;
+    const alphaCoefficients = new Array(historyLength);
+    for (let index = historyLength - 1; index >= 0; index--) {
+        const stepVector = history.stepVectorHistory[index];
+        const reciprocalCurvature = history.reciprocalCurvatureHistory[index];
+        const alphaCoefficient = reciprocalCurvature * dotProduct(stepVector, qVector);
+        alphaCoefficients[index] = alphaCoefficient;
+        qVector = subtractVectors$1(qVector, scaleVector(history.gradientChangeVectorHistory[index], alphaCoefficient));
+    }
+    const initialScalingFactor = computeInitialScalingFactor(history);
+    let rVector = scaleVector(qVector, initialScalingFactor);
+    for (let index = 0; index < historyLength; index++) {
+        const gradientChangeVector = history.gradientChangeVectorHistory[index];
+        const reciprocalCurvature = history.reciprocalCurvatureHistory[index];
+        const betaCoefficient = reciprocalCurvature * dotProduct(gradientChangeVector, rVector);
+        const correctionCoefficient = alphaCoefficients[index] - betaCoefficient;
+        rVector = addVectors(rVector, scaleVector(history.stepVectorHistory[index], correctionCoefficient));
+    }
+    return scaleVector(rVector, NEGATIVE_GRADIENT_DIRECTION$1);
+}
+function ensureDescentDirectionOrFallback(currentGradient, proposedSearchDirection, history, logger, iteration, currentCost) {
+    const directionalDerivative = dotProduct(currentGradient, proposedSearchDirection);
+    const isDescentDirection = directionalDerivative < 0.0;
+    if (isDescentDirection)
+        return proposedSearchDirection;
+    // WHY: If numerical issues break descent, fall back to steepest descent and clear history.
+    clearHistory(history);
+    logger.warn('lbfgs', iteration, 'Non-descent direction detected; falling back to negative gradient and clearing history.', [
+        { key: 'Cost:', value: currentCost },
+        { key: 'Directional derivative:', value: directionalDerivative }
+    ]);
+    return scaleVector(currentGradient, NEGATIVE_GRADIENT_DIRECTION$1);
+}
+function updateHistoryIfCurvatureIsValid(history, historySize, stepVector, gradientChangeVector, logger, iteration, currentCost) {
+    const stepDotGradientChange = dotProduct(stepVector, gradientChangeVector);
+    const curvatureIsTooWeak = stepDotGradientChange <= MINIMUM_CURVATURE_THRESHOLD;
+    if (curvatureIsTooWeak) {
+        // WHY: Weak/negative curvature can destabilize updates; clearing history is the simplest safe recovery.
+        clearHistory(history);
+        logger.warn('lbfgs', iteration, 'Curvature condition too weak; clearing history to regain robustness.', [
+            { key: 'Cost:', value: currentCost },
+            { key: 'stepDotGradientChange:', value: stepDotGradientChange }
+        ]);
+        return;
+    }
+    const reciprocalCurvature = 1.0 / stepDotGradientChange;
+    history.stepVectorHistory.push(stepVector);
+    history.gradientChangeVectorHistory.push(gradientChangeVector);
+    history.reciprocalCurvatureHistory.push(reciprocalCurvature);
+    while (history.stepVectorHistory.length > historySize) {
+        history.stepVectorHistory.shift();
+        history.gradientChangeVectorHistory.shift();
+        history.reciprocalCurvatureHistory.shift();
+    }
+}
+function computeNextParameters(currentParameters, searchDirection, stepSize) {
+    const stepVector = scaleVector(searchDirection, stepSize);
+    return addVectors(currentParameters, stepVector);
+}
+function handleLineSearchFailure$1(currentParameters, iteration, currentCost, gradientNorm, logger) {
+    logger.warn('lbfgs', iteration, 'Line search failed (non-descent direction).', [
+        { key: 'Cost:', value: currentCost },
+        { key: 'Gradient norm:', value: gradientNorm }
+    ]);
+    return {
+        finalParameters: currentParameters,
+        parameters: currentParameters,
+        iterations: iteration + 1,
+        converged: false,
+        finalCost: currentCost,
+        finalGradientNorm: gradientNorm
+    };
+}
+function lbfgs(initialParameters, costFunction, gradientFunction, options = {}) {
+    const maxIterations = options.maxIterations ?? DEFAULT_MAX_ITERATIONS$4;
+    const tolerance = options.tolerance ?? DEFAULT_TOLERANCE$2;
+    const historySize = options.historySize ?? DEFAULT_HISTORY_SIZE;
+    const useLineSearch = options.useLineSearch ?? DEFAULT_USE_LINE_SEARCH$1;
+    const fixedStepSize = options.stepSize ?? DEFAULT_FIXED_STEP_SIZE;
+    const onIteration = options.onIteration;
+    const logger = new Logger(options.logLevel, options.verbose);
+    let currentParameters = new Float64Array(initialParameters);
+    let currentCost = costFunction(currentParameters);
+    const history = createEmptyHistory();
+    for (let iteration = 0; iteration < maxIterations; iteration++) {
+        const currentGradient = gradientFunction(currentParameters);
+        const gradientNorm = vectorNorm$1(currentGradient);
+        if (onIteration)
+            onIteration(iteration, currentCost, currentParameters);
+        if (checkGradientConvergence(gradientNorm, tolerance)) {
+            logger.info('lbfgs', iteration, 'Converged', [
+                { key: 'Cost:', value: currentCost },
+                { key: 'Gradient norm:', value: gradientNorm }
+            ]);
+            return createConvergenceResult(currentParameters, iteration, true, currentCost, gradientNorm);
+        }
+        const proposedSearchDirection = computeLbfgsSearchDirection(currentGradient, history);
+        const searchDirection = ensureDescentDirectionOrFallback(currentGradient, proposedSearchDirection, history, logger, iteration, currentCost);
+        const stepSize = useLineSearch
+            ? strongWolfeLineSearch(costFunction, gradientFunction, currentParameters, searchDirection, options.lineSearchOptions)
+            : fixedStepSize;
+        if (stepSize === INVALID_STEP_SIZE) {
+            return handleLineSearchFailure$1(currentParameters, iteration, currentCost, gradientNorm, logger);
+        }
+        const newParameters = computeNextParameters(currentParameters, searchDirection, stepSize);
+        const stepVector = subtractVectors$1(newParameters, currentParameters);
+        const stepNorm = vectorNorm$1(stepVector);
+        const newCost = costFunction(newParameters);
+        const newGradient = gradientFunction(newParameters);
+        const gradientChangeVector = subtractVectors$1(newGradient, currentGradient);
+        updateHistoryIfCurvatureIsValid(history, historySize, stepVector, gradientChangeVector, logger, iteration, newCost);
+        logger.debug('lbfgs', iteration, 'Progress', [
+            { key: 'Cost:', value: currentCost },
+            { key: 'Gradient norm:', value: gradientNorm },
+            { key: 'Step size:', value: stepSize },
+            { key: 'Step norm:', value: stepNorm }
+        ]);
+        currentParameters = new Float64Array(newParameters);
+        currentCost = newCost;
+    }
+    const finalGradient = gradientFunction(currentParameters);
+    const finalGradientNorm = vectorNorm$1(finalGradient);
+    logger.warn('lbfgs', undefined, 'Maximum iterations reached', [
+        { key: 'Iterations:', value: maxIterations },
+        { key: 'Final cost:', value: currentCost },
+        { key: 'Final gradient norm:', value: finalGradientNorm }
+    ]);
+    return {
+        finalParameters: currentParameters,
+        parameters: currentParameters,
+        iterations: maxIterations,
+        converged: false,
+        finalCost: currentCost,
+        finalGradientNorm: finalGradientNorm
+    };
+}
+
+/**
+ * This file provides deterministic random number generation utilities.
+ *
+ * Role in system:
+ * - Enables reproducible stochastic optimizers (e.g., CMA-ES) via explicit seeds
+ * - Provides uniform and standard normal sampling without external dependencies
+ * - Keeps browser compatibility (no Node-specific APIs required)
+ *
+ * For first-time readers:
+ * - Use createSeededRandom(seed) to get a generator
+ * - Call nextUniform() for U[0,1), nextStandardNormal() for N(0,1)
+ * - Seed behavior: seed > 0 is deterministic; seed is auto-generated if 0/undefined
+ */
+const UINT32_MAX_PLUS_ONE = 2 ** 32;
+const AUTO_SEED_MULTIPLIER = 1664525;
+const AUTO_SEED_INCREMENT = 1013904223;
+const TWO_PI = 2.0 * Math.PI;
+const MINIMUM_POSITIVE_UNIFORM = 1e-12; // Guard against log(0) in Box–Muller
+function coerceToUint32(value) {
+    // WHY: We use uint32 arithmetic for deterministic, portable PRNG behavior.
+    return value >>> 0;
+}
+function computeAutoSeed() {
+    // WHY: When seed is not forced, we want a different stream each run.
+    // We mix time and Math.random() so that environments with coarse timers still vary.
+    const timeSeed = coerceToUint32(Date.now());
+    const randomSeed = coerceToUint32(Math.floor(Math.random() * UINT32_MAX_PLUS_ONE));
+    const mixed = coerceToUint32(timeSeed ^ randomSeed);
+    // One LCG step to further diffuse obvious patterns like time-only seeds.
+    return coerceToUint32(mixed * AUTO_SEED_MULTIPLIER + AUTO_SEED_INCREMENT);
+}
+function mulberry32(nextState) {
+    // Reference: Mulberry32 PRNG (fast, decent quality for optimization sampling).
+    // State is kept in an object so callers can share and advance it.
+    let t = (nextState.value += 0x6d2b79f5);
+    t = Math.imul(t ^ (t >>> 15), t | 1);
+    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+    const result = (t ^ (t >>> 14)) >>> 0;
+    return result / UINT32_MAX_PLUS_ONE;
+}
+function computeUniformOpenInterval(nextUniform) {
+    const u = nextUniform();
+    // Guard: avoid exactly 0 which would break Box–Muller.
+    return u <= 0.0 ? MINIMUM_POSITIVE_UNIFORM : u;
+}
+function createSeededRandom(seed) {
+    const resolvedSeed = seed && seed > 0 ? coerceToUint32(seed) : computeAutoSeed();
+    const state = { value: resolvedSeed };
+    let cachedNormal;
+    function nextUniform() {
+        return mulberry32(state);
+    }
+    function nextStandardNormal() {
+        if (cachedNormal !== undefined) {
+            const value = cachedNormal;
+            cachedNormal = undefined;
+            return value;
+        }
+        // Box–Muller transform (polar form would require rejection; classic is fine here).
+        const u1 = computeUniformOpenInterval(nextUniform);
+        const u2 = nextUniform();
+        const radius = Math.sqrt(-2 * Math.log(u1));
+        const angle = TWO_PI * u2;
+        const z0 = radius * Math.cos(angle);
+        const z1 = radius * Math.sin(angle);
+        cachedNormal = z1;
+        return z0;
+    }
+    return { seed: resolvedSeed, nextUniform, nextStandardNormal };
+}
+
+/**
+ * This file implements vanilla CMA-ES and IPOP-CMA-ES restart strategy
+ * for unconstrained black-box optimization (no gradients required).
+ *
+ * Role in system:
+ * - Provides a derivative-free optimizer for scalar cost functions
+ * - Adds IPOP restarts (λ doubles per restart) while preserving libcmaes semantics
+ * - Mirrors libcmaes default parameter formulas and core stop criteria
+ *
+ * For first-time readers:
+ * - Start with `cmaEs()` (public entry point)
+ * - `runSingleCmaEs()` executes one CMA-ES run (no restarts)
+ * - Restart logic wraps `runSingleCmaEs()` when `restartStrategy: "ipop"`
+ */
+const DEFAULT_MAX_ITERATIONS$3 = 1000;
+const DEFAULT_MAX_RESTARTS = 9; // libcmaes default
+const DEFAULT_RESTART_STRATEGY = 'none';
+const DEFAULT_FUNCTION_TOLERANCE = 1e-12; // libcmaes default
+const DEFAULT_PARAMETER_TOLERANCE = 1e-12; // libcmaes default
+const MINIMUM_FUNCTION_TOLERANCE = 1e-12;
+const MINIMUM_PARAMETER_TOLERANCE = 1e-12;
+const MINIMUM_POPULATION_SIZE = 2;
+const DEFAULT_STEP_SIZE_FALLBACK_SCALE = 1.0; // used to compute 1 / dim fallback
+const DEFAULT_COVARIANCE_REGULARIZATION = 1e-12;
+const MAX_REGULARIZATION_ATTEMPTS$1 = 8;
+const REGULARIZATION_GROWTH_BASE = 10;
+const H_SIGMA_BASE = 1.4;
+const H_SIGMA_DIMENSION_FACTOR_NUMERATOR = 2.0;
+const H_SIGMA_POWER_FACTOR = 2.0;
+const LARGE_DIMENSION_THRESHOLD_FOR_CSIGMA = 1000;
+const IPOPN_LAMBDA_MULTIPLIER = 2;
+function nowMs() {
+    if (typeof performance !== 'undefined' && typeof performance.now === 'function') {
+        return performance.now();
+    }
+    return Date.now();
+}
+function assertValidDimension(dimension) {
+    // Guard: CMA-ES requires at least one parameter dimension.
+    if (!Number.isInteger(dimension) || dimension <= 0) {
+        throw new Error(`CMA-ES requires dimension >= 1, got ${dimension}`);
+    }
+}
+function normalizePopulationSize(dimension, populationSize, logger) {
+    const defaultValue = computeDefaultPopulationSize(dimension);
+    if (populationSize === undefined)
+        return defaultValue;
+    if (populationSize < MINIMUM_POPULATION_SIZE || !Number.isFinite(populationSize)) {
+        logger.warn('cmaEs', undefined, 'Invalid populationSize; falling back to default.', [
+            { key: 'populationSize:', value: populationSize },
+            { key: 'default:', value: defaultValue }
+        ]);
+        return defaultValue;
+    }
+    return Math.floor(populationSize);
+}
+function normalizeMaxIterations(value, logger) {
+    if (value === undefined)
+        return DEFAULT_MAX_ITERATIONS$3;
+    if (!Number.isFinite(value) || value <= 0) {
+        logger.warn('cmaEs', undefined, 'Invalid maxIterations; falling back to default.', [
+            { key: 'maxIterations:', value }
+        ]);
+        return DEFAULT_MAX_ITERATIONS$3;
+    }
+    return Math.floor(value);
+}
+function normalizeMaxFunctionEvaluations(value, logger) {
+    if (value === undefined)
+        return undefined;
+    if (!Number.isFinite(value) || value <= 0) {
+        logger.warn('cmaEs', undefined, 'Invalid maxFunctionEvaluations; disabling evaluation budget.', [
+            { key: 'maxFunctionEvaluations:', value }
+        ]);
+        return undefined;
+    }
+    return Math.floor(value);
+}
+function normalizeMaxRestarts(value, logger) {
+    if (value === undefined)
+        return DEFAULT_MAX_RESTARTS;
+    if (!Number.isFinite(value) || value < 0) {
+        logger.warn('cmaEs', undefined, 'Invalid maxRestarts; falling back to default.', [
+            { key: 'maxRestarts:', value }
+        ]);
+        return DEFAULT_MAX_RESTARTS;
+    }
+    return Math.floor(value);
+}
+function normalizeRestartStrategy(value, logger) {
+    if (value === undefined)
+        return DEFAULT_RESTART_STRATEGY;
+    if (value === 'none' || value === 'ipop')
+        return value;
+    logger.warn('cmaEs', undefined, 'Unknown restartStrategy; falling back to "none".', [
+        { key: 'restartStrategy:', value: Number.NaN }
+    ]);
+    return DEFAULT_RESTART_STRATEGY;
+}
+function computeDefaultPopulationSize(dimension) {
+    // libcmaes default when lambda is unspecified or < 2:
+    // lambda = 4 + floor(3 * log(dim))
+    const value = 4 + Math.floor(3.0 * Math.log(dimension));
+    return Math.max(MINIMUM_POPULATION_SIZE, value);
+}
+function computeLibcmaesDefaults(dimension, populationSize) {
+    const parentCount = Math.floor(populationSize / 2.0);
+    const weights = computeLibcmaesWeights(parentCount);
+    const effectiveParentCount = computeEffectiveParentCount(weights);
+    const csigma = computeLibcmaesCsigma(dimension, effectiveParentCount);
+    const cc = computeLibcmaesCc(dimension, effectiveParentCount);
+    const c1 = computeLibcmaesC1(dimension, effectiveParentCount);
+    const cmu = computeLibcmaesCmu(dimension, effectiveParentCount, c1);
+    const dsigma = computeLibcmaesDsigma(dimension, effectiveParentCount, csigma);
+    return {
+        populationSize,
+        parentCount,
+        weights,
+        csigma,
+        cc,
+        c1,
+        cmu,
+        dsigma,
+        psFactor: Math.sqrt(csigma * (2.0 - csigma) * effectiveParentCount),
+        pcFactor: Math.sqrt(cc * (2.0 - cc) * effectiveParentCount),
+        chiN: computeLibcmaesChiN(dimension)
+    };
+}
+function computeLibcmaesWeights(parentCount) {
+    const weights = new Float64Array(parentCount);
+    let sum = 0.0;
+    for (let index = 0; index < parentCount; index++) {
+        const weight = Math.log(parentCount + 1) - Math.log(index + 1);
+        weights[index] = weight;
+        sum += weight;
+    }
+    for (let index = 0; index < parentCount; index++) {
+        weights[index] /= sum;
+    }
+    return weights;
+}
+function computeEffectiveParentCount(weights) {
+    let sum = 0.0;
+    let sumSquared = 0.0;
+    for (let index = 0; index < weights.length; index++) {
+        sum += weights[index];
+        sumSquared += weights[index] * weights[index];
+    }
+    return (sum * sum) / sumSquared;
+}
+function computeLibcmaesCsigma(dimension, effectiveParentCount) {
+    if (dimension < LARGE_DIMENSION_THRESHOLD_FOR_CSIGMA) {
+        return (effectiveParentCount + 2.0) / (dimension + effectiveParentCount + 5.0);
+    }
+    return (Math.sqrt(effectiveParentCount) + 2.0) / (Math.sqrt(dimension) + Math.sqrt(effectiveParentCount) + 3.0);
+}
+function computeLibcmaesCc(dimension, effectiveParentCount) {
+    return (4.0 + effectiveParentCount / dimension) / (dimension + 4.0 + (2.0 * effectiveParentCount) / dimension);
+}
+function computeLibcmaesC1(dimension, effectiveParentCount) {
+    return 2.0 / (Math.pow(dimension + 1.3, 2) + effectiveParentCount);
+}
+function computeLibcmaesCmu(dimension, effectiveParentCount, c1) {
+    const cmuUnclamped = (2.0 * (effectiveParentCount - 2.0 + 1.0 / effectiveParentCount)) /
+        (Math.pow(dimension + 2.0, 2) + effectiveParentCount);
+    return Math.min(1.0 - c1, cmuUnclamped);
+}
+function computeLibcmaesDsigma(dimension, effectiveParentCount, csigma) {
+    const term = Math.sqrt((effectiveParentCount - 1.0) / (dimension + 1.0)) - 1.0;
+    return 1.0 + csigma + 2.0 * Math.max(0.0, term);
+}
+function computeLibcmaesChiN(dimension) {
+    return (Math.sqrt(dimension) *
+        (1.0 - 1.0 / (4.0 * dimension) + 1.0 / (21.0 * dimension * dimension)));
+}
+function computeInitialStepSize(initialStepSize, dimension, logger) {
+    if (initialStepSize !== undefined && initialStepSize > 0.0)
+        return initialStepSize;
+    logger.warn('cmaEs', undefined, 'initialStepSize is missing or non-positive; falling back to 1/dim.', [
+        { key: 'dim:', value: dimension }
+    ]);
+    return DEFAULT_STEP_SIZE_FALLBACK_SCALE / dimension;
+}
+function sanitizeCost(rawCost) {
+    return Number.isFinite(rawCost) ? rawCost : Number.POSITIVE_INFINITY;
+}
+function createIdentityMatrix(dimension) {
+    return mlMatrix.Matrix.eye(dimension, dimension);
+}
+function computeMaxDiagonalElement(matrix) {
+    let maxValue = 0.0;
+    for (let index = 0; index < matrix.rows; index++) {
+        maxValue = Math.max(maxValue, matrix.get(index, index));
+    }
+    return maxValue;
+}
+function symmetrizeMatrixInPlace(matrix) {
+    for (let rowIndex = 0; rowIndex < matrix.rows; rowIndex++) {
+        for (let colIndex = rowIndex + 1; colIndex < matrix.columns; colIndex++) {
+            const average = 0.5 * (matrix.get(rowIndex, colIndex) + matrix.get(colIndex, rowIndex));
+            matrix.set(rowIndex, colIndex, average);
+            matrix.set(colIndex, rowIndex, average);
+        }
+    }
+}
+function computeRegularizationLambda$1(base, attempt) {
+    return base * Math.pow(REGULARIZATION_GROWTH_BASE, attempt);
+}
+function computeCholeskyLowerOrRegularize(covarianceMatrix, regularizationBase, logger) {
+    for (let attempt = 0; attempt < MAX_REGULARIZATION_ATTEMPTS$1; attempt++) {
+        const lambda = computeRegularizationLambda$1(regularizationBase, attempt);
+        const regularized = covarianceMatrix.add(createIdentityMatrix(covarianceMatrix.rows).mul(lambda));
+        try {
+            const decomposition = new mlMatrix.CholeskyDecomposition(regularized);
+            if (decomposition.isPositiveDefinite()) {
+                if (attempt > 0) {
+                    logger.warn('cmaEs', undefined, 'Covariance not SPD; recovered via diagonal regularization.', [
+                        { key: 'regularization:', value: lambda }
+                    ]);
+                }
+                return decomposition.lowerTriangularMatrix;
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    logger.warn('cmaEs', undefined, 'Covariance Cholesky failed; resetting covariance to identity.', []);
+    return new mlMatrix.CholeskyDecomposition(createIdentityMatrix(covarianceMatrix.rows)).lowerTriangularMatrix;
+}
+function solveLowerTriangularSystem(lowerTriangular, rhs) {
+    const dimension = rhs.length;
+    const solution = new Float64Array(dimension);
+    for (let rowIndex = 0; rowIndex < dimension; rowIndex++) {
+        let sum = rhs[rowIndex];
+        for (let colIndex = 0; colIndex < rowIndex; colIndex++) {
+            sum -= lowerTriangular.get(rowIndex, colIndex) * solution[colIndex];
+        }
+        solution[rowIndex] = sum / lowerTriangular.get(rowIndex, rowIndex);
+    }
+    return solution;
+}
+function vectorNormSquared(vector) {
+    let sum = 0.0;
+    for (let index = 0; index < vector.length; index++) {
+        sum += vector[index] * vector[index];
+    }
+    return sum;
+}
+function vectorNorm(vector) {
+    return Math.sqrt(vectorNormSquared(vector));
+}
+function addScaledInPlace(target, source, scale) {
+    for (let index = 0; index < target.length; index++) {
+        target[index] += scale * source[index];
+    }
+}
+function scaleInPlace(vector, scale) {
+    for (let index = 0; index < vector.length; index++) {
+        vector[index] *= scale;
+    }
+}
+function subtractVectors(a, b) {
+    const result = new Float64Array(a.length);
+    for (let index = 0; index < a.length; index++) {
+        result[index] = a[index] - b[index];
+    }
+    return result;
+}
+function computeWeightedMean(candidates, weights, parentCount) {
+    const dimension = candidates[0].parameters.length;
+    const mean = new Float64Array(dimension);
+    for (let index = 0; index < parentCount; index++) {
+        addScaledInPlace(mean, candidates[index].parameters, weights[index]);
+    }
+    return mean;
+}
+function computePcOuterProduct(pc) {
+    const dimension = pc.length;
+    const result = mlMatrix.Matrix.zeros(dimension, dimension);
+    for (let rowIndex = 0; rowIndex < dimension; rowIndex++) {
+        const vRow = pc[rowIndex];
+        for (let colIndex = 0; colIndex < dimension; colIndex++) {
+            result.set(rowIndex, colIndex, vRow * pc[colIndex]);
+        }
+    }
+    return result;
+}
+function addWeightedOuterProductInPlace(accumulator, vector, weight) {
+    const dimension = vector.length;
+    for (let rowIndex = 0; rowIndex < dimension; rowIndex++) {
+        const vRow = vector[rowIndex];
+        for (let colIndex = 0; colIndex < dimension; colIndex++) {
+            accumulator.set(rowIndex, colIndex, accumulator.get(rowIndex, colIndex) + weight * vRow * vector[colIndex]);
+        }
+    }
+}
+function computeDefaultMaxHistorySize(dimension, populationSize) {
+    const base = 10;
+    const scale = 30;
+    return base + Math.ceil((scale * dimension) / populationSize);
+}
+function checkStopMaxFevals(functionEvaluations, maxFunctionEvaluations) {
+    if (maxFunctionEvaluations !== undefined && functionEvaluations >= maxFunctionEvaluations) {
+        return { shouldStop: true, converged: false, reason: 'MAXFEVALS' };
+    }
+    return { shouldStop: false, converged: false, reason: 'CONT' };
+}
+function checkStopFtarget(bestCost, targetCost) {
+    if (targetCost !== undefined && bestCost <= targetCost) {
+        return { shouldStop: true, converged: true, reason: 'FTARGET' };
+    }
+    return { shouldStop: false, converged: false, reason: 'CONT' };
+}
+function checkStopMaxIter(iteration, maxIterations) {
+    if (iteration >= maxIterations) {
+        return { shouldStop: true, converged: false, reason: 'MAXITER' };
+    }
+    return { shouldStop: false, converged: false, reason: 'CONT' };
+}
+function checkStopTolHistFun(bestCostHistory, maxHistorySize, functionTolerance) {
+    if (bestCostHistory.length < maxHistorySize) {
+        return { shouldStop: false, converged: false, reason: 'CONT' };
+    }
+    let recentMin = Number.POSITIVE_INFINITY;
+    let recentMax = Number.NEGATIVE_INFINITY;
+    for (let index = bestCostHistory.length - maxHistorySize; index < bestCostHistory.length; index++) {
+        recentMin = Math.min(recentMin, bestCostHistory[index]);
+        recentMax = Math.max(recentMax, bestCostHistory[index]);
+    }
+    const range = Math.abs(recentMax - recentMin);
+    if (range < functionTolerance) {
+        return { shouldStop: true, converged: true, reason: 'TOLHISTFUN' };
+    }
+    return { shouldStop: false, converged: false, reason: 'CONT' };
+}
+function checkStopTolX(args) {
+    if (args.iteration <= 0)
+        return { shouldStop: false, converged: false, reason: 'CONT' };
+    const factor = args.sigma / args.sigmaInit;
+    const thresholdFactor = args.parameterTolerance * factor;
+    for (let index = 0; index < args.pc.length; index++) {
+        if (args.pc[index] >= thresholdFactor) {
+            return { shouldStop: false, converged: false, reason: 'CONT' };
+        }
+    }
+    for (let index = 0; index < args.covariance.rows; index++) {
+        const diagonalStd = Math.sqrt(args.covariance.get(index, index));
+        if (diagonalStd >= thresholdFactor) {
+            return { shouldStop: false, converged: false, reason: 'CONT' };
+        }
+    }
+    return { shouldStop: true, converged: true, reason: 'TOLX' };
+}
+function checkLibcmaesStopCriteria(args) {
+    const maxFevals = checkStopMaxFevals(args.functionEvaluations, args.maxFunctionEvaluations);
+    if (maxFevals.shouldStop)
+        return maxFevals;
+    const ftarget = checkStopFtarget(args.bestCost, args.targetCost);
+    if (ftarget.shouldStop)
+        return ftarget;
+    const maxIter = checkStopMaxIter(args.iteration, args.maxIterations);
+    if (maxIter.shouldStop)
+        return maxIter;
+    const tolHistFun = checkStopTolHistFun(args.bestCostHistory, args.maxHistorySize, args.functionTolerance);
+    if (tolHistFun.shouldStop)
+        return tolHistFun;
+    return checkStopTolX({
+        iteration: args.iteration,
+        sigma: args.sigma,
+        sigmaInit: args.sigmaInit,
+        parameterTolerance: args.parameterTolerance,
+        pc: args.pc,
+        covariance: args.covariance
+    });
+}
+function computeHsigThreshold(iteration, csigma, chiN, dimension) {
+    const decay = Math.pow(1.0 - csigma, H_SIGMA_POWER_FACTOR * (iteration + 1));
+    const normalization = Math.sqrt(1.0 - decay);
+    const dimensionFactor = H_SIGMA_BASE + H_SIGMA_DIMENSION_FACTOR_NUMERATOR / (dimension + 1.0);
+    return normalization * dimensionFactor * chiN;
+}
+function sampleCandidate(mean, sigma, lowerTriangular, nextStandardNormal) {
+    const dimension = mean.length;
+    const z = new Float64Array(dimension);
+    for (let index = 0; index < dimension; index++)
+        z[index] = nextStandardNormal();
+    const y = new Float64Array(dimension);
+    for (let rowIndex = 0; rowIndex < dimension; rowIndex++) {
+        let sum = 0.0;
+        for (let colIndex = 0; colIndex <= rowIndex; colIndex++) {
+            sum += lowerTriangular.get(rowIndex, colIndex) * z[colIndex];
+        }
+        y[rowIndex] = sum;
+    }
+    const parameters = new Float64Array(dimension);
+    for (let index = 0; index < dimension; index++)
+        parameters[index] = mean[index] + sigma * y[index];
+    return { parameters, normalizedStep: y };
+}
+function initializeState(initialParameters, sigmaInit, costFunction, counters, profiling) {
+    const mean = new Float64Array(initialParameters);
+    const costStart = profiling ? nowMs() : 0;
+    const bestCost = sanitizeCost(costFunction(mean));
+    if (profiling)
+        profiling.costMs += nowMs() - costStart;
+    counters.functionEvaluations += 1;
+    return {
+        mean,
+        covariance: createIdentityMatrix(initialParameters.length),
+        psigma: new Float64Array(initialParameters.length),
+        pc: new Float64Array(initialParameters.length),
+        sigma: sigmaInit,
+        sigmaInit,
+        bestCost,
+        bestParameters: new Float64Array(mean),
+        bestCostHistory: [bestCost]
+    };
+}
+function updateBestIfImproved(state, bestCandidate) {
+    if (bestCandidate.cost >= state.bestCost)
+        return;
+    state.bestCost = bestCandidate.cost;
+    state.bestParameters = new Float64Array(bestCandidate.parameters);
+}
+function pushBestCostHistory(state, bestCost, maxHistorySize) {
+    state.bestCostHistory.push(bestCost);
+    while (state.bestCostHistory.length > maxHistorySize)
+        state.bestCostHistory.shift();
+}
+function buildResult(state, defaults, iterations, converged, stopReason, functionEvaluations, profiling) {
+    const finalMaxStdDev = state.sigma * Math.sqrt(Math.max(0.0, computeMaxDiagonalElement(state.covariance)));
+    return {
+        finalParameters: state.bestParameters,
+        parameters: state.bestParameters,
+        iterations,
+        converged,
+        finalCost: state.bestCost,
+        populationSize: defaults.populationSize,
+        functionEvaluations: functionEvaluations ?? 0,
+        finalStepSize: state.sigma,
+        finalMaxStdDev,
+        stopReason,
+        profiling
+    };
+}
+function runOneGeneration(context, state) {
+    const choleskyStart = context.profiling ? nowMs() : 0;
+    const lowerTriangular = computeCholeskyLowerOrRegularize(state.covariance, context.covarianceRegularizationBase, context.logger);
+    if (context.profiling) {
+        context.profiling.choleskyMs += nowMs() - choleskyStart;
+    }
+    const candidates = [];
+    for (let sampleIndex = 0; sampleIndex < context.defaults.populationSize; sampleIndex++) {
+        const sampleStart = context.profiling ? nowMs() : 0;
+        const sampled = sampleCandidate(state.mean, state.sigma, lowerTriangular, context.nextStandardNormal);
+        if (context.profiling) {
+            context.profiling.samplingMs += nowMs() - sampleStart;
+        }
+        const costStart = context.profiling ? nowMs() : 0;
+        const cost = sanitizeCost(context.costFunction(sampled.parameters));
+        if (context.profiling) {
+            context.profiling.costMs += nowMs() - costStart;
+        }
+        context.counters.functionEvaluations += 1;
+        candidates.push({ parameters: sampled.parameters, normalizedStep: sampled.normalizedStep, cost });
+        if (context.maxFunctionEvaluations !== undefined &&
+            context.counters.functionEvaluations >= context.maxFunctionEvaluations) {
+            break;
+        }
+    }
+    candidates.sort((a, b) => a.cost - b.cost);
+    return { candidates, lowerTriangular };
+}
+function updateDistributionParameters(context, state, candidates, lowerTriangular, iteration) {
+    const updateStart = context.profiling ? nowMs() : 0;
+    const parentCount = Math.min(context.defaults.parentCount, candidates.length);
+    const xmean = computeWeightedMean(candidates, context.defaults.weights, parentCount);
+    const diffxmean = subtractVectors(xmean, state.mean);
+    scaleInPlace(diffxmean, 1.0 / state.sigma);
+    scaleInPlace(state.psigma, 1.0 - context.defaults.csigma);
+    const csqinvDiff = solveLowerTriangularSystem(lowerTriangular, diffxmean);
+    addScaledInPlace(state.psigma, csqinvDiff, context.defaults.psFactor);
+    const normPs = vectorNorm(state.psigma);
+    const hsigThreshold = computeHsigThreshold(iteration, context.defaults.csigma, context.defaults.chiN, context.dimension);
+    const hsig = normPs < hsigThreshold ? 1.0 : 0.0;
+    scaleInPlace(state.pc, 1.0 - context.defaults.cc);
+    addScaledInPlace(state.pc, diffxmean, hsig * context.defaults.pcFactor);
+    const spc = computePcOuterProduct(state.pc);
+    const wdiff = mlMatrix.Matrix.zeros(context.dimension, context.dimension);
+    for (let index = 0; index < parentCount; index++) {
+        addWeightedOuterProductInPlace(wdiff, candidates[index].normalizedStep, context.defaults.weights[index]);
+    }
+    const covarianceScale = 1.0 -
+        context.defaults.c1 -
+        context.defaults.cmu +
+        (1.0 - hsig) * context.defaults.c1 * context.defaults.cc * (2.0 - context.defaults.cc);
+    state.covariance = state.covariance.mul(covarianceScale).add(spc.mul(context.defaults.c1)).add(wdiff.mul(context.defaults.cmu));
+    symmetrizeMatrixInPlace(state.covariance);
+    const sigmaExponent = (context.defaults.csigma / context.defaults.dsigma) * (normPs / context.defaults.chiN - 1.0);
+    state.sigma *= Math.exp(sigmaExponent);
+    state.mean = xmean;
+    if (context.profiling) {
+        context.profiling.updateMs += nowMs() - updateStart;
+    }
+}
+function runSingleCmaEs(context, state) {
+    const initialStop = checkLibcmaesStopCriteria({
+        iteration: context.counters.iterations,
+        maxIterations: context.maxIterations,
+        functionEvaluations: context.counters.functionEvaluations,
+        maxFunctionEvaluations: context.maxFunctionEvaluations,
+        bestCost: state.bestCost,
+        targetCost: context.targetCost,
+        bestCostHistory: state.bestCostHistory,
+        maxHistorySize: context.maxHistorySize,
+        functionTolerance: context.functionTolerance,
+        sigma: state.sigma,
+        sigmaInit: state.sigmaInit,
+        parameterTolerance: context.parameterTolerance,
+        pc: state.pc,
+        covariance: state.covariance
+    });
+    if (initialStop.shouldStop) {
+        return { stop: initialStop, state };
+    }
+    while (true) {
+        const { candidates, lowerTriangular } = runOneGeneration(context, state);
+        if (candidates.length === 0) {
+            const budgetStop = checkStopMaxFevals(context.counters.functionEvaluations, context.maxFunctionEvaluations);
+            return { stop: budgetStop, state };
+        }
+        updateBestIfImproved(state, candidates[0]);
+        pushBestCostHistory(state, state.bestCost, context.maxHistorySize);
+        if (context.onIteration) {
+            context.onIteration(context.counters.iterations, state.bestCost, state.bestParameters);
+        }
+        const stop = checkLibcmaesStopCriteria({
+            iteration: context.counters.iterations + 1,
+            maxIterations: context.maxIterations,
+            functionEvaluations: context.counters.functionEvaluations,
+            maxFunctionEvaluations: context.maxFunctionEvaluations,
+            bestCost: state.bestCost,
+            targetCost: context.targetCost,
+            bestCostHistory: state.bestCostHistory,
+            maxHistorySize: context.maxHistorySize,
+            functionTolerance: context.functionTolerance,
+            sigma: state.sigma,
+            sigmaInit: state.sigmaInit,
+            parameterTolerance: context.parameterTolerance,
+            pc: state.pc,
+            covariance: state.covariance
+        });
+        if (stop.shouldStop) {
+            return { stop, state };
+        }
+        updateDistributionParameters(context, state, candidates, lowerTriangular, context.counters.iterations);
+        context.counters.iterations += 1;
+        context.logger.debug('cmaEs', context.counters.iterations, 'Progress', [
+            { key: 'bestCost:', value: state.bestCost },
+            { key: 'sigma:', value: state.sigma },
+            { key: 'fevals:', value: context.counters.functionEvaluations }
+        ]);
+    }
+}
+function cmaEs(initialParameters, costFunction, options = {}) {
+    const dimension = initialParameters.length;
+    assertValidDimension(dimension);
+    const logger = new Logger(options.logLevel, options.verbose);
+    const restartStrategy = normalizeRestartStrategy(options.restartStrategy, logger);
+    const maxRestarts = normalizeMaxRestarts(options.maxRestarts, logger);
+    const maxIterations = normalizeMaxIterations(options.maxIterations, logger);
+    const maxFunctionEvaluations = normalizeMaxFunctionEvaluations(options.maxFunctionEvaluations, logger);
+    const functionTolerance = Math.max(options.functionTolerance ?? DEFAULT_FUNCTION_TOLERANCE, MINIMUM_FUNCTION_TOLERANCE);
+    const parameterTolerance = Math.max(options.parameterTolerance ?? DEFAULT_PARAMETER_TOLERANCE, MINIMUM_PARAMETER_TOLERANCE);
+    const covarianceRegularizationBase = options.covarianceRegularization ?? DEFAULT_COVARIANCE_REGULARIZATION;
+    const sigmaInit = computeInitialStepSize(options.initialStepSize, dimension, logger);
+    const targetCost = options.targetCost;
+    const onIteration = options.onIteration;
+    const seededRandom = createSeededRandom(options.randomSeed);
+    const counters = { iterations: 0, functionEvaluations: 0 };
+    const profiling = options.profiling
+        ? { totalMs: 0, costMs: 0, choleskyMs: 0, samplingMs: 0, updateMs: 0 }
+        : undefined;
+    const totalStart = profiling ? nowMs() : 0;
+    let populationSize = normalizePopulationSize(dimension, options.populationSize, logger);
+    let defaults = computeLibcmaesDefaults(dimension, populationSize);
+    let maxHistorySize = options.maxHistorySize && options.maxHistorySize > 0
+        ? options.maxHistorySize
+        : computeDefaultMaxHistorySize(dimension, defaults.populationSize);
+    logger.info('cmaEs', 0, 'Starting', [
+        { key: 'dim:', value: dimension },
+        { key: 'lambda:', value: defaults.populationSize },
+        { key: 'mu:', value: defaults.parentCount },
+        { key: 'sigma0:', value: sigmaInit }
+    ]);
+    let globalBestCost = Number.POSITIVE_INFINITY;
+    let globalBestParameters = new Float64Array(initialParameters);
+    let globalStopReason;
+    let globalConverged = false;
+    let globalState = null;
+    const totalRuns = restartStrategy === 'ipop' ? maxRestarts + 1 : 1;
+    for (let runIndex = 0; runIndex < totalRuns; runIndex++) {
+        defaults = computeLibcmaesDefaults(dimension, populationSize);
+        maxHistorySize =
+            options.maxHistorySize && options.maxHistorySize > 0
+                ? options.maxHistorySize
+                : computeDefaultMaxHistorySize(dimension, defaults.populationSize);
+        const state = initializeState(initialParameters, sigmaInit, costFunction, counters, profiling);
+        const context = {
+            dimension,
+            defaults,
+            maxHistorySize,
+            functionTolerance,
+            parameterTolerance,
+            covarianceRegularizationBase,
+            maxIterations,
+            maxFunctionEvaluations,
+            targetCost,
+            costFunction,
+            logger,
+            nextStandardNormal: seededRandom.nextStandardNormal,
+            onIteration,
+            counters,
+            profiling
+        };
+        const runResult = runSingleCmaEs(context, state);
+        globalState = runResult.state;
+        if (globalState.bestCost < globalBestCost) {
+            globalBestCost = globalState.bestCost;
+            globalBestParameters = new Float64Array(globalState.bestParameters);
+        }
+        if (runResult.stop.reason === 'FTARGET') {
+            globalStopReason = 'FTARGET';
+            globalConverged = true;
+            break;
+        }
+        if (runResult.stop.reason === 'MAXFEVALS' || runResult.stop.reason === 'MAXITER') {
+            globalStopReason = runResult.stop.reason;
+            globalConverged = false;
+            break;
+        }
+        if (restartStrategy !== 'ipop') {
+            globalStopReason = runResult.stop.reason === 'CONT' ? undefined : runResult.stop.reason;
+            globalConverged = runResult.stop.converged;
+            break;
+        }
+        if (runIndex >= maxRestarts) {
+            globalStopReason = 'IPOP_MAX_RESTARTS';
+            globalConverged = false;
+            break;
+        }
+        populationSize *= IPOPN_LAMBDA_MULTIPLIER;
+    }
+    if (!globalState) {
+        const fallbackDefaults = computeLibcmaesDefaults(dimension, populationSize);
+        const fallbackState = initializeState(initialParameters, sigmaInit, costFunction, counters, profiling);
+        if (profiling)
+            profiling.totalMs = nowMs() - totalStart;
+        return buildResult(fallbackState, fallbackDefaults, counters.iterations, false, globalStopReason, counters.functionEvaluations, profiling);
+    }
+    globalState.bestCost = globalBestCost;
+    globalState.bestParameters = globalBestParameters;
+    if (profiling)
+        profiling.totalMs = nowMs() - totalStart;
+    return buildResult(globalState, defaults, counters.iterations, globalConverged, globalStopReason, counters.functionEvaluations, profiling);
+}
+
 /**
  * This file provides shared utility functions for constrained optimization algorithms
  * using the adjoint method.
@@ -1846,7 +3058,7 @@ function projectStatesToConstraints(parameters, states, constraintFunction, step
     let projectedStates = new Float64Array(states);
     for (let i = 0; i < maxIterations; i++) {
         const constraint = constraintFunction(parameters, projectedStates);
-        const constraintNorm = vectorNorm(constraint);
+        const constraintNorm = vectorNorm$1(constraint);
         if (constraintNorm <= constraintTolerance) {
             break;
         }
@@ -1869,8 +3081,11 @@ function projectStatesToConstraints(parameters, states, constraintFunction, step
  * Validates initial conditions including constraint satisfaction and dimensions.
  *
  * Checks that:
- * 1. Constraint count equals state count (required for adjoint method)
- * 2. Initial constraint violation is within tolerance (warns if not)
+ * 1. Initial constraint violation is within tolerance (warns if not)
+ *
+ * Note:
+ * - Constraint count and state count do not need to match.
+ * - Both square and non-square constraint Jacobians are supported by the shared solvers.
  *
  * @param initialParameters - Initial parameter vector p0
  * @param initialStates - Initial state vector x0
@@ -1878,11 +3093,10 @@ function projectStatesToConstraints(parameters, states, constraintFunction, step
  * @param constraintTolerance - Tolerance for constraint violation
  * @param logger - Logger instance for warnings
  * @param algorithmName - Name of calling algorithm (for error messages)
- * @throws Error if constraint count != state count
  */
 function validateInitialConditions$1(initialParameters, initialStates, constraintFunction, constraintTolerance, logger, algorithmName = 'constrainedOptimization') {
     const initialConstraint = constraintFunction(initialParameters, initialStates);
-    const initialConstraintNorm = vectorNorm(initialConstraint);
+    const initialConstraintNorm = vectorNorm$1(initialConstraint);
     if (initialConstraintNorm > constraintTolerance) {
         logger.warn(algorithmName, undefined, 'Initial constraint violation', [
             { key: '||c(p0,x0)||:', value: initialConstraintNorm },
@@ -1967,7 +3181,7 @@ function isResidualFunction(costFunction, parameters, states) {
 function computeCost(costFunction, parameters, states) {
     if (isResidualFunction(costFunction, parameters, states)) {
         const residual = costFunction(parameters, states);
-        const residualNorm = vectorNorm(residual);
+        const residualNorm = vectorNorm$1(residual);
         return RESIDUAL_COST_COEFFICIENT * residualNorm * residualNorm;
     }
     return costFunction(parameters, states);
@@ -2231,7 +3445,7 @@ function computeAdjointGradient(dfdp, lambda, dcdp) {
         lambdaTdcdpVector[i] = lambdaTdcdp.get(0, i);
     }
     // df/dp = ∂f/∂p - λ^T ∂c/∂p
-    return subtractVectors(dfdp, lambdaTdcdpVector);
+    return subtractVectors$1(dfdp, lambdaTdcdpVector);
 }
 /**
  * Updates states using linear approximation: x_new = x_old + dx
@@ -2265,7 +3479,7 @@ function createCostFunctionWrapper(currentParameters, currentStates, costFunctio
         // Update states during line search to maintain constraint satisfaction.
         // We use linear approximation (x_new = x_old + dx) where dx solves (∂c/∂x) dx = -∂c/∂p · Δp
         // because solving the full nonlinear constraint system for each line search step would be too expensive.
-        const deltaP = subtractVectors(params, currentParameters);
+        const deltaP = subtractVectors$1(params, currentParameters);
         const newStates = updateStates(currentStates, dcdx, dcdp, deltaP, logger);
         return computeCost(costFunction, params, newStates);
     };
@@ -2302,7 +3516,7 @@ function createGradientFunctionWrapper(currentParameters, currentStates, current
         }
         // For different trial parameters, update states to maintain constraints and compute gradient.
         // We use linear approximation for efficiency: solving full nonlinear constraints for each trial would be too slow.
-        const deltaP = subtractVectors(trialParams, currentParameters);
+        const deltaP = subtractVectors$1(trialParams, currentParameters);
         const trialStates = updateStates(currentStates, currentDcdx, currentDcdp, deltaP, logger);
         // Compute gradient at trial point to evaluate search direction quality in line search.
         const trialPartials = computePartialDerivatives(trialParams, trialStates, costFunction, constraintFunction, options);
@@ -2330,7 +3544,7 @@ function determineStepSize(currentGradient, currentParameters, currentStates, co
  */
 function checkConstraintViolation$2(currentParameters, currentStates, constraintFunction, constraintTolerance, iteration, logger) {
     const constraint = constraintFunction(currentParameters, currentStates);
-    const constraintNorm = vectorNorm(constraint);
+    const constraintNorm = vectorNorm$1(constraint);
     if (constraintNorm > constraintTolerance) {
         logger.warn('adjointGradientDescent', iteration, 'Constraint violation detected', [
             { key: '||c(p,x)||:', value: constraintNorm },
@@ -2347,14 +3561,14 @@ function computeAdjointGradientAndNorm(currentParameters, currentStates, costFun
     const partials = computePartialDerivatives(currentParameters, currentStates, costFunction, constraintFunction, options);
     const lambda = solveAdjointEquation(partials.dcdx, partials.dfdx, logger);
     const adjointGradient = computeAdjointGradient(partials.dfdp, lambda, partials.dcdp);
-    const gradientNorm = vectorNorm(adjointGradient);
+    const gradientNorm = vectorNorm$1(adjointGradient);
     return { adjointGradient, gradientNorm, partials };
 }
 /**
  * Checks gradient convergence and returns result if converged.
  */
 function checkGradientConvergenceAndReturn(currentParameters, currentStates, iteration, currentCost, gradientNorm, constraintNorm, constraintTolerance, tolerance, usedLineSearchFlag, logger) {
-    if (constraintNorm <= constraintTolerance && checkGradientConvergence(gradientNorm, tolerance, iteration)) {
+    if (constraintNorm <= constraintTolerance && checkGradientConvergence(gradientNorm, tolerance)) {
         logger.info('adjointGradientDescent', iteration, 'Converged', [
             { key: 'Cost:', value: currentCost },
             { key: 'Gradient norm:', value: gradientNorm },
@@ -2403,7 +3617,7 @@ function updateParametersAndStates(currentParameters, currentStates, adjointGrad
     const negativeStepSize = NEGATIVE_GRADIENT_DIRECTION * stepSize;
     const step = scaleVector(adjointGradient, negativeStepSize);
     const newParameters = addVectors(currentParameters, step);
-    const deltaP = subtractVectors(newParameters, currentParameters);
+    const deltaP = subtractVectors$1(newParameters, currentParameters);
     const newStates = updateStates(currentStates, partials.dcdx, partials.dcdp, deltaP, logger);
     const newCost = computeCost(costFunction, newParameters, newStates);
     return { newParameters, newStates, newCost };
@@ -2412,7 +3626,7 @@ function updateParametersAndStates(currentParameters, currentStates, adjointGrad
  * Checks step size convergence and returns result if converged.
  */
 function checkStepSizeConvergenceAndReturn(currentParameters, currentStates, iteration, currentCost, gradientNorm, stepNorm, constraintNorm, constraintTolerance, tolerance, newUsedLineSearch, logger) {
-    if (constraintNorm <= constraintTolerance && checkStepSizeConvergence(stepNorm, tolerance, iteration)) {
+    if (constraintNorm <= constraintTolerance && checkStepSizeConvergence(stepNorm, tolerance)) {
         logger.info('adjointGradientDescent', iteration, 'Converged', [
             { key: 'Cost:', value: currentCost },
             { key: 'Gradient norm:', value: gradientNorm },
@@ -2518,8 +3732,8 @@ function handleStepSizeAndUpdate(adjointGradient, currentParameters, currentStat
  */
 function checkStepSizeConvergenceAndLog(currentParameters, currentStates, constraint, currentCost, gradientNorm, stepSize, constraintNorm, iteration, constraintTolerance, tolerance, newUsedLineSearch, newParameters, logger) {
     // Check step size convergence: if step is too small, optimization has likely converged or stalled.
-    const step = subtractVectors(newParameters, currentParameters);
-    const stepNorm = vectorNorm(step);
+    const step = subtractVectors$1(newParameters, currentParameters);
+    const stepNorm = vectorNorm$1(step);
     const stepSizeConvergenceResult = checkStepSizeConvergenceAndReturn(currentParameters, currentStates, iteration, currentCost, gradientNorm, stepNorm, constraintNorm, constraintTolerance, tolerance, newUsedLineSearch, logger);
     if (stepSizeConvergenceResult.converged && stepSizeConvergenceResult.result) {
         return stepSizeConvergenceResult;
@@ -2555,7 +3769,7 @@ function performAdjointGradientDescentIteration(iteration, currentParameters, cu
  */
 function validateInitialConditions(initialParameters, initialStates, constraintFunction, constraintTolerance, logger) {
     const initialConstraint = constraintFunction(initialParameters, initialStates);
-    const initialConstraintNorm = vectorNorm(initialConstraint);
+    const initialConstraintNorm = vectorNorm$1(initialConstraint);
     if (initialConstraintNorm > constraintTolerance) {
         logger.warn('adjointGradientDescent', undefined, 'Initial constraint violation', [
             { key: '||c(p0,x0)||:', value: initialConstraintNorm },
@@ -2578,9 +3792,9 @@ function createMaxIterationsResult(currentParameters, currentStates, currentCost
     const partials = computePartialDerivatives(currentParameters, currentStates, costFunction, constraintFunction, options);
     const lambda = solveAdjointEquation(partials.dcdx, partials.dfdx, logger);
     const finalGradient = computeAdjointGradient(partials.dfdp, lambda, partials.dcdp);
-    const finalGradientNorm = vectorNorm(finalGradient);
+    const finalGradientNorm = vectorNorm$1(finalGradient);
     const finalConstraint = constraintFunction(currentParameters, currentStates);
-    const finalConstraintNorm = vectorNorm(finalConstraint);
+    const finalConstraintNorm = vectorNorm$1(finalConstraint);
     logger.warn('adjointGradientDescent', undefined, 'Maximum iterations reached', [
         { key: 'Iterations:', value: maxIterations },
         { key: 'Final cost:', value: currentCost },
@@ -2807,7 +4021,7 @@ const DEFAULT_RIDGE_REGULARIZATION = 1e-8; // Small ridge regularization to reco
  */
 function checkConstraintViolation$1(currentParameters, currentStates, constraintFunction, constraintTolerance, iteration, logger) {
     const constraint = constraintFunction(currentParameters, currentStates);
-    const constraintNorm = vectorNorm(constraint);
+    const constraintNorm = vectorNorm$1(constraint);
     if (constraintNorm > constraintTolerance) {
         logger.warn('constrainedGaussNewton', iteration, 'Constraint violation detected', [
             { key: '||c(p,x)||:', value: constraintNorm },
@@ -2906,7 +4120,7 @@ function computeStepForGN(currentParameters, currentStates, residualFunction, co
  * Returns convergence result if converged, null otherwise.
  */
 function checkStepSizeConvergenceForGN(stepNorm, constraintSatisfied, tolerance, iteration, currentParameters, currentStates, cost, residualNorm, constraintNorm, logger) {
-    if (constraintSatisfied && checkStepSizeConvergence(stepNorm, tolerance, iteration)) {
+    if (constraintSatisfied && checkStepSizeConvergence(stepNorm, tolerance)) {
         logger.info('constrainedGaussNewton', iteration, 'Converged', [
             { key: 'Cost:', value: cost },
             { key: 'Residual norm:', value: residualNorm },
@@ -2928,14 +4142,14 @@ function checkStepSizeConvergenceForGN(stepNorm, constraintSatisfied, tolerance,
  * Returns convergence result if converged, null otherwise.
  */
 function checkResidualConvergenceForGN(newParameters, newStates, newResidualNorm, newCost, constraintFunction, constraintTolerance, tolerance, iteration, constraintNorm, logger) {
-    if (checkResidualConvergence(newResidualNorm, tolerance, iteration)) {
+    if (checkResidualConvergence(newResidualNorm, tolerance)) {
         logger.info('constrainedGaussNewton', iteration, 'Converged', [
             { key: 'Cost:', value: newCost },
             { key: 'Residual norm:', value: newResidualNorm },
             { key: 'Constraint norm:', value: constraintNorm }
         ]);
         const finalConstraint = constraintFunction(newParameters, newStates);
-        const finalConstraintNorm = vectorNorm(finalConstraint);
+        const finalConstraintNorm = vectorNorm$1(finalConstraint);
         if (finalConstraintNorm <= constraintTolerance) {
             const result = createConvergenceResult(newParameters, iteration, true, newCost, undefined);
             return {
@@ -2955,7 +4169,7 @@ function checkResidualConvergenceForGN(newParameters, newStates, newResidualNorm
 function performConstrainedGaussNewtonIteration(currentParameters, currentStates, residualFunction, constraintFunction, effectiveJacobianOptions, tolerance, constraintTolerance, stepSizeP, stepSizeX, iteration, logger, onIteration, dcdp, dcdx) {
     const { constraintNorm } = checkConstraintViolation$1(currentParameters, currentStates, constraintFunction, constraintTolerance, iteration, logger);
     const residual = residualFunction(currentParameters, currentStates);
-    const residualNorm = vectorNorm(residual);
+    const residualNorm = vectorNorm$1(residual);
     const cost = computeSumOfSquaredResiduals(residualNorm);
     const constraintSatisfied = constraintNorm <= constraintTolerance;
     if (onIteration) {
@@ -2966,7 +4180,7 @@ function performConstrainedGaussNewtonIteration(currentParameters, currentStates
         return stepResult;
     }
     const step = stepResult.step;
-    const stepNorm = vectorNorm(step);
+    const stepNorm = vectorNorm$1(step);
     const stepSizeConvergenceResult = checkStepSizeConvergenceForGN(stepNorm, constraintSatisfied, tolerance, iteration, currentParameters, currentStates, cost, residualNorm, constraintNorm, logger);
     if (stepSizeConvergenceResult) {
         return {
@@ -2976,7 +4190,7 @@ function performConstrainedGaussNewtonIteration(currentParameters, currentStates
     }
     const { newParameters, newStates } = updateParametersAndStatesForConstrainedGN(currentParameters, currentStates, step, constraintFunction, stepSizeP, stepSizeX, constraintTolerance, logger, dcdp, dcdx);
     const newResidual = residualFunction(newParameters, newStates);
-    const newResidualNorm = vectorNorm(newResidual);
+    const newResidualNorm = vectorNorm$1(newResidual);
     const newCost = computeSumOfSquaredResiduals(newResidualNorm);
     const residualConvergenceResult = checkResidualConvergenceForGN(newParameters, newStates, newResidualNorm, newCost, constraintFunction, constraintTolerance, tolerance, iteration, constraintNorm, logger);
     if (residualConvergenceResult) {
@@ -3060,10 +4274,10 @@ function constrainedGaussNewton(initialParameters, initialStates, residualFuncti
     const currentParameters = iterationResult.finalParameters;
     const currentStates = iterationResult.finalStates;
     const finalResidual = residualFunction(currentParameters, currentStates);
-    const finalResidualNorm = vectorNorm(finalResidual);
+    const finalResidualNorm = vectorNorm$1(finalResidual);
     const finalCost = computeSumOfSquaredResiduals(finalResidualNorm);
     const finalConstraint = constraintFunction(currentParameters, currentStates);
-    const finalConstraintNorm = vectorNorm(finalConstraint);
+    const finalConstraintNorm = vectorNorm$1(finalConstraint);
     logger.warn('constrainedGaussNewton', undefined, 'Maximum iterations reached', [
         { key: 'Iterations:', value: maxIterations },
         { key: 'Final cost:', value: finalCost },
@@ -3148,7 +4362,7 @@ function createConvergenceResultForLM(finalParameters, states, iteration, conver
  */
 function checkConstraintViolation(currentParameters, currentStates, constraintFunction, constraintTolerance, iteration, logger) {
     const constraint = constraintFunction(currentParameters, currentStates);
-    const constraintNorm = vectorNorm(constraint);
+    const constraintNorm = vectorNorm$1(constraint);
     if (constraintNorm > constraintTolerance) {
         logger.warn('constrainedLevenbergMarquardt', iteration, 'Constraint violation detected', [
             { key: '||c(p,x)||:', value: constraintNorm },
@@ -3183,7 +4397,7 @@ function solveDampedNormalEquations(jtj, jtr, currentLambda, lambdaFactor) {
         return { newLambda };
     }
     const step = matrixToFloat64Array(stepMatrix);
-    const stepNorm = vectorNorm(step);
+    const stepNorm = vectorNorm$1(step);
     return { step, stepNorm };
 }
 /**
@@ -3244,7 +4458,7 @@ function tryConstrainedLevenbergMarquardtStep(jtj, jtr, currentParameters, curre
         const newStates = updateStates$1(currentStates, c_x, c_p, step, logger, 'constrainedLevenbergMarquardt');
         const projectedStates = projectStatesToConstraints(newParameters, newStates, constraintFunction, stepSizeX, constraintTolerance, logger, 'constrainedLevenbergMarquardt');
         const newResidual = residualFunction(newParameters, projectedStates);
-        const newResidualNorm = vectorNorm(newResidual);
+        const newResidualNorm = vectorNorm$1(newResidual);
         const newCost = computeSumOfSquaredResiduals(newResidualNorm);
         const evaluationResult = evaluateStepQuality(newParameters, projectedStates, newCost, currentCost, currentLambda, lambdaFactor, iteration, logger);
         return {
@@ -3271,7 +4485,7 @@ function tryConstrainedLevenbergMarquardtStep(jtj, jtr, currentParameters, curre
  * Returns convergence result if converged, null otherwise.
  */
 function checkConvergenceForLM(gradientNorm, constraintSatisfied, tolGradient, iteration, currentParameters, currentStates, cost, residualNorm, constraintNorm, currentLambda, logger) {
-    if (constraintSatisfied && checkGradientConvergence(gradientNorm, tolGradient, iteration)) {
+    if (constraintSatisfied && checkGradientConvergence(gradientNorm, tolGradient)) {
         logger.info('constrainedLevenbergMarquardt', iteration, 'Converged', [
             { key: 'Cost:', value: cost },
             { key: 'Gradient norm:', value: gradientNorm },
@@ -3299,7 +4513,7 @@ function tryStepWithLambda(jtj, jtr, currentParameters, currentStates, currentLa
         }
         if (stepResult.stepNorm !== undefined &&
             constraintSatisfied &&
-            checkStepSizeConvergence(stepResult.stepNorm, tolStep, iteration)) {
+            checkStepSizeConvergence(stepResult.stepNorm, tolStep)) {
             logger.info('constrainedLevenbergMarquardt', iteration, 'Converged', [
                 { key: 'Cost:', value: cost },
                 { key: 'Gradient norm:', value: gradientNorm },
@@ -3332,11 +4546,11 @@ function tryStepWithLambda(jtj, jtr, currentParameters, currentStates, currentLa
  */
 function processStepResult(updatedParameters, updatedStates, updatedLambda, residualFunction, constraintFunction, constraintTolerance, tolResidual, iteration, gradientNorm, logger) {
     const currentResidual = residualFunction(updatedParameters, updatedStates);
-    const currentResidualNorm = vectorNorm(currentResidual);
+    const currentResidualNorm = vectorNorm$1(currentResidual);
     const currentCost = computeSumOfSquaredResiduals(currentResidualNorm);
     const currentConstraint = constraintFunction(updatedParameters, updatedStates);
-    const currentConstraintNorm = vectorNorm(currentConstraint);
-    if (currentConstraintNorm <= constraintTolerance && checkResidualConvergence(currentResidualNorm, tolResidual, iteration)) {
+    const currentConstraintNorm = vectorNorm$1(currentConstraint);
+    if (currentConstraintNorm <= constraintTolerance && checkResidualConvergence(currentResidualNorm, tolResidual)) {
         logger.info('constrainedLevenbergMarquardt', iteration, 'Converged', [
             { key: 'Cost:', value: currentCost },
             { key: 'Gradient norm:', value: gradientNorm },
@@ -3366,7 +4580,7 @@ function processStepResult(updatedParameters, updatedStates, updatedLambda, resi
 function performConstrainedLevenbergMarquardtIteration(currentParameters, currentStates, currentLambda, residualFunction, constraintFunction, effectiveJacobianOptions, tolGradient, tolStep, tolResidual, constraintTolerance, stepSizeP, stepSizeX, lambdaFactor, iteration, logger, onIteration, dcdp, dcdx) {
     const { constraintNorm } = checkConstraintViolation(currentParameters, currentStates, constraintFunction, constraintTolerance, iteration, logger);
     const residual = residualFunction(currentParameters, currentStates);
-    const residualNorm = vectorNorm(residual);
+    const residualNorm = vectorNorm$1(residual);
     const cost = computeSumOfSquaredResiduals(residualNorm);
     if (onIteration) {
         onIteration(iteration, cost, currentParameters);
@@ -3374,7 +4588,7 @@ function performConstrainedLevenbergMarquardtIteration(currentParameters, curren
     const effectiveJacobian = computeEffectiveJacobian(currentParameters, currentStates, residualFunction, constraintFunction, effectiveJacobianOptions, logger, 'constrainedLevenbergMarquardt');
     const { jtj, jtr } = computeNormalEquationsMatrices(effectiveJacobian, residual);
     const gradientVector = matrixToFloat64Array(jtr);
-    const gradientNorm = vectorNorm(gradientVector);
+    const gradientNorm = vectorNorm$1(gradientVector);
     const constraintSatisfied = constraintNorm <= constraintTolerance;
     const gradientConvergenceResult = checkConvergenceForLM(gradientNorm, constraintSatisfied, tolGradient, iteration, currentParameters, currentStates, cost, residualNorm, constraintNorm, currentLambda, logger);
     if (gradientConvergenceResult) {
@@ -3423,7 +4637,7 @@ function initializeLMState(initialParameters, initialStates, residualFunction) {
     const bestParameters = new Float64Array(initialParameters);
     const bestStates = new Float64Array(initialStates);
     const initialResidual = residualFunction(initialParameters, initialStates);
-    const initialResidualNorm = vectorNorm(initialResidual);
+    const initialResidualNorm = vectorNorm$1(initialResidual);
     const bestCost = computeSumOfSquaredResiduals(initialResidualNorm);
     return { currentParameters, currentStates, bestParameters, bestStates, bestCost };
 }
@@ -3473,12 +4687,12 @@ function runLMIterations(initialParameters, initialStates, residualFunction, con
  */
 function createFinalLMResult(bestParameters, bestStates, bestCost, currentLambda, actualIterations, residualFunction, constraintFunction, effectiveJacobianOptions, logger) {
     const finalResidual = residualFunction(bestParameters, bestStates);
-    const finalResidualNorm = vectorNorm(finalResidual);
+    const finalResidualNorm = vectorNorm$1(finalResidual);
     const finalConstraint = constraintFunction(bestParameters, bestStates);
-    const finalConstraintNorm = vectorNorm(finalConstraint);
+    const finalConstraintNorm = vectorNorm$1(finalConstraint);
     const finalEffectiveJacobian = computeEffectiveJacobian(bestParameters, bestStates, residualFunction, constraintFunction, effectiveJacobianOptions, logger, 'constrainedLevenbergMarquardt');
     const { jtr: finalJtr } = computeNormalEquationsMatrices(finalEffectiveJacobian, finalResidual);
-    const finalGradientNorm = vectorNorm(matrixToFloat64Array(finalJtr));
+    const finalGradientNorm = vectorNorm$1(matrixToFloat64Array(finalJtr));
     return createConvergenceResultForLM(bestParameters, bestStates, actualIterations - 1, false, bestCost, finalGradientNorm, finalResidualNorm, finalConstraintNorm, currentLambda);
 }
 /**
@@ -3530,14 +4744,14 @@ function constrainedLevenbergMarquardt(initialParameters, initialStates, residua
         return iterationResult.result;
     }
     const finalResidual = residualFunction(iterationResult.bestParameters, iterationResult.bestStates);
-    const finalResidualNorm = vectorNorm(finalResidual);
+    const finalResidualNorm = vectorNorm$1(finalResidual);
     const finalConstraint = constraintFunction(iterationResult.bestParameters, iterationResult.bestStates);
-    const finalConstraintNorm = vectorNorm(finalConstraint);
+    const finalConstraintNorm = vectorNorm$1(finalConstraint);
     logger.warn('constrainedLevenbergMarquardt', undefined, 'Maximum iterations reached', [
         { key: 'Iterations:', value: iterationResult.actualIterations },
         { key: 'Final cost:', value: iterationResult.bestCost },
         {
-            key: 'Final gradient norm:', value: vectorNorm(matrixToFloat64Array(computeNormalEquationsMatrices(computeEffectiveJacobian(iterationResult.bestParameters, iterationResult.bestStates, residualFunction, constraintFunction, effectiveJacobianOptions, logger, 'constrainedLevenbergMarquardt'), finalResidual).jtr))
+            key: 'Final gradient norm:', value: vectorNorm$1(matrixToFloat64Array(computeNormalEquationsMatrices(computeEffectiveJacobian(iterationResult.bestParameters, iterationResult.bestStates, residualFunction, constraintFunction, effectiveJacobianOptions, logger, 'constrainedLevenbergMarquardt'), finalResidual).jtr))
         },
         { key: 'Final residual norm:', value: finalResidualNorm },
         { key: 'Final constraint norm:', value: finalConstraintNorm },
@@ -3777,6 +4991,37 @@ function formatLevenbergMarquardtResult(result, options) {
     }
     return lines.join('\n');
 }
+/**
+ * Formats a CMA-ES result.
+ */
+function formatCmaEsResult(result, options) {
+    const opts = { ...DEFAULT_OPTIONS, ...options };
+    const lines = formatBasicResult(result, opts);
+    const insertionIndex = lines.findIndex(line => line.includes('Final gradient norm') || line.includes('Final residual norm'));
+    const extraLines = [
+        `  Population size (λ): ${result.populationSize}`,
+        `  Function evaluations: ${result.functionEvaluations}`,
+        `  Final step size (σ): ${formatNumberWithPrecision(result.finalStepSize, 6)}`,
+        `  Final max std dev: ${formatNumberWithPrecision(result.finalMaxStdDev, opts.costPrecision)}`
+    ];
+    if (result.stopReason) {
+        extraLines.push(`  Stop reason: ${result.stopReason}`);
+    }
+    if (result.profiling) {
+        extraLines.push(`  Profiling (ms): total=${formatNumberWithPrecision(result.profiling.totalMs, 2)}, ` +
+            `cost=${formatNumberWithPrecision(result.profiling.costMs, 2)}, ` +
+            `cholesky=${formatNumberWithPrecision(result.profiling.choleskyMs, 2)}, ` +
+            `sampling=${formatNumberWithPrecision(result.profiling.samplingMs, 2)}, ` +
+            `update=${formatNumberWithPrecision(result.profiling.updateMs, 2)}`);
+    }
+    if (insertionIndex >= 0) {
+        lines.splice(insertionIndex + 1, 0, ...extraLines);
+    }
+    else {
+        lines.push(...extraLines);
+    }
+    return lines.join('\n');
+}
 /**
  * Formats a ConstrainedGaussNewtonResult.
  */
@@ -3934,6 +5179,9 @@ function formatResult(result, options) {
     if ('finalLambda' in result) {
         return formatLevenbergMarquardtResult(result, options);
     }
+    if ('populationSize' in result && 'functionEvaluations' in result && 'finalStepSize' in result) {
+        return formatCmaEsResult(result, options);
+    }
     if ('usedLineSearch' in result) {
         return formatGradientDescentResult(result, options);
     }
@@ -3957,6 +5205,12 @@ function printGradientDescentResult(result, options) {
 function printLevenbergMarquardtResult(result, options) {
     console.log(formatLevenbergMarquardtResult(result, options));
 }
+/**
+ * Prints a CMA-ES result directly to console.
+ */
+function printCmaEsResult(result, options) {
+    console.log(formatCmaEsResult(result, options));
+}
 /**
  * Prints a constrained Gauss-Newton result directly to console.
  */
@@ -3982,6 +5236,8 @@ function printResult(result, options) {
 exports.addVectors = addVectors;
 exports.adjointGradientDescent = adjointGradientDescent;
 exports.backtrackingLineSearch = backtrackingLineSearch;
+exports.bfgs = bfgs;
+exports.cmaEs = cmaEs;
 exports.constrainedGaussNewton = constrainedGaussNewton;
 exports.constrainedLevenbergMarquardt = constrainedLevenbergMarquardt;
 exports.createFiniteDiffGradient = createFiniteDiffGradient;
@@ -3997,6 +5253,7 @@ exports.finiteDiffResidualPartialP = finiteDiffResidualPartialP;
 exports.finiteDiffResidualPartialX = finiteDiffResidualPartialX;
 exports.float64ArrayToMatrix = float64ArrayToMatrix;
 exports.formatAdjointGradientDescentResult = formatAdjointGradientDescentResult;
+exports.formatCmaEsResult = formatCmaEsResult;
 exports.formatConstrainedGaussNewtonResult = formatConstrainedGaussNewtonResult;
 exports.formatConstrainedLevenbergMarquardtResult = formatConstrainedLevenbergMarquardtResult;
 exports.formatGradientDescentResult = formatGradientDescentResult;
@@ -4005,10 +5262,12 @@ exports.formatOptimizationResult = formatOptimizationResult;
 exports.formatResult = formatResult;
 exports.gaussNewton = gaussNewton;
 exports.gradientDescent = gradientDescent;
+exports.lbfgs = lbfgs;
 exports.levenbergMarquardt = levenbergMarquardt;
 exports.matrixToFloat64Array = matrixToFloat64Array;
 exports.matrixToFloat64Array2D = matrixToFloat64Array2D;
 exports.printAdjointGradientDescentResult = printAdjointGradientDescentResult;
+exports.printCmaEsResult = printCmaEsResult;
 exports.printConstrainedGaussNewtonResult = printConstrainedGaussNewtonResult;
 exports.printConstrainedLevenbergMarquardtResult = printConstrainedLevenbergMarquardtResult;
 exports.printGradientDescentResult = printGradientDescentResult;
@@ -4016,6 +5275,7 @@ exports.printLevenbergMarquardtResult = printLevenbergMarquardtResult;
 exports.printOptimizationResult = printOptimizationResult;
 exports.printResult = printResult;
 exports.scaleVector = scaleVector;
-exports.subtractVectors = subtractVectors;
-exports.vectorNorm = vectorNorm;
+exports.strongWolfeLineSearch = strongWolfeLineSearch;
+exports.subtractVectors = subtractVectors$1;
+exports.vectorNorm = vectorNorm$1;
 //# sourceMappingURL=index.cjs.map