numopt-js 0.1.0

package/dist/core/constrainedLevenbergMarquardt.js

@@ -0,0 +1,469 @@
+/**
+ * This file implements the constrained Levenberg-Marquardt algorithm for solving
+ * nonlinear least squares problems with constraints.
+ *
+ * The constrained Levenberg-Marquardt method uses the effective Jacobian concept:
+ * J_eff = r_p - r_x C_x^+ C_p, which captures all constraint effects.
+ * This allows the algorithm to use the same structure as unconstrained
+ * Levenberg-Marquardt: (J_eff^T J_eff + λI) δ = -J_eff^T r
+ *
+ * Role in system:
+ * - Constrained version of Levenberg-Marquardt method
+ * - Uses effective Jacobian computed via adjoint method
+ * - Updates both parameters and states to maintain constraint satisfaction
+ * - More robust than constrained Gauss-Newton (handles singular matrices)
+ *
+ * For first-time readers:
+ * - Start with constrainedLevenbergMarquardt function
+ * - Understand how effective Jacobian replaces regular Jacobian
+ * - Check lambda update strategy and damping mechanism
+ */
+import { Matrix, CholeskyDecomposition } from 'ml-matrix';
+import { float64ArrayToMatrix, matrixToFloat64Array, vectorNorm, computeSumOfSquaredResiduals } from '../utils/matrix.js';
+import { checkGradientConvergence, checkStepSizeConvergence, checkResidualConvergence } from './convergence.js';
+import { computeEffectiveJacobian } from './effectiveJacobian.js';
+import { updateStates, validateInitialConditions, projectStatesToConstraints } from './constrainedUtils.js';
+import { Logger } from './logger.js';
+import { finiteDiffConstraintPartialP, finiteDiffConstraintPartialX } from './finiteDiff.js';
+const DEFAULT_MAX_ITERATIONS = 1000;
+const DEFAULT_LAMBDA_INITIAL = 1e-3;
+const DEFAULT_LAMBDA_FACTOR = 10.0;
+const DEFAULT_TOL_GRADIENT = 1e-6;
+const DEFAULT_TOL_STEP = 1e-6;
+const DEFAULT_TOL_RESIDUAL = 1e-6;
+const DEFAULT_CONSTRAINT_TOLERANCE = 1e-6;
+const DEFAULT_STEP_SIZE_P = 1e-6;
+const DEFAULT_STEP_SIZE_X = 1e-6;
+const MAXIMUM_LAMBDA_THRESHOLD = 1e10; // Maximum lambda before giving up (prevents infinite loop)
+const NEGATIVE_COEFFICIENT = -1.0; // Coefficient for negative right-hand side in damped normal equations: (J_eff^T J_eff + λI) δ = -J_eff^T r
+/**
+ * Computes J_eff^T J_eff and J_eff^T r matrices needed for normal equations.
+ * Returns both matrices for use in solving damped normal equations.
+ */
+function computeNormalEquationsMatrices(effectiveJacobian, residual) {
+    const jacobianTranspose = effectiveJacobian.transpose();
+    const jtj = jacobianTranspose.mmul(effectiveJacobian);
+    const residualMatrix = float64ArrayToMatrix(residual);
+    const jtr = jacobianTranspose.mmul(residualMatrix);
+    return { jtj, jtr };
+}
+/**
+ * Creates a convergence result object for constrained Levenberg-Marquardt algorithm.
+ * Centralizes result creation to avoid code duplication.
+ */
+function createConvergenceResultForLM(parameters, states, iteration, converged, finalCost, finalGradientNorm, finalResidualNorm, finalConstraintNorm, finalLambda) {
+    return {
+        parameters,
+        iterations: iteration + 1,
+        converged,
+        finalCost,
+        finalGradientNorm,
+        finalResidualNorm,
+        finalLambda,
+        finalStates: states,
+        finalConstraintNorm
+    };
+}
+/**
+ * Checks constraint violation and logs warning if needed.
+ */
+function checkConstraintViolation(currentParameters, currentStates, constraintFunction, constraintTolerance, iteration, logger) {
+    const constraint = constraintFunction(currentParameters, currentStates);
+    const constraintNorm = vectorNorm(constraint);
+    if (constraintNorm > constraintTolerance) {
+        logger.warn('constrainedLevenbergMarquardt', iteration, 'Constraint violation detected', [
+            { key: '||c(p,x)||:', value: constraintNorm },
+            { key: 'Tolerance:', value: constraintTolerance }
+        ]);
+    }
+    return { constraintNorm };
+}
+/**
+ * Solves damped normal equations for Levenberg-Marquardt step.
+ * Damping parameter lambda interpolates between Gauss-Newton (λ→0) and gradient descent (λ→∞).
+ * Returns step vector or increases lambda if Cholesky decomposition fails.
+ */
+function solveDampedNormalEquations(jtj, jtr, currentLambda, lambdaFactor) {
+    const parameterCount = jtj.rows;
+    const identity = Matrix.eye(parameterCount, parameterCount);
+    const dampedHessian = jtj.add(identity.mul(currentLambda));
+    const negativeJtr = jtr.mul(NEGATIVE_COEFFICIENT);
+    let stepMatrix;
+    try {
+        const cholesky = new CholeskyDecomposition(dampedHessian);
+        if (cholesky.isPositiveDefinite()) {
+            stepMatrix = cholesky.solve(negativeJtr);
+        }
+        else {
+            const newLambda = currentLambda * lambdaFactor;
+            return { newLambda };
+        }
+    }
+    catch (choleskyError) {
+        const newLambda = currentLambda * lambdaFactor;
+        return { newLambda };
+    }
+    const step = matrixToFloat64Array(stepMatrix);
+    const stepNorm = vectorNorm(step);
+    return { step, stepNorm };
+}
+/**
+ * Evaluates step quality by comparing new cost to current cost.
+ * Returns acceptance result with updated lambda based on cost improvement.
+ */
+function evaluateStepQuality(newParameters, newStates, newCost, currentCost, currentLambda, lambdaFactor, iteration, logger) {
+    if (newCost < currentCost) {
+        const newLambda = currentLambda / lambdaFactor;
+        logger.debug('constrainedLevenbergMarquardt', iteration, 'Step accepted', [
+            { key: 'Cost:', value: currentCost },
+            { key: 'New cost:', value: newCost },
+            { key: 'Lambda:', value: newLambda }
+        ]);
+        return { stepAccepted: true, newParameters, newStates, newLambda };
+    }
+    const newLambda = currentLambda * lambdaFactor;
+    logger.debug('constrainedLevenbergMarquardt', iteration, 'Step rejected', [
+        { key: 'Cost:', value: currentCost },
+        { key: 'New cost:', value: newCost },
+        { key: 'Lambda:', value: newLambda }
+    ]);
+    return { stepAccepted: false, newParameters, newStates, newLambda };
+}
+/**
+ * Tries a constrained Levenberg-Marquardt step by solving damped normal equations.
+ * Returns whether step was accepted and updated parameters/states/lambda.
+ */
+function tryConstrainedLevenbergMarquardtStep(jtj, jtr, currentParameters, currentStates, currentLambda, lambdaFactor, residualFunction, constraintFunction, currentCost, tolStep, iteration, stepSizeP, stepSizeX, constraintTolerance, logger, dcdp, dcdx) {
+    // Lambda threshold prevents infinite loops when matrix is severely ill-conditioned
+    if (currentLambda >= MAXIMUM_LAMBDA_THRESHOLD) {
+        logger.warn('constrainedLevenbergMarquardt', iteration, 'Lambda too large, stopping optimization', [
+            { key: 'Lambda:', value: currentLambda },
+            { key: 'Cost:', value: currentCost }
+        ]);
+        return { stepAccepted: false, newLambda: currentLambda, shouldStop: true };
+    }
+    try {
+        const solveResult = solveDampedNormalEquations(jtj, jtr, currentLambda, lambdaFactor);
+        if ('newLambda' in solveResult) {
+            return { stepAccepted: false, newLambda: solveResult.newLambda };
+        }
+        const { step, stepNorm } = solveResult;
+        if (checkStepSizeConvergence(stepNorm, tolStep, iteration)) {
+            const newLambda = currentLambda * lambdaFactor;
+            return { stepAccepted: false, newLambda, stepNorm };
+        }
+        const newParameters = new Float64Array(currentParameters.length);
+        for (let i = 0; i < currentParameters.length; i++) {
+            newParameters[i] = currentParameters[i] + step[i];
+        }
+        const c_x = dcdx
+            ? dcdx(currentParameters, currentStates)
+            : finiteDiffConstraintPartialX(currentParameters, currentStates, constraintFunction, { stepSize: stepSizeX });
+        const c_p = dcdp
+            ? dcdp(currentParameters, currentStates)
+            : finiteDiffConstraintPartialP(currentParameters, currentStates, constraintFunction, { stepSize: stepSizeP });
+        const newStates = updateStates(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 newCost = computeSumOfSquaredResiduals(newResidualNorm);
+        const evaluationResult = evaluateStepQuality(newParameters, projectedStates, newCost, currentCost, currentLambda, lambdaFactor, iteration, logger);
+        return {
+            stepAccepted: evaluationResult.stepAccepted,
+            newParameters,
+            newStates: evaluationResult.newStates,
+            newLambda: evaluationResult.newLambda
+        };
+    }
+    catch (error) {
+        // Numerical issues indicate ill-conditioning: increasing lambda improves conditioning
+        const newLambda = currentLambda * lambdaFactor;
+        if (logger) {
+            logger.warn('constrainedLevenbergMarquardt', iteration, 'Singular matrix encountered, increasing lambda', [
+                { key: 'Lambda:', value: newLambda },
+                { key: 'Cost:', value: currentCost }
+            ]);
+        }
+        return { stepAccepted: false, newLambda };
+    }
+}
+/**
+ * Checks convergence criteria for constrained Levenberg-Marquardt.
+ * 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)) {
+        logger.info('constrainedLevenbergMarquardt', iteration, 'Converged', [
+            { key: 'Cost:', value: cost },
+            { key: 'Gradient norm:', value: gradientNorm },
+            { key: 'Residual norm:', value: residualNorm },
+            { key: 'Constraint norm:', value: constraintNorm },
+            { key: 'Lambda:', value: currentLambda }
+        ]);
+        return createConvergenceResultForLM(currentParameters, currentStates, iteration, true, cost, gradientNorm, residualNorm, constraintNorm, currentLambda);
+    }
+    return null;
+}
+/**
+ * Tries steps with increasing lambda until an acceptable step is found.
+ * Returns step result or indicates that optimization should stop.
+ */
+function tryStepWithLambda(jtj, jtr, currentParameters, currentStates, currentLambda, lambdaFactor, residualFunction, constraintFunction, cost, tolStep, iteration, stepSizeP, stepSizeX, constraintTolerance, constraintSatisfied, gradientNorm, residualNorm, constraintNorm, logger, dcdp, dcdx) {
+    let stepAccepted = false;
+    let updatedLambda = currentLambda;
+    let updatedParameters;
+    let updatedStates;
+    while (!stepAccepted && updatedLambda < MAXIMUM_LAMBDA_THRESHOLD) {
+        const stepResult = tryConstrainedLevenbergMarquardtStep(jtj, jtr, currentParameters, currentStates, updatedLambda, lambdaFactor, residualFunction, constraintFunction, cost, tolStep, iteration, stepSizeP, stepSizeX, constraintTolerance, logger, dcdp, dcdx);
+        if (stepResult.shouldStop) {
+            return { stepAccepted: false, updatedLambda, shouldStop: true };
+        }
+        if (stepResult.stepNorm !== undefined &&
+            constraintSatisfied &&
+            checkStepSizeConvergence(stepResult.stepNorm, tolStep, iteration)) {
+            logger.info('constrainedLevenbergMarquardt', iteration, 'Converged', [
+                { key: 'Cost:', value: cost },
+                { key: 'Gradient norm:', value: gradientNorm },
+                { key: 'Residual norm:', value: residualNorm },
+                { key: 'Step size:', value: stepResult.stepNorm },
+                { key: 'Constraint norm:', value: constraintNorm },
+                { key: 'Lambda:', value: updatedLambda }
+            ]);
+            return { stepAccepted: false, updatedLambda, stepSizeConverged: true };
+        }
+        updatedLambda = stepResult.newLambda;
+        if (stepResult.stepAccepted && stepResult.newParameters && stepResult.newStates) {
+            updatedParameters = stepResult.newParameters;
+            updatedStates = stepResult.newStates;
+            stepAccepted = true;
+        }
+    }
+    if (!stepAccepted && updatedLambda >= MAXIMUM_LAMBDA_THRESHOLD) {
+        logger.warn('constrainedLevenbergMarquardt', iteration, 'Could not find acceptable step even with maximum lambda. Stopping optimization.', [
+            { key: 'Lambda:', value: updatedLambda },
+            { key: 'Cost:', value: cost }
+        ]);
+        return { stepAccepted: false, updatedLambda, shouldStop: true };
+    }
+    return { stepAccepted, updatedParameters, updatedStates, updatedLambda };
+}
+/**
+ * Processes step result and checks residual convergence.
+ * Returns convergence result if converged, or best solution found.
+ */
+function processStepResult(updatedParameters, updatedStates, updatedLambda, residualFunction, constraintFunction, constraintTolerance, tolResidual, iteration, gradientNorm, logger) {
+    const currentResidual = residualFunction(updatedParameters, updatedStates);
+    const currentResidualNorm = vectorNorm(currentResidual);
+    const currentCost = computeSumOfSquaredResiduals(currentResidualNorm);
+    const currentConstraint = constraintFunction(updatedParameters, updatedStates);
+    const currentConstraintNorm = vectorNorm(currentConstraint);
+    if (currentConstraintNorm <= constraintTolerance && checkResidualConvergence(currentResidualNorm, tolResidual, iteration)) {
+        logger.info('constrainedLevenbergMarquardt', iteration, 'Converged', [
+            { key: 'Cost:', value: currentCost },
+            { key: 'Gradient norm:', value: gradientNorm },
+            { key: 'Residual norm:', value: currentResidualNorm },
+            { key: 'Constraint norm:', value: currentConstraintNorm },
+            { key: 'Lambda:', value: updatedLambda }
+        ]);
+        return {
+            converged: true,
+            result: createConvergenceResultForLM(updatedParameters, updatedStates, iteration, true, currentCost, gradientNorm, currentResidualNorm, currentConstraintNorm, updatedLambda),
+            bestCost: currentCost,
+            bestParameters: updatedParameters,
+            bestStates: updatedStates
+        };
+    }
+    return {
+        converged: false,
+        bestCost: currentCost,
+        bestParameters: updatedParameters,
+        bestStates: updatedStates
+    };
+}
+/**
+ * Performs one iteration of constrained Levenberg-Marquardt optimization.
+ * Returns updated parameters/states/lambda or null if converged/error occurred.
+ */
+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 cost = computeSumOfSquaredResiduals(residualNorm);
+    if (onIteration) {
+        onIteration(iteration, cost, currentParameters);
+    }
+    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 constraintSatisfied = constraintNorm <= constraintTolerance;
+    const gradientConvergenceResult = checkConvergenceForLM(gradientNorm, constraintSatisfied, tolGradient, iteration, currentParameters, currentStates, cost, residualNorm, constraintNorm, currentLambda, logger);
+    if (gradientConvergenceResult) {
+        return {
+            converged: true,
+            result: gradientConvergenceResult
+        };
+    }
+    const stepResult = tryStepWithLambda(jtj, jtr, currentParameters, currentStates, currentLambda, lambdaFactor, residualFunction, constraintFunction, cost, tolStep, iteration, stepSizeP, stepSizeX, constraintTolerance, constraintSatisfied, gradientNorm, residualNorm, constraintNorm, logger, dcdp, dcdx);
+    if (stepResult.shouldStop) {
+        return { converged: false, shouldStop: true };
+    }
+    if (stepResult.stepSizeConverged) {
+        return {
+            converged: true,
+            result: createConvergenceResultForLM(currentParameters, currentStates, iteration, true, cost, gradientNorm, residualNorm, constraintNorm, stepResult.updatedLambda)
+        };
+    }
+    if (stepResult.stepAccepted && stepResult.updatedParameters && stepResult.updatedStates) {
+        const processResult = processStepResult(stepResult.updatedParameters, stepResult.updatedStates, stepResult.updatedLambda, residualFunction, constraintFunction, constraintTolerance, tolResidual, iteration, gradientNorm, logger);
+        if (processResult.converged && processResult.result) {
+            return {
+                converged: true,
+                result: processResult.result
+            };
+        }
+        return {
+            converged: false,
+            newParameters: processResult.bestParameters,
+            newStates: processResult.bestStates,
+            newLambda: stepResult.updatedLambda,
+            bestCost: processResult.bestCost,
+            bestParameters: processResult.bestParameters,
+            bestStates: processResult.bestStates
+        };
+    }
+    return { converged: false, newLambda: stepResult.updatedLambda };
+}
+/**
+ * Initializes state for constrained Levenberg-Marquardt optimization.
+ * Tracks best solution found to return if max iterations reached.
+ */
+function initializeLMState(initialParameters, initialStates, residualFunction) {
+    const currentParameters = new Float64Array(initialParameters);
+    const currentStates = new Float64Array(initialStates);
+    const bestParameters = new Float64Array(initialParameters);
+    const bestStates = new Float64Array(initialStates);
+    const initialResidual = residualFunction(initialParameters, initialStates);
+    const initialResidualNorm = vectorNorm(initialResidual);
+    const bestCost = computeSumOfSquaredResiduals(initialResidualNorm);
+    return { currentParameters, currentStates, bestParameters, bestStates, bestCost };
+}
+/**
+ * Runs main iteration loop for constrained Levenberg-Marquardt optimization.
+ * Returns result if converged, or final state if max iterations reached.
+ */
+function runLMIterations(initialParameters, initialStates, residualFunction, constraintFunction, effectiveJacobianOptions, tolGradient, tolStep, tolResidual, constraintTolerance, stepSizeP, stepSizeX, lambdaInitial, lambdaFactor, maxIterations, logger, onIteration, dcdp, dcdx) {
+    const state = initializeLMState(initialParameters, initialStates, residualFunction);
+    let currentLambda = lambdaInitial;
+    let actualIterations = 0;
+    for (let iteration = 0; iteration < maxIterations; iteration++) {
+        actualIterations = iteration + 1;
+        const iterationResult = performConstrainedLevenbergMarquardtIteration(state.currentParameters, state.currentStates, currentLambda, residualFunction, constraintFunction, effectiveJacobianOptions, tolGradient, tolStep, tolResidual, constraintTolerance, stepSizeP, stepSizeX, lambdaFactor, iteration, logger, onIteration, dcdp, dcdx);
+        if (iterationResult.converged && iterationResult.result) {
+            return { result: iterationResult.result };
+        }
+        if (iterationResult.shouldStop) {
+            break;
+        }
+        if (iterationResult.bestCost !== undefined && iterationResult.bestCost < state.bestCost) {
+            state.bestCost = iterationResult.bestCost;
+            if (iterationResult.bestParameters && iterationResult.bestStates) {
+                state.bestParameters = new Float64Array(iterationResult.bestParameters);
+                state.bestStates = new Float64Array(iterationResult.bestStates);
+            }
+        }
+        if (iterationResult.newLambda !== undefined) {
+            currentLambda = iterationResult.newLambda;
+        }
+        if (iterationResult.newParameters && iterationResult.newStates) {
+            state.currentParameters = iterationResult.newParameters;
+            state.currentStates = iterationResult.newStates;
+        }
+    }
+    return {
+        bestParameters: state.bestParameters,
+        bestStates: state.bestStates,
+        bestCost: state.bestCost,
+        currentLambda,
+        actualIterations
+    };
+}
+/**
+ * Creates final result when max iterations reached or optimization stopped.
+ * Computes final gradient norm for diagnostic purposes.
+ */
+function createFinalLMResult(bestParameters, bestStates, bestCost, currentLambda, actualIterations, residualFunction, constraintFunction, effectiveJacobianOptions, logger) {
+    const finalResidual = residualFunction(bestParameters, bestStates);
+    const finalResidualNorm = vectorNorm(finalResidual);
+    const finalConstraint = constraintFunction(bestParameters, bestStates);
+    const finalConstraintNorm = vectorNorm(finalConstraint);
+    const finalEffectiveJacobian = computeEffectiveJacobian(bestParameters, bestStates, residualFunction, constraintFunction, effectiveJacobianOptions, logger, 'constrainedLevenbergMarquardt');
+    const { jtr: finalJtr } = computeNormalEquationsMatrices(finalEffectiveJacobian, finalResidual);
+    const finalGradientNorm = vectorNorm(matrixToFloat64Array(finalJtr));
+    return createConvergenceResultForLM(bestParameters, bestStates, actualIterations - 1, false, bestCost, finalGradientNorm, finalResidualNorm, finalConstraintNorm, currentLambda);
+}
+/**
+ * Performs constrained Levenberg-Marquardt optimization for nonlinear least squares problems.
+ *
+ * Algorithm:
+ * 1. Start with initial parameters p0, states x0, and lambda (damping parameter)
+ * 2. Compute effective Jacobian J_eff = r_p - r_x C_x^+ C_p
+ * 3. Solve damped normal equations: (J_eff^T J_eff + λI) δ = -J_eff^T r
+ * 4. Try step: p_new = p_old + δ, x_new updated using linear approximation
+ * 5. If cost decreases: accept step, decrease lambda
+ * 6. If cost increases: reject step, increase lambda
+ * 7. Repeat until convergence
+ *
+ * The damping parameter lambda interpolates between:
+ * - Constrained Gauss-Newton (λ → 0): fast convergence near solution
+ * - Constrained gradient descent (λ → ∞): robust but slow
+ *
+ * @param initialParameters - Initial parameter vector p0
+ * @param initialStates - Initial state vector x0 (should satisfy c(p0, x0) = 0)
+ * @param residualFunction - Residual function r(p, x)
+ * @param constraintFunction - Constraint function c(p, x) = 0
+ * @param options - Optimization options
+ * @returns Optimization result with final parameters, states, constraint norm, and lambda
+ */
+export function constrainedLevenbergMarquardt(initialParameters, initialStates, residualFunction, constraintFunction, options = {}) {
+    const maxIterations = options.maxIterations ?? DEFAULT_MAX_ITERATIONS;
+    const lambdaInitial = options.lambdaInitial ?? DEFAULT_LAMBDA_INITIAL;
+    const lambdaFactor = options.lambdaFactor ?? DEFAULT_LAMBDA_FACTOR;
+    const tolGradient = options.tolGradient ?? DEFAULT_TOL_GRADIENT;
+    const tolStep = options.tolStep ?? DEFAULT_TOL_STEP;
+    const tolResidual = options.tolResidual ?? DEFAULT_TOL_RESIDUAL;
+    const constraintTolerance = options.constraintTolerance ?? DEFAULT_CONSTRAINT_TOLERANCE;
+    const stepSizeP = options.stepSizeP ?? DEFAULT_STEP_SIZE_P;
+    const stepSizeX = options.stepSizeX ?? DEFAULT_STEP_SIZE_X;
+    const onIteration = options.onIteration;
+    const logger = new Logger(options.logLevel, options.verbose);
+    validateInitialConditions(initialParameters, initialStates, constraintFunction, constraintTolerance, logger, 'constrainedLevenbergMarquardt');
+    const effectiveJacobianOptions = {
+        drdp: options.drdp,
+        drdx: options.drdx,
+        dcdp: options.dcdp,
+        dcdx: options.dcdx,
+        stepSizeP,
+        stepSizeX
+    };
+    const iterationResult = runLMIterations(initialParameters, initialStates, residualFunction, constraintFunction, effectiveJacobianOptions, tolGradient, tolStep, tolResidual, constraintTolerance, stepSizeP, stepSizeX, lambdaInitial, lambdaFactor, maxIterations, logger, onIteration, options.dcdp, options.dcdx);
+    if ('result' in iterationResult) {
+        return iterationResult.result;
+    }
+    const finalResidual = residualFunction(iterationResult.bestParameters, iterationResult.bestStates);
+    const finalResidualNorm = vectorNorm(finalResidual);
+    const finalConstraint = constraintFunction(iterationResult.bestParameters, iterationResult.bestStates);
+    const finalConstraintNorm = vectorNorm(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 residual norm:', value: finalResidualNorm },
+        { key: 'Final constraint norm:', value: finalConstraintNorm },
+        { key: 'Final lambda:', value: iterationResult.currentLambda }
+    ]);
+    return createFinalLMResult(iterationResult.bestParameters, iterationResult.bestStates, iterationResult.bestCost, iterationResult.currentLambda, iterationResult.actualIterations, residualFunction, constraintFunction, effectiveJacobianOptions, logger);
+}
+//# sourceMappingURL=constrainedLevenbergMarquardt.js.map

package/dist/core/constrainedLevenbergMarquardt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constrainedLevenbergMarquardt.js","sourceRoot":"","sources":["../../src/core/constrainedLevenbergMarquardt.ts"],"names":[],"mappings":"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"}

package/dist/core/constrainedUtils.d.ts

@@ -0,0 +1,92 @@
+/**
+ * This file provides shared utility functions for constrained optimization algorithms
+ * using the adjoint method.
+ *
+ * Role in system:
+ * - Eliminates code duplication between adjointGradientDescent, constrainedGaussNewton, and constrainedLevenbergMarquardt
+ * - Centralizes adjoint method computation logic (DRY principle)
+ * - Provides reusable functions for state updates and constraint handling
+ *
+ * For first-time readers:
+ * - These are utility functions used internally by constrained optimization algorithms
+ * - solveAdjointEquation: Solves the adjoint equation for computing gradients
+ * - updateStates: Updates states using linear approximation to maintain constraint satisfaction
+ * - validateInitialConditions: Validates initial states and constraints
+ *
+ * Extracted from adjointGradientDescent.ts to enable code reuse.
+ */
+import { Matrix } from 'ml-matrix';
+import type { ConstraintFn } from './types.js';
+import { Logger } from './logger.js';
+/**
+ * Solves a least squares problem Ax = b using Cholesky decomposition.
+ * For square matrices, uses Cholesky/LU decomposition directly.
+ * For non-square matrices, uses normal equations to convert to square system:
+ * - Overdetermined (rows > columns): A^T A x = A^T b (Cholesky on A^T A)
+ * - Underdetermined (rows < columns): A A^T y = b, x = A^T y (Cholesky on A A^T)
+ * This approach avoids SVD/pseudoInverse entirely for better performance.
+ *
+ * @param A - Coefficient matrix
+ * @param b - Right-hand side vector (as Matrix column vector)
+ * @param logger - Logger for error messages
+ * @param algorithmName - Name of calling algorithm (for error messages)
+ * @returns Solution vector x as Float64Array
+ */
+export declare function solveLeastSquares(A: Matrix, b: Matrix, logger: Logger, algorithmName?: string, regularization?: number): Float64Array;
+/**
+ * Solves the adjoint equation: (∂c/∂x)^T λ = rhs
+ * Returns the adjoint variable λ.
+ * Supports both square and non-square constraint Jacobians.
+ *
+ * This is the core of the adjoint method, used for efficient gradient computation
+ * without explicitly inverting matrices.
+ *
+ * @param dcdx - Constraint Jacobian ∂c/∂x
+ * @param rhs - Right-hand side vector (e.g., (∂f/∂x)^T or (r_x^T r))
+ * @param logger - Logger instance for error reporting
+ * @param algorithmName - Name of calling algorithm (for error messages)
+ * @returns Adjoint variable λ
+ */
+export declare function solveAdjointEquation(dcdx: Matrix, rhs: Float64Array, logger: Logger, algorithmName?: string, regularization?: number): Float64Array;
+/**
+ * Updates states using linear approximation: x_new = x_old + dx
+ * where dx solves (∂c/∂x) dx = -∂c/∂p · Δp
+ * Supports both square and non-square constraint Jacobians.
+ *
+ * This maintains constraint satisfaction approximately using first-order Taylor expansion.
+ * For large steps, constraints may be violated slightly, but the algorithm will correct
+ * this in subsequent iterations.
+ *
+ * @param currentStates - Current state vector x
+ * @param dcdx - Constraint Jacobian ∂c/∂x
+ * @param dcdp - Constraint Jacobian ∂c/∂p
+ * @param deltaP - Parameter change Δp
+ * @param logger - Logger instance for error reporting
+ * @param algorithmName - Name of calling algorithm (for error messages)
+ * @returns Updated state vector x_new
+ */
+export declare function updateStates(currentStates: Float64Array, dcdx: Matrix, dcdp: Matrix, deltaP: Float64Array, logger: Logger, algorithmName?: string): Float64Array;
+/**
+ * Projects states onto the constraint manifold for fixed parameters using
+ * a few Newton correction steps: (∂c/∂x) Δx = -c(p, x).
+ * This is a standard feasibility-restoration step consistent with the
+ * implicit function theorem (solving c(p, x) = 0 locally).
+ */
+export declare function projectStatesToConstraints(parameters: Float64Array, states: Float64Array, constraintFunction: ConstraintFn, stepSizeX: number, constraintTolerance: number, logger: Logger, algorithmName?: string, maxIterations?: number): Float64Array;
+/**
+ * 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)
+ *
+ * @param initialParameters - Initial parameter vector p0
+ * @param initialStates - Initial state vector x0
+ * @param constraintFunction - Constraint function c(p, x) = 0
+ * @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
+ */
+export declare function validateInitialConditions(initialParameters: Float64Array, initialStates: Float64Array, constraintFunction: ConstraintFn, constraintTolerance: number, logger: Logger, algorithmName?: string): void;
+//# sourceMappingURL=constrainedUtils.d.ts.map

package/dist/core/constrainedUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constrainedUtils.d.ts","sourceRoot":"","sources":["../../src/core/constrainedUtils.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAE,MAAM,EAAgC,MAAM,WAAW,CAAC;AACjE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAG/C,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAyQrC;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iBAAiB,CAC/B,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,MAAM,EAAE,MAAM,EACd,aAAa,GAAE,MAAkC,EACjD,cAAc,GAAE,MAAU,GACzB,YAAY,CAgBd;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,YAAY,EACjB,MAAM,EAAE,MAAM,EACd,aAAa,GAAE,MAAkC,EACjD,cAAc,GAAE,MAAU,GACzB,YAAY,CAkBd;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,YAAY,CAC1B,aAAa,EAAE,YAAY,EAC3B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,YAAY,EACpB,MAAM,EAAE,MAAM,EACd,aAAa,GAAE,MAAkC,GAChD,YAAY,CAcd;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CACxC,UAAU,EAAE,YAAY,EACxB,MAAM,EAAE,YAAY,EACpB,kBAAkB,EAAE,YAAY,EAChC,SAAS,EAAE,MAAM,EACjB,mBAAmB,EAAE,MAAM,EAC3B,MAAM,EAAE,MAAM,EACd,aAAa,GAAE,MAAkC,EACjD,aAAa,GAAE,MAAU,GACxB,YAAY,CAyBd;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,yBAAyB,CACvC,iBAAiB,EAAE,YAAY,EAC/B,aAAa,EAAE,YAAY,EAC3B,kBAAkB,EAAE,YAAY,EAChC,mBAAmB,EAAE,MAAM,EAC3B,MAAM,EAAE,MAAM,EACd,aAAa,GAAE,MAAkC,GAChD,IAAI,CAYN"}