CasADi v3.6.3
latest released May 17, 2023Grab a binary from the table:
Windows  Linux  Mac classic (High Sierra or above)  Mac M1  

Matlab  R2018b or later  R2018b or later  R2018b or later  R2020b or later (normal Matlab) R2018b or later (Open Beta) 
Octave  6.2.0 or later  6.2.0 or later  6.2.0 or later  6.2.0 or later 
Python  pip install casadi (needs pip V >=8.1) 
For Matlab/Octave, unzip in your home directory and adapt the path:
addpath('<yourpath>/casadi3.6.3windows64matlab2018b')
Check your installation:
Matlab/Octave  Python 



Get started with the example pack. Onboarding pointers have been gathered by the community at our wiki.
Symbolic expressions
 Added SX/MX/DM operations #1595:
hypot(x,y) = sqrt(x*x+y*y)
log1p(x) = log(1+x)
expm1(x) = exp(x1)
 Added operation
remainder
with the semantics of the C operation  breaking AD rule of
fmin/
fmax` is now symmetric:jacobian(fmin(x,y),vertcat(x,y))
used to be [1 0] for x==y. Now yields [0.5 0.5].  Added AD rules for
mmin
/mmax
 Added
logsumexp
which behaves likelog(sum(exp(x)))
but is numerically more accurate (and no overflow issues).  breaking
vertcat
/vcat
,horzcat
/hcat
, etc now return aDM
type instead of aSparsity
type #2549  breaking CasADiMatlab
mod
has been renamed torem
, because its numerical behaviour is like the builtinMatlabrem
. The builtinMatlabmod
has no CasADi counterpart. CasADiPythonmod
has been removed, because its numerical behaviour is not likenumpy.mod
. #2767.numpy.mod
has no counterpart in CasADi; onlyfmod
is equivalent.  DAE index reduction support (Pantelides structural algorithm) See https://github.com/casadi/casadi/blob/3.6.0/docs/examples/python/dae_reduced_index.py
 Fixed flaw in codegen with MX if_else
Common subexpression elimination
 Added Common Subexpression Elimination #1540 for MX and SX. CasADi can now efficiently eliminate redundant computation by inspecting an expression graph and removing redundant nodes.
Before, CasADi internals would avoid introducing redundant nodes during operations on a given expression, but the user was responsible to avoid duplication when constructing that expression.
There is a function cse()
that you may apply to expressions:
x = MX.sym('x')
# User responsibility
sx = sin(x)
y = sqrt(sx)+sx # MX(@1=sin(x), (sqrt(@1)+@1))
# cse
y = sqrt(sin(x))+sin(x) # MX((sqrt(sin(x))+sin(x)))
y = cse(y) # MX(@1=sin(x), (sqrt(@1)+@1))
There is a boolean option cse
that may be used when constructing a Function
:
x = MX.sym('x')
f = Function('f',[x],[sqrt(sin(x))+sin(x)],{"cse":True})
f.disp(True)
f:(i0)>(o0) MXFunction
Algorithm:
@0 = input[0][0]
@0 = sin(@0)
@1 = sqrt(@0)
@1 = (@1+@0)
output[0][0] = @1
The technique scales favorably for large graphs.
Triangular solve triangular solve nodes in MX
MX how has atomic support for solving upper and lower triangular linear systems without allocating any linear solver instance. The operation handles the case with unity diagonal separately for efficiency and supports C code generation. To use the feature, call casadi.solve(A, b)
(Python or MATLAB/Octave)
# Python
import casadi
A = casadi.MX.sym('A', casadi.Sparsity.upper(2))
b = casadi.MX.sym('b', 2)
x = casadi.solve(A, b)
// C++
casadi::MX A = casadi::MX::sym("A", casadi::Sparsity::upper(2));
casadi::MX b = casadi::MX::sym("b", 2);
casadi::MX x = solve(A, b); // for argumentdependent lookup, alternatively casadi::MX::solve(A, b) for static function
Cf. #2688.
Function
 breaking
SX
/MX
Function
construction with free variables (i.e. symbols used in the output expressions that are not declared as inputs) now fails immediately unless theallow_free
option is used.  breaking
SX
/MX
Function
construction now fails if there are duplicates in input names or output names, unless theallow_duplicate_io_names
option is used #2604.  breaking Serialization: files saved with CasADi 3.5.5 will load in CasADi 3.6.0 (unittested), except for Functions that include a ‘mumps’ linear solver since serialization of this solver was deficient, and except for Functions that include an Integrator.
 breaking
custom_jacobian
semantics changed. The Function must now return individual blocks (Jacobian of an output w.r.t. to an input)  breaking Changed API part for Jacobian sparsity (relevant for advanced use through
external
orCallback
)
bool has_jac_sparsity(casadi_int oind, casadi_int iind) const override;
Sparsity get_jac_sparsity(casadi_int oind, casadi_int iind, bool symmetric) const override;
Function.find_function
Can be used to retrieve Functions in a hierarchy. Avoid truncation in printing #2452
 breaking: Function outputs that are not used (passed a null pointer internally) will be logged (
dump_in
option ) asnan
instead of earlier0
. E.g. Ipoptnlp_grad_f
has two outputs,f
andgrad_f_x
. Thef
output is not used internally, so will be logged asnan
.
Codegeneration
Function
objects with anexternal
call can now be codegenerated.mmin
/mmax
now support codegeneration
Solvers/plugins
nlpsol
/Opti.solver
can now take an option ‘detect_simple_bounds’ (defaultFalse
) that will promote general constraints to simple bounds (lbx/ubx). Added SPRAL linear solver for Ipopt
 Added QP solvers HPIPM, Proxqp, Highs
 CPLEX interface will dynamically load
libcplex<CPLEX_VERSION>
, where CPLEX_VERSION is read from environmental variables. Same strategy forGurobi
.  SqpMethod Eigenreflect/eigenclip incorrect #2896
Generalized integrator support
The Integrator
class, which solves initialvalue problems in ODEs and DAEs has been thoroughly refactored. Changes include:
 The integrator class now has a much more mature support for returning the IVP solution at multiple time points. It can now be obtained by providing a time grid to the
integrator
constructor. Unlike before, this support should now work in combination with forward/adjoint sensitivity analysis (to any order) and sparsity pattern calculations. Cf. #2823.  The integrator class now includes support for a piecewise constant control (
u
). The interface will keep track of changes tou
and avoid integrating past such changes; for the Sundials (CVODES/IDAS) interfaces by setting a “stop time”, for fixed step integrators by aligning the integration points with the grid points. Cf. #3025. Development versions of CasADi included support for this in a dedicated class, calledSimulator
, but this class has now been removed (breaking) and the functionality has been ported to theIntegrator
class. If you had code looking likecs.integrator('sim_function', 'cvodes', dae, tgrid, opts)
, you may replace it bycs.integrator('sim_function', 'cvodes', dae, 0, tgrid[1:], opts)
.  The Integrator class now much better exploits the problem structure in the sensitivity calculations, especially adjoint (and forwardoveradjoint, adjointoveradjoint) sensitivity calculations. Cf. #2823, #3047. The sensitivity analysis relies to a much less extent on symbolic reformulations and instead uses calls to the
Function
class for derivative calculations  this makes the class now more efficient for use with nonsymbolic DAEs, including FMUs or other external models.  breaking The options
t0
,tf
,output_t0
andgrid
have been deprecated and will result in a warning if used. Instead, the user can provide equivalent information via theintegrator
constructor, cf. previous point.  The
backward states
are no longer part of the DAE formulation. They are now derived from a user specified number of sensitivity equations (nadj
). This is a slight restriction in the possible problem formulations, but on the other hand allows for a much better exploitation of adjoint sensitivity structure. The the backward states remain in the integrator class function inputs and outputs, but have now been renamed to align with their meaning;adj_xf
means the adjoint seeds corresponding toxf
(before they were calledrx0
),adj_p
are the adjoint sensitivities corresponding top
(before calledrqf
and so on.  An option
scale_abstol
has been added to the Sundials integrators. If this is set to true, nominal values for the differential state and algebraic variables will be passed on to the solver. Cf. #3046
See “multipoint_simulation” in the example pack for a good starting point.
Function factory
 breaking* Hessian blocks are now symmetric by default instead of returning only the upper triangular part. Prefix with
triu:
to get the old behavior.  breaking Multiple Jacobian and/or Hessian blocks can now be calculated more efficiently. Rather than calculating the blocks separately, calculation is done for multiple blocks at once, whenever possible. Cf. #2696.
DaeBuilder / FMI interoperability
 The dependent parameters
d
and local dependent variablesw
have been replaced by the single dependent variablesv
.  The DaeBuilder::create function has been reimplemented and now uses the updated Function::factory support (above).
 New proofofconcept support for export of models in FMI 3.0 format, cf. #3009
 New binary interface to standard FMI, including analytic validated first derivatives and validated hybrid second derivatives, cf. #2779
 The Integrator class has been refactored to efficiently support nonsymbolic DAEs, including from FMI  see below.
Binaries
 Adding Python interfaces for versions 3.10 and 3.11
 Adding builds for Mac silicon
 Octave interface will now dynamically couple with the correct versioned
octaveinterp
version, such that the new binaries work with future releases of Octave that increment theoctaveinterp
ABI version number.
CLI
 There is now a CasADi command line interface,
casadicli
. At the moment, functionality is very limited, justeval_dump
, to evaluate Function that have been dumped to the disk (optionsdump
,dump_in
)
Documentation
 There was a substantial effort to create an onboarding guide: https://github.com/casadi/casadi/wiki/OnboardingGuide
Building
 Source builds are no longer dependent on SWIG since Python and Matlab interface files generated by SWIG are now shipped in source archives.
 Source builds can now build and integrate a range thirdparty opensource solver automatically. E.g.
DWITH_IPOPT=ON DWITH_BUILD_REQUIRED=ON
 Source builds can now use mockups for a range of thirdparty commercial solvers. E.g.
DWITH_CPLEX=ON DWITH_MOCKUP_CPLEX=ON
 Source packages for python
pip
are now available
Plugin versions used in binaries
3.6.0
 dynamicloading, Compile with support for dynamic loading of FMU libraries
 sundialsinterface, Interface to the ODE/DAE integrator suite SUNDIALS.
 csparseinterface, Interface to the sparse direct linear solver CSparse.
 superscsinterface, Interface to QP solver SUPERSCS.
 osqpinterface, Interface to QP solver OSQP.
 tinyxmlinterface, Interface to the XML parser TinyXML.
 qpoasesinterface, Interface to the activeset QP solver qpOASES.
 blocksqpinterface, Interface to the NLP solver blockSQP.
 cplexmockupbuild, Use mockup CPLEX (BUILD_MOCKUPS_VERSION=v60) from downloaded source (BUILD_MOCKUPS_GIT_REPO=https://github.com/casadi/mockups.git).
 snoptmockupbuild, Use mockup SNOPT (BUILD_MOCKUPS_VERSION=v60) from downloaded source (BUILD_MOCKUPS_GIT_REPO=https://github.com/casadi/mockups.git).
 knitromockupbuild, Use mockup KNITRO (BUILD_MOCKUPS_VERSION=v60) from downloaded source (BUILD_MOCKUPS_GIT_REPO=https://github.com/casadi/mockups.git).
 gurobimockupbuild, Use mockup GUROBI (BUILD_MOCKUPS_VERSION=v60) from downloaded source (BUILD_MOCKUPS_GIT_REPO=https://github.com/casadi/mockups.git).
 worhpmockupbuild, Use mockup WORHP (BUILD_MOCKUPS_VERSION=v60) from downloaded source (BUILD_MOCKUPS_GIT_REPO=https://github.com/casadi/mockups.git).
 hslmockupbuild, Use mockup WORHP (BUILD_MOCKUPS_VERSION=v60) from downloaded source (BUILD_MOCKUPS_GIT_REPO=https://github.com/casadi/mockups.git).
 highssourcebuild, Build HiGHS (BUILD_HIGHS_VERSION=v1.4.1) from downloaded source (BUILD_HIGHS_GIT_REPO=https://github.com/ERGOCode/HiGHS).
 proxqpsourcebuild, Build PROXQP (BUILD_PROXQP_VERSION=v0.3.2) from downloaded source (BUILD_PROXQP_GIT_REPO=https://github.com/SimpleRobotics/proxsuite.git).
 osqpsourcebuild, Build OSQP (BUILD_OSQP_VERSION=v0.6.2) from downloaded source (BUILD_OSQP_GIT_REPO=https://github.com/osqp/osqp.git).
 superscssourcebuild, Build SuperSCS (BUILD_SUPERSCS_VERSION=4d2d1bd03ed4cf93e684a880b233760ce34ca69c) from downloaded source (BUILD_SUPERSCS_GIT_REPO=https://github.com/jgillis/scs.git).
 bonminsourcebuild, Build BONMIN (BUILD_BONMIN_VERSION=releases/1.8.8) from downloaded source (BUILD_BONMIN_GIT_REPO=https://github.com/coinor/Bonmin.git).
 ipoptsourcebuild, Build IPOPT (BUILD_IPOPT_VERSION=3.14.11.mod) from downloaded source (BUILD_IPOPT_GIT_REPO=https://github.com/jgillis/Ipopt1.git).
 cbcsourcebuild, Build CBC (BUILD_CBC_VERSION=releases/2.10.6) from downloaded source.
 clpsourcebuild, Build CLP (BUILD_CLP_VERSION=releases/1.17.7) from downloaded source (BUILD_CLP_GIT_REPO=https://github.com/coinor/Clp.git).
 mumpssourcebuild, Build MUMPS (BUILD_MUMPS_TP_VERSION=releases/3.0.2) from downloaded source (BUILD_MUMPS_TP_GIT_REPO=https://github.com/coinortools/ThirdPartyMumps.git).
 spralsourcebuild, Build SPRAL (BUILD_SPRAL_VERSION=d385d2c9e858366d257cafaaf05760ffa6543e26) from downloaded source (BUILD_SPRAL_GIT_REPO=https://github.com/ralna/spral.git).
 metissourcebuild, Build METIS (BUILD_METIS_TP_VERSION=releases/2.0.0) from downloaded source.
 hpipmsourcebuild, Build HPIPM (BUILD_HPIPM_VERSION=0e0c9f4e0d4081dceafa9b37c396db50bce0e81a) from downloaded source (BUILD_HPIPM_GIT_REPO=https://github.com/jgillis/hpipm.git).
 blasfeosourcebuild, Build BLASFEO (BUILD_BLASFEO_VERSION=edf92b396adddd9e548b9786f87ad290a0971329) from downloaded source (BUILD_BLASFEO_GIT_REPO=https://github.com/giaf/blasfeo.git).
 lapacksourcebuild, Download and install OpenBLAS for LAPACK+BLAS
 eigen3sourcebuild, Build Eigen (BUILD_EIGEN3_VERSION=3.4.0) from downloaded source (BUILD_EIGEN3_GIT_REPO=https://gitlab.com/libeigen/eigen.git).
 simdesourcebuild, Build Simde (BUILD_SIMDE_VERSION=v0.7.2) from downloaded source (BUILD_SIMDE_GIT_REPO=https://github.com/simdeverywhere/simde.git).
 cplexinterface, Interface to the QP solver CPLEX.
 gurobiinterface, Interface to the (mixedinteger) QP solver GUROBI
 knitrointerface, Interface to the NLP solver KNITRO.
 snoptinterface, Interface to the NLP solver SNOPT.
 worhpinterface, Interface to the NLP solver Worhp (requires gfortran, gomp).
 lapackinterface, Interface to LAPACK.
 mumpsinterface, Interface to MUMPS.
 spralinterface, Interface to SPRAL.
 coinutilssourcebuild, Build COINUTILS (BUILD_COINUTILS_VERSION=releases/2.11.6) from downloaded source.
 osisourcebuild, Build OSI (BUILD_OSI_VERSION=releases/0.108.7) from downloaded source.
 clpinterface, Interface to the LP solver CLP.
 cglsourcebuild, Build CGL (BUILD_CGL_VERSION=releases/0.60.4) from downloaded source.
 cbcinterface, Interface to the LP solver CBC.
 ipoptinterface, Interface to the NLP solver Ipopt.
 bonmininterface, Interface to the MINLP framework Bonmin.
 highsinterface, Interface to the MILP / QP solver HiGHS.
 proxqpinterface, Interface to QP solver PROXQP.
 amplinterface, Interface to the AMPL solver library.
Changes in 3.6.1
 Various bugfixes and patches https://github.com/casadi/casadi/milestone/24?closed=1
 breaking serialization of integrator is not compatible with 3.6.0 due to bugfixes
 git:
master
branch has been renamed tomain
, and has different semantics: it will be the branch where new features are added regularly before they become an official release. Latest official release is available aslatest
branch.
Changes in 3.6.2
 Various bugfixes and patches https://github.com/casadi/casadi/milestone/25?closed=1
 breaking serialization of integrator is not compatible with 3.6.0 or 3.6.1 due to bugfixes
Changes in 3.6.3
 Various bugfixes and patches https://github.com/casadi/casadi/milestone/26?closed=1
 KNITRO on linux crashes with a segmentation fault without
LD_PRELOAD=<knitro_lin_path>/libiomp5.so
.  Callbacks with one argument are broken in Matlab CasADi
CasADi v3.5.5
released September 5, 2020Grab a binary from the table (for MATLAB, use the newest compatible version below):
Windows  Linux  Mac (High Sierra or above)  

Matlab  R2016a or later, R2014b, R2014a, R2013a or R2013b 
R2014b or later, R2014a 
R2015a or later, R2014b, R2014a 
Octave  4.4.1 (32bit / 64bit), 4.4.0 (32bit / 64bit), 5.1.0 (32bit / 64bit), 5.2.0 (32bit / 64bit), 6.1.0 (32bit / 64bit) 
4.4.1, 5.1.0, 5.2.0, 6.1.0 
5.2.0, 6.1.0(Mojave or higher) 
Python  Py27 (32bit^{*} / 64bit^{*}), Py35 (32bit^{*} / 64bit^{*}), Py36 (32bit^{*} / 64bit^{*}), Py37 (32bit^{*} / 64bit^{*}), Py38 (32bit^{*} / 64bit^{*}) Py39 (32bit^{*} / 64bit^{*}) 
Py27, Py35, Py36, Py37, Py38, Py39 
Py27, Py35, Py36, Py37, Py38, Py39 
or just pip install casadi (needs pip V >=8.1) 
(^{*}) Check your Python console if you need 32bit or 64bit  bitness should be printed at startup.
Unzip in your home directory and adapt the path:
Matlab/Octave  Python 



Get started with the example pack.
CasADi Functions
 CasADi Functions can be serialized now (#308).
f.save('f.casadi') % Dump any CasADi Function to a file
f = Function.load('f.casadi') % Loads back in
This enables easy sharing of models/solver isntances beteen Matlab/Python/C++ crossplatform, and enables a form of parallelization.
 You can now evaluate CasADi Functions from C without requiring codegeneration. This makes it possible to embed CasADi computations in Fortran, Julia, FMI, …
 All CasADi Functions support timing information now (
print_time
, default true for QP and NLP solvers). Userecord_time
to make timings available throughf.stats()
without printing them. map
with reduce arguments now has an efficient implementation (no copying/repmat) Lowoverhead Callback eval support was changed to
eval_buffer
FunctionInternal::finalize
no longer takes options dict. Options
always_inline
andnever_inline
were added  Options
is_diff_in
andis_diff_out
were added  (3.5.2) CtrlC interrupts are now disabled in multithreaded Maps since they could result in crashes
 (3.5.2) Sparsity of Callbacks can be set with
has_jacobian_sparsity/get_jacobian_sparsity
 (3.5.2) Jitted functions can now be serialized
 (3.5.2) BSpline constructor takes an inline option yielding a fully differentiable (but not very scalable) BSpline operation for MX
 (3.5.5) Fixed performance deficiency in inline BSline derivatives
CasADi expressions
 breaking:
IM
type is removed from public API (was used to represent integer sparse matrices). UseDM
instead.  breaking:
linspace(0,1,3)
andlinspace(0.0,1,3)
now both return[0 0.5 1]
instead of[0 0 1]
for the former MX
supports slicing withMX
now (symbolic indexing). Issue #2364:
 breaking:
veccat
of an empty list now returns0by1
instead of0by0
. jtimes
output dimensions have changed when any of the arguments is empty. NLP function object’s ’lam_p’ is now
0by1
in case of missing parameters.
 breaking:
 (3.5.2) Fixed longstanding bug in
cosh
derivative  (3.5.2) An MX operation
convexify
was added  (3.5.2) An inefficiency in MX multiplication sparsity was detected and fixed by Mirko Hahn
Interpolation functionality
 Support for parametric (=changeable only, but not differentiable) grid and/or coefficients for linear/spline interpolation
 for
interpolant
, new constructors where added that takes dimensions instead of concrete vectors
 for
 Support for symbolic (differentiable) grid and coefficients for linear interpolation (set
inline
option to true).
Python specific
 Overheadless CasADi Function evaluation API added through Python memoryviews
 Similar functionality in Callbacks
 (3.5.2) fix numpy compatibility (numpy 1.19)
 (3.5.3) fix the numpy fix
Matlab/Octave specific
 breaking:
a(:)=b
now behaves like Matlab builtin matrices whena
is a CasADi matrix. Before, only the first column ofa
would be touched by this statement. (#2363)  breaking: Fixed bug where
MX
constructor treated a numeric row vector as column vector. Nowsize(MX(ones(1,4)))
returns(1,4)
as expected. (#2366)  Can now use spy directly on
DM
,MX
,SX
 (3.5.2) Printing from a multithreaded map context is disabled beause it could result in crashes. In linux, you may still see the output from a terminal used to start Matlab
Opti
 Opti supports conic problems now:
Opti('conic')
 One can now easily obtain a parametric solution as a CasADi Function from an Opti instance:
opti = Opti()
x = opti.variable()
y = opti.variable()
p = opti.parameter()
opti.minimize(y**2+sin(xyp)**2)
opti.subject_to(x+y>=1)
opti.solver(nlpsolver,nlpsolver_options)
F = opti.to_function("F",[x,p,opti.lam_g],[x,y])
r = F(0,0.1,0)
(3.5.1) Improved support for vertcatted inputs to to_function
 Using Opti together with
max_iter
is more natural now: usesolve_limited()
to avoid exceptions to be raised when iterations or time runs out. No need to try/catch.
Codegeneration
 breaking:
external
now looks for a.dylib
file, not.so
for mac  breaking: Codegen API has changes related to threadlocal memory:
void* mem
changed toint mem
alloc_mem
,init_mem
,free_mem
have been purged.checkout
andrelease
replace them.
int mem = checkout();
eval(arg, res, iw, w, mem);
release(mem);
 Codegen ‘CODEGEN_PREFIX’ has been renamed to ‘CASADI_CODEGEN_PREFIX’
 QP solvers (QRQP, OSQP) and SqpMethod codegenerate now. This means that embedded MPC with CasADi is now more practical.
 RungeKutta and Collocation Integrator objects can be inlined into codegeneratable MX Function with the ‘simplify’ option.
 (3.5.1) an important flaw was corrected that caused incorrect code for expression graphs with logical ‘and’ and ‘or’.
 (3.5.1) fixed regression for expression graphs containing inf/nan
 (3.5.2) fixed bug of a division looking like a comment
 (3.5.2) fixed
mem.h
regression  (3.5.2) Made
main
and mexrelated functionsc89
compliant
Solvers

breaking: NLP solvers 
bound_consistency
, an option to postprocess the primal and dual solution by projecting it on the bounds, introduced in 3.4, was changed to defaultoff

Sundials was patched to support multithreading

WORHP was bumped to v1.13

SNOPT was bumped to v7.7

SuperSCS (conic solver) was added

OSQP (QP solver) was added

CBC (LP solver) was added

(3.5.3) AMPL was fixed to allow other solvers than IPOPT

breaking: SQP Method
regularize_margin
option was addedregularize
(bool) option was removed. To get the effect ofregularize=true
, specifyconvexify_strategy='regularize'
. Other strategies include clipping eigenvalues. line search was reverted from a custom designed thing, to standard textbook L1

CPLEX and Gurobi got support for sos constraints

Conic/qpsol interface extended for semidefinite programming and SOCP
 Solvers supporting SOCP:
Gurobi
,SuperSCS
,CPLEX
 Solvers supporting SOCP:

breaking: Newton Rootfinder now supports a
line_search
option (default true) 
Rootfinder now throws an exception by default (’error_on_fail’ option true) when failing to converge

(3.5.5) Implemented constraints in IDAS and step size limits in CVODES/IDAS integrators
Convenience tools
 Debugging facilities:
 Function options
print_in
/print_in
print inputs/outputs when numerically evaluating a function  Function option
dump_in
/dump_out
dumps to the file system  Function option
dump
dumps the function itself (loadable withFunction.load
)
 Function options
DM.from_file
andDM.to_file
with aMatrixMarket
andtxt
support Helping interaction with codegen with
main=true
:Function.generate_in
/Function.nz_from_in
/Function.nz_to_in
to help creating input text files. Function.convert_in
/Function.convert_out
to switch between list and dictionary arguments/results
Binaries
 (3.5.1) Mac binaries for Matlab was switched to a different build environment. The binaries now require High Sierra or above, and work on Catalina.
 (3.5.4) Mac binaries for Python and octave have been switched just like Matlab
 (3.5.4) Linux binaries for Matlab and Octave have been switched to the manylinux environment, with gfortran dependency now grafted in (included, with a unique alias to avoid name collision)
Thirdparty solver interfaces in binaries
Versions used in binaries ( see FAQ ):
software  version  library  license env  build env 

IPOPT  3.12.3  shipped  /  / 
SNOPT  7.7  libsnopt7.so/snopt7.dll  SNOPT_LICENSE  SNOPT 
WORHP  1.13  libworhp.so/worhp.dll  WORHP_LICENSE_FILE  WORHP 
KNITRO  10.3  libknitro1030.so/knitro1032.dll  /  KNITRO 
CPLEX  windows/mac: 12.8.0, linux:12.6.3  libcplex1263.so / libcplex1280.dll  ILOG_LICENSE_FILE  CPLEX 
GUROBI  6.5.0  libgurobi65.so/gurobi65.dll  GRB_LICENSE_FILE  GUROBI_HOME 
CasADi v3.4.5
released August 7, 2018Grab a binary from the table (for MATLAB, use the newest compatible version below):
Windows  Linux  Mac  

Matlab  R2016a or later, R2014b, R2014a, R2013a or R2013b 
R2014b or later, R2014a 
R2015a or later, R2014b, R2014a 
Octave  4.4.1 (32bit / 64bit), 4.4.0 (32bit / 64bit) 
4.4.1, 4.2.2 
4.4.0 
Python  Py27 (32bit^{*} / 64bit^{*}), Py35 (32bit^{*} / 64bit^{*}), Py36 (32bit^{*} / 64bit^{*}), Py37 (32bit^{*} / 64bit^{*}) 
Py27, Py35, Py36, Py37 
Py27, Py35, Py36, Py37 
or just pip install casadi (needs pip V >=8.1) 
(^{*}) Check your Python console if you need 32bit or 64bit  bitness should be printed at startup.
Unzip in your home directory and adapt the path:
Matlab/Octave  Python 



Get started with the example pack.
Credit where credit is due: Proper attribution of linear solver routines, reimplementation of code generation for linear solvers #2158, #2134
CasADi 3.3 introduced support for two sparse direct linear solvers relying based on sparse direct QR factorization and sparse direct LDL factorization, respectively. In the release notes and in the code, it was not made clear enough that part of these routines could be considered derivative works of CSparse and LDL, respectively, both under copyright of Tim Davis. In the current release, routines derived from CSparse and LDL are clearly marked as such and to be considered derivative work under LGPL. All these routines reside inside the casadi::Sparsity
class.
Since CasADi, CSparse and LDL all have the same opensource license (LGPL), this will not introduce any additional restrictions for users.
Since C code generated from CasADi is not LGPL (allowing CasADi users to use the generated code freely), all CSparse and LDL derived routines have been removed or replaced in CasADi’s C runtime. This means that code generation for CasADi’s ‘qr’ and ’ldl’ is now possible without any additional license restrictions. A number of bugs have also been resolved.
Parametric sensitivity for NLP solvers #724
CasADi 3.4 introduces differentiability for NLP solver instances in CasADi. Derivatives can be calculated efficiently with either forward or reverse mode algorithmic differentiation. We will detail this functionality in future publications, but in the meantime, feel free to reach out to Joel if you have questions about the functionality. The implementation is based on using derivative propagation rules to the implicit function theorem, applied to the nonlinear KKT system. It is part of the NLP solver base class and should in principle work with any NLP solver, although the factorization and solution of the KKT system (based on the sparse QR above) is likely to be a speed bottle neck in applications. The derivative calculations also depend on accurate Lagrange multipliers to be available, in particular with the correct signs for all multipliers. Functions for calculating parametric sensitivities for a particular system can be C code generated.
A primaldual active set method for quadratic programming
The parametric sensitivity analysis for NLP solvers, detailed above, is only as good as the multipliers you provide to it. Multipliers from an interior point method such as IPOPT are usually not accurate enough to be used for the parametric sensitivity analysis, which in particular relies on knowledge of the active set. For this reason, we have started work on a primaldual active set method for quadratic programming. The method relies on the same factorization of the linearized KKT system as the parametric sensitivity analysis and will support C code generation. The solver is available as the “activeset” plugin in CasADi. The method is still workinprogress and in particular performs poorly if the Hessian matrix is not strictly positive definite.
Changes in Opti
describe
methods in Matlab now follows index1 based convention. Added
show_infeasibilities
to help debugging infeasible problems.  Added
opti.lbg,opti.ubg
Changes in existing functionality
 Some CasADi operations failed when the product of rows and columns of a matrix was larger then
2^311
. This limit has been raised to2^631
by changing CasADi integer types tocasadi_int
(long long
). The change is hidden for Python/Octave/Matlab users, but C++ users may be affected.  Fixed various bottlenecks in large scale MX Function initialization
 Nonzero location reports for NaN/Inf now follow index1 based convention in Matlab interface.
Added functionality
 SX Functions can be serialized/pickled/saved now.
 Added
forloop equivalents
to the users guide  New backend for parallel maps: “thread” target, shipped in the binaries.
 Uniform ‘success’ flag in
solver.stats()
fornlpsol
/conic
 Added
evalf
function to numerically evaluate an SX/MX matrix that does not depend on any symbols  Added
diff
andcumsum
(follows the Matlab convention)  Added a rootfinder plugin (‘fast_newton’) that can codegenerate
 Added binary search for Linear/BSpline Interpolant. Used by default for grid dimensions (>=100)
Binaries
 Binaries now come with a large set of plugins enabled
 Binaries ship with “thread” parallelization
 Binaries are hosted on Github instead of Sourceforge
Misc
 Default build mode is
Release
mode once again (as was always intended)  CasADi passes with
Werror
forgcc6
andgcc7
Getting error “CasADi is not running from its package context.” in Python? Check that you have casadipy27v3.4.5/casadi/casadi.py
. If you have casadipy27v3.4.5/casadi.py
instead, that’s not good; add an extra casadi
folder.
Got stuck while installing? You may also try out CasADi without installing, right in your browser (pick Python or Octave/Matlab).
CasADi v3.3.0
released November 14, 2017Grab a binary from the table (for MATLAB, use the newest compatible version below):
Windows  Linux  Mac  

Matlab  R2014b or later, R2014a, R2013a or R2013b 
R2014b or later, R2014a 
R2015a or later, R2014b, R2014a 
Octave  4.2.1 (32bit / 64bit)  4.2.1  4.2.1 
Python  Py27 (32bit^{1,2} / 64bit^{2}), Py35 (32bit^{2} / 64bit^{2}), Py36 (32bit^{2} / 64bit^{2}) 
Py27, Py35, Py36 
Py27, Py35, Py36 
^{1} Use this when you have Python(x,y). ^{2} Check your Python console if you need 32bit or 64bit  bitness should be printed at startup.
Or see the download page for more options.
Unzip in your home directory and adapt the path:
Matlab/Octave  Python 

addpath('.../casadimatlabR2014av3.3.0') import casadi.* x = MX.sym('x') disp(jacobian(sin(x),x)) 
from sys import path path.append(r".../casadipy27v3.3.0") from casadi import * x = MX.sym("x") print(jacobian(sin(x),x)) 
New: install with pip install casadi
Get started with the example pack.
New and improved features
Support for finite differences
CasADi is now able to calculate derivatives using finite differences approximations. To enable this feature, set the “enable_fd” option to true for a function object. If the function object has builtin derivative support, you can disable it by setting the options enable_forward
, enable_reverse
and enable_jacobian
to false.
The default algorithm is a central difference scheme with automatic stepsize selection based on estimates of truncation errors and roundoff errors. You can change this to a (cheaper, but less accurate) onesided scheme by setting fd_method
to forward
or backward
. There is also an experimental discontinuity avoiding scheme (suitable if the function is differentiated near nonsmooth points that can be enable by setting fd_method
to smoothing
.
New linear solvers with support for C code generation
Two sparse direct linear solvers have been added to CasADi’s runtime core: One based on an uplooking QR factorization, calculated using Householder reflections, and one sparse direct LDL method (squareroot free variant of Cholesky). These solvers are available for both SX and MX, for MX as the linear solver plugins “qr” and “ldl”, for MX as the methods “SX::qr_sparse” and “SX::ldl”. They also support for C code generation (with the exception of LDL in MX).
Faster symbolic processing of MX graphs
A speed bottleneck, related to the topological sorting of large MX graphs has been identified and resolved. The complexity of the sorting algorithms is now linear in all cases.
Other improvements
A\y
andy'/A
now work in Matlab/Octave Matrix power works
 First major release with Opti
shell
compiler now works on Windows, allowing to dojit
using Visual Studio Added introspection methods
instruction_*
that work for SX/MX Functions. Seeaccessing_mx_algorithm
example to see how you can walk an MXgraph
.  Experimental feature to export SX/MX functions to pureMatlab code.
DM::rand
creates a matrix with random numbers.DM::rng
controls the seeding of the random number generator.
Distribution/build system
 Python interface no longer searches for/links to Python libraries (on Linux, OSX)
 Python interface no longer depends on Numpy at compiletime; CasADi works for any numpy version now
 Python binaries and wheels have come a step closer to true
manylinux
. CasADi should now run on CentOS 5.
API changes
Refactored printing of function objects
The default printout of Function instances is now shorter and consistent across different Function derived classes (SX/MX functions, NLP solvers, integrators, etc.). The new syntax is:
from casadi import *
x = SX.sym('x')
y = SX.sym('x',2)
f = Function('f', [x,y],[sin(x)+y], ['x', 'y'], ['r'])
print(f) # f:(x,y[2])>(r[2]) SXFunction
f.disp() # Equivalent syntax (MATLAB style)
f.disp(True) # Print algorithm
I.e. you get a list of inputs, with dimension if nonscalar, and a name of the internal class (here SXFunction).
You can also get the name as a string: str(f)
or f.str()
. If you want to print the algorithm, pass an optional argument “True”, i.e. f.str(True)
or f.disp(True)
.
Changes to the codegen C API
The C API has seen continued improvements, in particular regarding the handling of external functions with memory allocation. See the user guide for the latest API.
Other changes
inv()
is now more efficient for largeSX
/DM
matrices, and is evaluatable forMX
(cparse
by default). The old variant is still available forSX
/MX
asinv_minor
, and forMX
asinv_node
. Linear solverrelated defaults are now set to
csparse
as opposed tosymbolicqr
 In Matlab, when the CasADi result is a
vector<bool>
, this gets mapped to a logical matrix. E.g.which_depends
is affected by this change.  The sumofsquares operator is now called
sumsqr
instead ofsum_square
.  The API of the
Linsol
class has changed.
casadipy27v3.3.0/casadi/casadi.py
. If you have casadipy27v3.3.0/casadi.py
instead, that’s not good; add an extra casadi
folder.
CasADi v3.2.3
released September 11, 2017Grab a binary from the table (for MATLAB, use the newest compatible version below):
Windows 64 bit  Linux (14.04+)  Mac  

Matlab  R2014b or later  R2014b or later  R2015a or later 
R2014a  R2014a  R2014b  
R2013a or R2013b  R2014a  
Octave  4.2.1 32bit or 64bit  4.2.1  4.2.1 
Python  Py27 (py 32bit or py 64bit )  Py27  Py27 
Py35 (py 32bit or py 64bit )  Py35  Py35  
Py36 (py 32bit or py 64bit )  Py36  Py36 
or see download page for more options/versions …
Unzip in your home directory and adapt the path:
Matlab/Octave  Python 

addpath('.../casadimatlabR2014av3.2.3') import casadi.* x = MX.sym('x') disp(jacobian(sin(x),x)) 
from sys import path path.append(r".../casadipy27np1.9.1v3.2.3") from casadi import * x = MX.sym("x") print(jacobian(sin(x),x)) 
New: install with pip install casadi
(you must have pip version
>= 8.1!)
New features
 Introduced differentiable exponential matrix node
expm
(requires slicot)  Introduced differentiable Ndimensional lookup tables:
interpolant
with ‘bspline’ solver.
Bugs in the SUNDIALS interface fixed
CasADi 3.1 included a refactored support for ODE/DAE sensitivity analysis. While more efficient, this also exposed some bugs that have now been fixed in the CasADi 3.2 release, including:
 A bug affecting second order sensitivity analysis using CVODES was fixed. Cf. #1924.
 Segfault in IDAS Cf. #1911.
API changes
 The
if_else
andconditional
operations are now nonshortcircuiting by default for both SX and MX. This means thatif_else(c,x,y)
is now equivalent toif_else(c,x,y,False)
and notif_else(c,x,y,True)
as before. Also note thatif_else(c,x,y,True)
is only supported for MX. Cf. #1968.  The functions
Function::jacobian
,Function::derivative
andFunction::hessian
, which have had an internal character since CasADi 3.0, have been deprecated and will be removed in their current forms in the next release. The user is encouraged to work with expressions (e.g.J = jacobian(f,x)
orJv = jtimes(f,x,v)
or[H,g] = hessian(f,x)
) or useFunction::factory
(*). To allow a smooth transition,Function::jacobian
andFunction::hessian
will be available asFunction::jacobian_old
andFunction::hessian_old
in this and next release. Cf. #1777.
(*) example in Matlab:
x = MX.sym('x')
y = x^2;
f = Function('f',{x},{y})
%J = f.jacobian(0,0) replacement:
J = Function('J',{x},{jacobian(y,x), y}) % alternative 1
J = f.factory('J',{'i0'},{'jac:o0:i0','o0'}) % alternative 2
%H = f.hessian(0,0) replacement:
[H,g] = hessian(y,x);
H = Function('H',{x},{H,g}) % alternative 1
H = f.factory('H',{'i0'},{'hess:o0:i0:i0','grad:o0:i0'}) % alternative 2
Improvements to C code generation
 The generated code now follows stricter coding standards. It should now be possible to compile the code with the GCC flags
Wall Werror
. Cf. #1741.
Changes to the build system
 The build system has been refactored and CasADi/C++ can be conveniently compiled with Visual Studio C++ on Windows. The installation now also includes CMake configure files, which makes it convenient to locate and use a CasADi installation in C++ code. Cf. #1982.
 The logic for source builds have changed. Before, the build system would try to locate thirdparty packages on the system and compile and install the thirdparty interfaces if this was successful. Now, the logic is that thirdparty packages are not installed unless the user specifically indicates this
e.g.
DWITH_IPOPT=ON`. Cf. #1989, #1988.  The default installation directories for the SWIG interfaces (for Python, Octave and MATLAB) has changed. It is now installed as subdirectories of the
CMAKE_INSTALL_PREFIX
location by default, but this can be changed by explicitly setting the CMake variablesBIN_PREFIX
,CMAKE_PREFIX
,INCLUDE_PREFIX
,LIB_PREFIX
,MATLAB_PREFIX
andPYTHON_PREFIX
. A flat installation directory (without subdirectories) can be obtained by setting theWITH_SELFCONTAINED
option. This is the default behavior on Windows. Cf. #1991, #1990
Changes to precompiled binaries
Python 2.6 (#1976), Python 3.6 (#1987) and Octave 4.2 (#2002, #2000) are now supported.
Get started with the example pack.
Getting error “CasADi is not running from its package context.” in Python? Check that you have casadipy27np1.9.1v3.2.3/casadi/casadi.py
. If you have casadipy27np1.9.1v3.2.3/casadi.py
instead, that’s not good; add an extra casadi
folder.
Extra links for the adventurous: more versions, nightly builds, source build instructions