Complexity of explicit solutions was always an important issue. There are two levels of complexity involved in multi-parametric solutions to optimal control problems:

Runtime complexity is important while computing the solution, while the second level is vital for on-line implementation of explicit controllers in real life. Clearly, the higher the number of regions, the longer it takes to identify a proper control law, and also the more memory is needed to store all necessary regions along with associated control laws. Therefore there is a clear need of simple controllers in terms of number of regions. Although this can be achived by applying one of the low-complexity schemes MPT offers, these controllers do not guarantee optimal performance.

If the controller is required to provided optimal control action, complexity can only be reduced by post-processing. MPT² now allows to achieve this goal by simplifying the resulting controller while maintaining the same ammount of performance the original controller gives. This is achived by merging regions which have the same control law into larger chunks. Two levels of simplifications can be used:

Optimal merging gives least number of regions one could possible get, while greedy merging is based on a randomized procedure which checks which regions can be merged. Differences between these two methods are in runtime and complexity of the simplified solutions. Greedy merging is much faster, but optimal merging gives you the least number of regions one can possibly get. So the choice is up to you. Give the function a try by calling

simple_controller = mpt_simplify(ctrlStruct)

Consult help mpt_simplify for how to switch from greedy merging (which is used by default) to optimal merging.

Big progress has been achieved in improving runtime efficiency of (almost all) algorihtms provided by MPT. First, a brand new technique for computing solutions to Constrained Finite-Time Optimal Control (CFTOC) problems for Piecewise-Affine (PWA) systems is now available. This algorithm, developed by Miroslav Baric et al., is based on a Dynamic Programming approach with Piecewise-Affine cost-to-go expressions. As can be seen from the table below, this algorithm is faster by a factor of 2-20 (depends on a problem) than the original implementation of CFTOC algorithm. Secondly, all MPT code has been masively optimized for runtime speed, which gives the new version an additional edge over the old release.

Reachable sets can now be computed using mpt_reachSets. Sets can be calculated either for an autonomous system using

sets = mpt_reachSets(sysStruct, X0, N)

sets = mpt_reachSets(ctrlStruct, X0, N)

It is a known fact that different solvers tend to give slightly different solutions in some tricky cases. MPT² therefore introduces extensive error checking while solving certain linear and quadratic programs in order to avoid any problems resulting from a buggy behavior of external solvers. If a problem is detected, the given LP (QP) will be automatically solved again with a different solver in order to get a feasible solution. Our tests have shown that this rescue procedure often helps to obtain a solution in cases where the old release failed.

MPT² comes with an extended support for LP, QP, MILP and MIQP solvers. Besides the already supported solvers (CPLEX, NAG, CDD, GLPK, QSopt), we have added support for XPress, Mosek, OOQP and bintprog. Depending on the problem you are solving, fastest and most reliable solvers will be choosed automatically. If one solver fails to give a proper solution due to numerical problems, another available solver will be tried automatically as described in the numerical robustness section.