Add MadNLP solver support through CasADi

[mickaelbegon]

Disclosure: This issue text and technical analysis were prepared by OpenAI Codex from the implementation and benchmark results on the linked branch, and reviewed by the branch author.

Motivation

Add MadNLP as an optional nonlinear programming solver in Bioptim through CasADi’s nlpsol interface.

MadNLP may be useful for large optimal-control problems and biomechanical problems where exact Hessian and constraint-Jacobian evaluations are expensive.

Reference implementation

A working implementation is available on this branch:

• Implementation: https://github.com/mickaelbegon/BiorbdOptim/tree/codex/madnlp-integration-master
• Installation instructions and benchmarks: https://github.com/mickaelbegon/BiorbdOptim/blob/codex/madnlp-integration-master/benchmarks/README.md
• Successful Linux CI run: https://github.com/mickaelbegon/BiorbdOptim/actions/runs/30048124748

Proposed scope

• Add Solver.MADNLP().
• Expose convergence tolerance, constraint tolerance, maximum iterations, verbosity, and advanced MadNLP options.
• Pass primal and dual warm-start values through the standard CasADi inputs.
• Normalize MadNLP status, feasibility, iteration count, and timing information in Solution.
• Keep MadNLP optional so Bioptim remains importable when the plugin is unavailable.
• Add unit and integration tests.
• Document the Linux installation procedure.
• Add reproducible GitHub Actions tests and solver benchmarks.

Current validation

The reference branch contains a Linux benchmark comparing MadNLP, IPOPT, FATROP, and ACADOS on nine problem sizes.

Notable hot-run results include:

• 500-interval pendulum: MadNLP 33.430 s, IPOPT 40.398 s.
• Hessian-heavy muscle-fatigue problem: MadNLP 17.397 s, IPOPT 23.002 s.
• On the muscle-fatigue problem, MadNLP uses 57 iterations versus 67 for IPOPT.

Costs and constraint violations are reported in the benchmark README to verify solution equivalence.

Installation considerations

The main difficulty is providing an ABI-compatible combination of:

• CasADi with the MadNLP plugin;
• the MadNLP C/Julia runtime;
• RBDL-CasADi and biorbd.

The reference branch includes a reproducible Ubuntu workflow that installs the official CasADi wheel, compiles RBDL-CasADi and biorbd against the same ABI, verifies the MadNLP runtime checksum, and runs the integration tests.

Known limitations

• Online optimization callbacks are not currently supported.
• Bioptim’s c_compile path is disabled for MadNLP.
• The free-time benchmark currently fails in MadNLP.
• The contact-inequality case returns a nearly equivalent objective but does not meet the benchmark feasibility threshold.

Would the maintainers be interested in turning this reference branch into a pull request?

[mickaelbegon]

Disclosure: This implementation update and benchmark analysis were prepared by OpenAI Codex from the linked branches and GitHub Actions artifacts, and reviewed by the branch author.

Implementation update (2026-07-28)

The MadNLP work has been rebased onto a clean origin/master worktree and extended with configurable linear-solver support:

• Current Bioptim branch: https://github.com/mickaelbegon/BiorbdOptim/tree/codex/madnlp-linear-solvers
• Benchmark and installation README: https://github.com/mickaelbegon/BiorbdOptim/blob/codex/madnlp-linear-solvers/benchmarks/README.md
• Complete Linux validation: https://github.com/mickaelbegon/BiorbdOptim/actions/runs/30322800572
• PARDISO-enabled libMad branch: https://github.com/mickaelbegon/libMad/tree/codex/pardiso-mkl
• libMad Linux build validation: https://github.com/mickaelbegon/libMad/actions/runs/30321250184

The implementation now exposes MUMPS, UMFPACK, and PARDISO MKL through Solver.MADNLP(). PARDISO can be selected with three profiles:

• baseline: upstream MadNLPPardiso.PardisoMKLSolver;
• robust: scaling, symmetric weighted matching, 1e-8 tiny-pivot perturbation, automatic refinement, sparse-matrix validation, and up to two iterative-refinement steps;
• robust_inertia_free: the robust factorization with MadNLP's inertia-free correction and 1e-8 initial primal/dual regularization.

The reproducible Ubuntu 24.04 workflow builds the pinned Julia/libMad runtime, compiles CasADi 3.8 against it, installs biorbd/Bioptim, verifies that each PARDISO profile is actually selected, and runs MUMPS plus the three profiles on the same nine-case matrix. Each cell uses one cold solve followed by three hot solves, with all numerical libraries restricted to one thread.

Linux benchmark summary

• MUMPS succeeds on 9/9 cases.
• PARDISO baseline succeeds on 7/9.
• PARDISO robust succeeds on 8/9 and is the best general PARDISO profile tested.
• PARDISO robust inertia-free succeeds on 7/9; it recovers the multiphase case but fails on free_time and the 500-interval pendulum, so it is better treated as a targeted fallback.
• On the seven cost-equivalent successes shared by robust PARDISO and MUMPS, robust PARDISO reduces aggregate cold wall time by 2.8%, hot wall time by 4.3%, and reported solver time by 6.2%.
• On the 500-interval pendulum, hot wall time is 55.852 s with MUMPS, 43.018 s with baseline PARDISO, and 43.408 s with robust PARDISO.
• On the Hessian-heavy muscle-fatigue case, robust PARDISO needs 63 iterations and 23.544 s hot, versus 123 iterations and 44.958 s for baseline PARDISO. MUMPS remains slightly faster at 64 iterations and 20.774 s.

The robust free_time solve is feasible but reaches a different, substantially lower objective (109.838911 versus 1137.695623 with MUMPS), so that timing is not considered a like-for-like comparison and the trajectory should be inspected. The inertia-free muscle-fatigue objective differs from MUMPS by 0.0339%. All other successful cost differences are below 0.01%, with constraint violations below the requested 1e-6 tolerance.

The current evidence therefore supports keeping MUMPS as the default robust backend, offering robust PARDISO as an opt-in backend for large sparse KKT systems, and retaining the inertia-free profile as a formulation-specific fallback.