/*
 * MATLAB Compiler: 2.1
 * Date: Wed May 23 19:52:28 2001
 * Arguments: "-B" "macro_default" "-O" "all" "-O" "fold_scalar_mxarrays:on"
 * "-O" "fold_non_scalar_mxarrays:on" "-O" "optimize_integer_for_loops:on" "-O"
 * "array_indexing:on" "-O" "optimize_conditionals:on" "-x" "-W" "mex" "-L" "C"
 * "-t" "-T" "link:mexlibrary" "libmatlbmx.mlib" "mpc2.m" 
 */
#include "mpc2.h"
#include "dantzgmp_mex_interface.h"
#include "libmatlbm.h"

static mxChar _array1_[126] = { 'R', 'u', 'n', '-', 't', 'i', 'm', 'e', ' ',
                                'E', 'r', 'r', 'o', 'r', ':', ' ', 'F', 'i',
                                'l', 'e', ':', ' ', 'm', 'p', 'c', '2', ' ',
                                'L', 'i', 'n', 'e', ':', ' ', '1', ' ', 'C',
                                'o', 'l', 'u', 'm', 'n', ':', ' ', '1', ' ',
                                'T', 'h', 'e', ' ', 'f', 'u', 'n', 'c', 't',
                                'i', 'o', 'n', ' ', '"', 'm', 'p', 'c', '2',
                                '"', ' ', 'w', 'a', 's', ' ', 'c', 'a', 'l',
                                'l', 'e', 'd', ' ', 'w', 'i', 't', 'h', ' ',
                                'm', 'o', 'r', 'e', ' ', 't', 'h', 'a', 'n',
                                ' ', 't', 'h', 'e', ' ', 'd', 'e', 'c', 'l',
                                'a', 'r', 'e', 'd', ' ', 'n', 'u', 'm', 'b',
                                'e', 'r', ' ', 'o', 'f', ' ', 'o', 'u', 't',
                                'p', 'u', 't', 's', ' ', '(', '3', ')', '.' };
static mxArray * _mxarray0_;

static mxChar _array3_[126] = { 'R', 'u', 'n', '-', 't', 'i', 'm', 'e', ' ',
                                'E', 'r', 'r', 'o', 'r', ':', ' ', 'F', 'i',
                                'l', 'e', ':', ' ', 'm', 'p', 'c', '2', ' ',
                                'L', 'i', 'n', 'e', ':', ' ', '1', ' ', 'C',
                                'o', 'l', 'u', 'm', 'n', ':', ' ', '1', ' ',
                                'T', 'h', 'e', ' ', 'f', 'u', 'n', 'c', 't',
                                'i', 'o', 'n', ' ', '"', 'm', 'p', 'c', '2',
                                '"', ' ', 'w', 'a', 's', ' ', 'c', 'a', 'l',
                                'l', 'e', 'd', ' ', 'w', 'i', 't', 'h', ' ',
                                'm', 'o', 'r', 'e', ' ', 't', 'h', 'a', 'n',
                                ' ', 't', 'h', 'e', ' ', 'd', 'e', 'c', 'l',
                                'a', 'r', 'e', 'd', ' ', 'n', 'u', 'm', 'b',
                                'e', 'r', ' ', 'o', 'f', ' ', 'i', 'n', 'p',
                                'u', 't', 's', ' ', '(', '2', '6', ')', '.' };
static mxArray * _mxarray2_;
static mxArray * _mxarray4_;

static mxChar _array6_[8] = { 'f', 'e', 'a', 's', 'i', 'b', 'l', 'e' };
static mxArray * _mxarray5_;
static mxArray * _mxarray7_;
static mxArray * _mxarray8_;

static mxChar _array10_[47] = { 'W', 'a', 'r', 'n', 'i', 'n', 'g', ':',
                                ' ', 'M', 'a', 'x', 'i', 'm', 'u', 'm',
                                ' ', 'n', 'u', 'm', 'b', 'e', 'r', ' ',
                                'o', 'f', ' ', 'i', 't', 'e', 'r', 'a',
                                't', 'i', 'o', 'n', 's', ' ', 'e', 'x',
                                'c', 'e', 'e', 'd', 'e', 'd', '.' };
static mxArray * _mxarray9_;

static mxChar _array12_[50] = { ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
                                'S', 'o', 'l', 'u', 't', 'i', 'o', 'n', ' ',
                                'i', 's', ' ', 'u', 'n', 'r', 'e', 'l', 'i',
                                'a', 'b', 'l', 'e', '.', ' ', 'A', 'u', 'g',
                                'm', 'e', 'n', 't', ' ', 'M', 'A', 'X', 'I',
                                'T', 'E', 'R', '.', ' ' };
static mxArray * _mxarray11_;

static mxChar _array14_[10] = { 'i', 'n', 'f', 'e', 'a',
                                's', 'i', 'b', 'l', 'e' };
static mxArray * _mxarray13_;

static mxChar _array16_[68] = { 'W', 'a', 'r', 'n', 'i', 'n', 'g', ':', ' ',
                                'T', 'h', 'e', ' ', 'c', 'o', 'n', 's', 't',
                                'r', 'a', 'i', 'n', 't', 's', ' ', 'a', 'r',
                                'e', ' ', 'o', 'v', 'e', 'r', 'l', 'y', ' ',
                                's', 't', 'r', 'i', 'n', 'g', 'e', 'n', 't',
                                '.', ' ', 'N', 'o', ' ', 'f', 'e', 'a', 's',
                                'i', 'b', 'l', 'e', ' ', 's', 'o', 'l', 'u',
                                't', 'i', 'o', 'n', '.' };
static mxArray * _mxarray15_;

static mxChar _array18_[48] = { ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
                                ' ', 'P', 'r', 'e', 'v', 'i', 'o', 'u',
                                's', ' ', 'o', 'p', 't', 'i', 'm', 'a',
                                'l', ' ', 's', 'e', 'q', 'u', 'e', 'n',
                                'c', 'e', ' ', 'w', 'i', 'l', 'l', ' ',
                                'b', 'e', ' ', 'u', 's', 'e', 'd', '.' };
static mxArray * _mxarray17_;
static double _ieee_plusinf_;
static mxArray * _mxarray19_;
static mxArray * _mxarray20_;

void InitializeModule_mpc2(void) {
    _mxarray0_ = mclInitializeString(126, _array1_);
    _mxarray2_ = mclInitializeString(126, _array3_);
    _mxarray4_ = mclInitializeDouble(0.0);
    _mxarray5_ = mclInitializeString(8, _array6_);
    _mxarray7_ = mclInitializeDouble(1.0);
    _mxarray8_ = mclInitializeDouble(100.0);
    _mxarray9_ = mclInitializeString(47, _array10_);
    _mxarray11_ = mclInitializeString(50, _array12_);
    _mxarray13_ = mclInitializeString(10, _array14_);
    _mxarray15_ = mclInitializeString(68, _array16_);
    _mxarray17_ = mclInitializeString(48, _array18_);
    _ieee_plusinf_ = mclGetInf();
    _mxarray19_ = mclInitializeDouble(_ieee_plusinf_);
    _mxarray20_ = mclInitializeDoubleVector(0, 0, (double *)NULL);
}

void TerminateModule_mpc2(void) {
    mxDestroyArray(_mxarray20_);
    mxDestroyArray(_mxarray19_);
    mxDestroyArray(_mxarray17_);
    mxDestroyArray(_mxarray15_);
    mxDestroyArray(_mxarray13_);
    mxDestroyArray(_mxarray11_);
    mxDestroyArray(_mxarray9_);
    mxDestroyArray(_mxarray8_);
    mxDestroyArray(_mxarray7_);
    mxDestroyArray(_mxarray5_);
    mxDestroyArray(_mxarray4_);
    mxDestroyArray(_mxarray2_);
    mxDestroyArray(_mxarray0_);
}

static mxArray * Mmpc2(mxArray * * epsslack,
                       mxArray * * how,
                       int nargout_,
                       mxArray * MuKduINV,
                       mxArray * KduINV,
                       mxArray * Kx,
                       mxArray * Ku1,
                       mxArray * Kut,
                       mxArray * Kr,
                       mxArray * zmin,
                       mxArray * rhsc0,
                       mxArray * Mlim,
                       mxArray * Mx,
                       mxArray * Mu1,
                       mxArray * Mvv,
                       mxArray * rhsa0,
                       mxArray * TAB,
                       mxArray * Jm,
                       mxArray * DUFree,
                       mxArray * xk,
                       mxArray * uk1,
                       mxArray * utarget,
                       mxArray * r,
                       mxArray * vKv,
                       mxArray * nu,
                       mxArray * p,
                       mxArray * degrees,
                       mxArray * optimalseq,
                       mxArray * isunconstr);

_mexLocalFunctionTable _local_function_table_mpc2
  = { 0, (mexFunctionTableEntry *)NULL };

/*
 * The function "mlfMpc2" contains the normal interface for the "mpc2"
 * M-function from file "C:\matlabR12\toolbox\mpc\Simulink\mpc2.m" (lines
 * 1-90). This function processes any input arguments and passes them to the
 * implementation version of the function, appearing above.
 */
mxArray * mlfMpc2(mxArray * * epsslack,
                  mxArray * * how,
                  mxArray * MuKduINV,
                  mxArray * KduINV,
                  mxArray * Kx,
                  mxArray * Ku1,
                  mxArray * Kut,
                  mxArray * Kr,
                  mxArray * zmin,
                  mxArray * rhsc0,
                  mxArray * Mlim,
                  mxArray * Mx,
                  mxArray * Mu1,
                  mxArray * Mvv,
                  mxArray * rhsa0,
                  mxArray * TAB,
                  mxArray * Jm,
                  mxArray * DUFree,
                  mxArray * xk,
                  mxArray * uk1,
                  mxArray * utarget,
                  mxArray * r,
                  mxArray * vKv,
                  mxArray * nu,
                  mxArray * p,
                  mxArray * degrees,
                  mxArray * optimalseq,
                  mxArray * isunconstr) {
    int nargout = 1;
    mxArray * zopt = mclGetUninitializedArray();
    mxArray * epsslack__ = mclGetUninitializedArray();
    mxArray * how__ = mclGetUninitializedArray();
    mlfEnterNewContext(
      2,
      26,
      epsslack,
      how,
      MuKduINV,
      KduINV,
      Kx,
      Ku1,
      Kut,
      Kr,
      zmin,
      rhsc0,
      Mlim,
      Mx,
      Mu1,
      Mvv,
      rhsa0,
      TAB,
      Jm,
      DUFree,
      xk,
      uk1,
      utarget,
      r,
      vKv,
      nu,
      p,
      degrees,
      optimalseq,
      isunconstr);
    if (epsslack != NULL) {
        ++nargout;
    }
    if (how != NULL) {
        ++nargout;
    }
    zopt
      = Mmpc2(
          &epsslack__,
          &how__,
          nargout,
          MuKduINV,
          KduINV,
          Kx,
          Ku1,
          Kut,
          Kr,
          zmin,
          rhsc0,
          Mlim,
          Mx,
          Mu1,
          Mvv,
          rhsa0,
          TAB,
          Jm,
          DUFree,
          xk,
          uk1,
          utarget,
          r,
          vKv,
          nu,
          p,
          degrees,
          optimalseq,
          isunconstr);
    mlfRestorePreviousContext(
      2,
      26,
      epsslack,
      how,
      MuKduINV,
      KduINV,
      Kx,
      Ku1,
      Kut,
      Kr,
      zmin,
      rhsc0,
      Mlim,
      Mx,
      Mu1,
      Mvv,
      rhsa0,
      TAB,
      Jm,
      DUFree,
      xk,
      uk1,
      utarget,
      r,
      vKv,
      nu,
      p,
      degrees,
      optimalseq,
      isunconstr);
    if (epsslack != NULL) {
        mclCopyOutputArg(epsslack, epsslack__);
    } else {
        mxDestroyArray(epsslack__);
    }
    if (how != NULL) {
        mclCopyOutputArg(how, how__);
    } else {
        mxDestroyArray(how__);
    }
    return mlfReturnValue(zopt);
}

/*
 * The function "mlxMpc2" contains the feval interface for the "mpc2"
 * M-function from file "C:\matlabR12\toolbox\mpc\Simulink\mpc2.m" (lines
 * 1-90). The feval function calls the implementation version of mpc2 through
 * this function. This function processes any input arguments and passes them
 * to the implementation version of the function, appearing above.
 */
void mlxMpc2(int nlhs, mxArray * plhs[], int nrhs, mxArray * prhs[]) {
    mxArray * mprhs[26];
    mxArray * mplhs[3];
    int i;
    if (nlhs > 3) {
        mlfError(_mxarray0_);
    }
    if (nrhs > 26) {
        mlfError(_mxarray2_);
    }
    for (i = 0; i < 3; ++i) {
        mplhs[i] = mclGetUninitializedArray();
    }
    for (i = 0; i < 26 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 26; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(
      0,
      26,
      mprhs[0],
      mprhs[1],
      mprhs[2],
      mprhs[3],
      mprhs[4],
      mprhs[5],
      mprhs[6],
      mprhs[7],
      mprhs[8],
      mprhs[9],
      mprhs[10],
      mprhs[11],
      mprhs[12],
      mprhs[13],
      mprhs[14],
      mprhs[15],
      mprhs[16],
      mprhs[17],
      mprhs[18],
      mprhs[19],
      mprhs[20],
      mprhs[21],
      mprhs[22],
      mprhs[23],
      mprhs[24],
      mprhs[25]);
    mplhs[0]
      = Mmpc2(
          &mplhs[1],
          &mplhs[2],
          nlhs,
          mprhs[0],
          mprhs[1],
          mprhs[2],
          mprhs[3],
          mprhs[4],
          mprhs[5],
          mprhs[6],
          mprhs[7],
          mprhs[8],
          mprhs[9],
          mprhs[10],
          mprhs[11],
          mprhs[12],
          mprhs[13],
          mprhs[14],
          mprhs[15],
          mprhs[16],
          mprhs[17],
          mprhs[18],
          mprhs[19],
          mprhs[20],
          mprhs[21],
          mprhs[22],
          mprhs[23],
          mprhs[24],
          mprhs[25]);
    mlfRestorePreviousContext(
      0,
      26,
      mprhs[0],
      mprhs[1],
      mprhs[2],
      mprhs[3],
      mprhs[4],
      mprhs[5],
      mprhs[6],
      mprhs[7],
      mprhs[8],
      mprhs[9],
      mprhs[10],
      mprhs[11],
      mprhs[12],
      mprhs[13],
      mprhs[14],
      mprhs[15],
      mprhs[16],
      mprhs[17],
      mprhs[18],
      mprhs[19],
      mprhs[20],
      mprhs[21],
      mprhs[22],
      mprhs[23],
      mprhs[24],
      mprhs[25]);
    plhs[0] = mplhs[0];
    for (i = 1; i < 3 && i < nlhs; ++i) {
        plhs[i] = mplhs[i];
    }
    for (; i < 3; ++i) {
        mxDestroyArray(mplhs[i]);
    }
}

/*
 * The function "Mmpc2" is the implementation version of the "mpc2" M-function
 * from file "C:\matlabR12\toolbox\mpc\Simulink\mpc2.m" (lines 1-90). It
 * contains the actual compiled code for that M-function. It is a static
 * function and must only be called from one of the interface functions,
 * appearing below.
 */
/*
 * function [zopt,epsslack,how]=mpconline(MuKduINV,KduINV,Kx,Ku1,Kut,Kr,zmin,rhsc0,Mlim,Mx,Mu1,Mvv,...%Mdd
 */
static mxArray * Mmpc2(mxArray * * epsslack,
                       mxArray * * how,
                       int nargout_,
                       mxArray * MuKduINV,
                       mxArray * KduINV,
                       mxArray * Kx,
                       mxArray * Ku1,
                       mxArray * Kut,
                       mxArray * Kr,
                       mxArray * zmin,
                       mxArray * rhsc0,
                       mxArray * Mlim,
                       mxArray * Mx,
                       mxArray * Mu1,
                       mxArray * Mvv,
                       mxArray * rhsa0,
                       mxArray * TAB,
                       mxArray * Jm,
                       mxArray * DUFree,
                       mxArray * xk,
                       mxArray * uk1,
                       mxArray * utarget,
                       mxArray * r,
                       mxArray * vKv,
                       mxArray * nu,
                       mxArray * p,
                       mxArray * degrees,
                       mxArray * optimalseq,
                       mxArray * isunconstr) {
    mexLocalFunctionTable save_local_function_table_ = mclSetCurrentLocalFunctionTable(
                                                         &_local_function_table_mpc2);
    mxArray * zopt = mclGetUninitializedArray();
    mxArray * j = mclGetUninitializedArray();
    mxArray * free = mclGetUninitializedArray();
    mxArray * duold = mclGetUninitializedArray();
    mxArray * ans = mclGetUninitializedArray();
    mxArray * iter = mclGetUninitializedArray();
    mxArray * il = mclGetUninitializedArray();
    mxArray * ib = mclGetUninitializedArray();
    mxArray * basis = mclGetUninitializedArray();
    mxArray * maxiter = mclGetUninitializedArray();
    mxArray * ili = mclGetUninitializedArray();
    mxArray * ibi = mclGetUninitializedArray();
    mxArray * nc = mclGetUninitializedArray();
    mxArray * basisi = mclGetUninitializedArray();
    mxArray * rhsa = mclGetUninitializedArray();
    mxArray * rhsc = mclGetUninitializedArray();
    mclCopyArray(&MuKduINV);
    mclCopyArray(&KduINV);
    mclCopyArray(&Kx);
    mclCopyArray(&Ku1);
    mclCopyArray(&Kut);
    mclCopyArray(&Kr);
    mclCopyArray(&zmin);
    mclCopyArray(&rhsc0);
    mclCopyArray(&Mlim);
    mclCopyArray(&Mx);
    mclCopyArray(&Mu1);
    mclCopyArray(&Mvv);
    mclCopyArray(&rhsa0);
    mclCopyArray(&TAB);
    mclCopyArray(&Jm);
    mclCopyArray(&DUFree);
    mclCopyArray(&xk);
    mclCopyArray(&uk1);
    mclCopyArray(&utarget);
    mclCopyArray(&r);
    mclCopyArray(&vKv);
    mclCopyArray(&nu);
    mclCopyArray(&p);
    mclCopyArray(&degrees);
    mclCopyArray(&optimalseq);
    mclCopyArray(&isunconstr);
    /*
     * rhsa0,TAB,Jm,DUFree,xk,uk1,utarget,r,vKv,...%dKd,
     * nu,p,degrees,optimalseq,isunconstr);
     * 
     * % Compute the optimal input sequence by solving a QP problem or analytically
     * 
     * %   Copyright (c) 1998 by Alberto Bemporad, August 24, 1998
     * %   $Revision: 1.00 $  $Date: 1998/08/24 $
     * %   $Revision: 1.10 $  $Date: 2001/03/09 $   Added MAXITER
     * 
     * if isunconstr,
     */
    if (mlfTobool(mclVa(isunconstr, "isunconstr"))) {
        /*
         * 
         * % Unconstrained MPC
         * 
         * zopt=-KduINV*(Kx'*xk+Ku1'*uk1+Kut'*utarget+...
         */
        mlfAssign(
          &zopt,
          mclMtimes(
            mclUminus(mclVa(KduINV, "KduINV")),
            mclPlus(
              mclPlus(
                mclPlus(
                  mclPlus(
                    mclMtimes(mlfCtranspose(mclVa(Kx, "Kx")), mclVa(xk, "xk")),
                    mclMtimes(
                      mlfCtranspose(mclVa(Ku1, "Ku1")), mclVa(uk1, "uk1"))),
                  mclMtimes(
                    mlfCtranspose(mclVa(Kut, "Kut")),
                    mclVa(utarget, "utarget"))),
                mclMtimes(mlfCtranspose(mclVa(Kr, "Kr")), mclVa(r, "r"))),
              mlfCtranspose(mclVa(vKv, "vKv")))));
        /*
         * Kr'*r+vKv');%+dKd');
         * 
         * epsslack=0;
         */
        mlfAssign(epsslack, _mxarray4_);
        /*
         * 
         * how='feasible';
         */
        mlfAssign(how, _mxarray5_);
        /*
         * return
         */
        goto return_;
    /*
     * end
     */
    }
    /*
     * 
     * % Constrained MPC
     * 
     * % Form matrices for DANTZGMP routine (tableau)
     * rhsc=rhsc0+Mlim+Mx*xk+Mu1*uk1+Mvv;%+Mdd;
     */
    mlfAssign(
      &rhsc,
      mclPlus(
        mclPlus(
          mclPlus(
            mclPlus(mclVa(rhsc0, "rhsc0"), mclVa(Mlim, "Mlim")),
            mclMtimes(mclVa(Mx, "Mx"), mclVa(xk, "xk"))),
          mclMtimes(mclVa(Mu1, "Mu1"), mclVa(uk1, "uk1"))),
        mclVa(Mvv, "Mvv")));
    /*
     * rhsa=rhsa0-[(xk'*Kx+r'*Kr+uk1'*Ku1+vKv+...%dkd+...
     */
    mlfAssign(
      &rhsa,
      mclMinus(
        mclVa(rhsa0, "rhsa0"),
        mlfCtranspose(
          mlfHorzcat(
            mclPlus(
              mclPlus(
                mclPlus(
                  mclPlus(
                    mclMtimes(mlfCtranspose(mclVa(xk, "xk")), mclVa(Kx, "Kx")),
                    mclMtimes(mlfCtranspose(mclVa(r, "r")), mclVa(Kr, "Kr"))),
                  mclMtimes(
                    mlfCtranspose(mclVa(uk1, "uk1")), mclVa(Ku1, "Ku1"))),
                mclVa(vKv, "vKv")),
              mclMtimes(
                mlfCtranspose(mclVa(utarget, "utarget")), mclVa(Kut, "Kut"))),
            _mxarray4_,
            NULL))));
    /*
     * utarget'*Kut),0]';
     * 
     * basisi=[KduINV*rhsa;
     */
    mlfAssign(
      &basisi,
      mlfVertcat(
        mclMtimes(mclVa(KduINV, "KduINV"), mclVv(rhsa, "rhsa")),
        mclMinus(
          mclVv(rhsc, "rhsc"),
          mclMtimes(mclVa(MuKduINV, "MuKduINV"), mclVv(rhsa, "rhsa"))),
        NULL));
    /*
     * rhsc-MuKduINV*rhsa];
     * 
     * nc=size(rhsc,1);
     */
    mlfAssign(
      &nc, mlfSize(mclValueVarargout(), mclVv(rhsc, "rhsc"), _mxarray7_));
    /*
     * 
     * ibi=-[1:degrees+1+nc]';
     */
    mlfAssign(
      &ibi,
      mclUminus(
        mlfCtranspose(
          mlfColon(
            _mxarray7_,
            mclPlus(
              mclPlus(mclVa(degrees, "degrees"), _mxarray7_), mclVv(nc, "nc")),
            NULL))));
    /*
     * ili=-ibi;
     */
    mlfAssign(&ili, mclUminus(mclVv(ibi, "ibi")));
    /*
     * maxiter=100; % Max number of iterations allowed
     */
    mlfAssign(&maxiter, _mxarray8_);
    /*
     * 
     * % Solves QP
     * [basis,ib,il,iter]=dantzgmp(TAB,basisi,ibi,ili,maxiter);
     */
    mlfNDantzgmp(
      0,
      mlfVarargout(&basis, &ib, &il, &iter, NULL),
      mclVa(TAB, "TAB"),
      mclVv(basisi, "basisi"),
      mclVv(ibi, "ibi"),
      mclVv(ili, "ili"),
      mclVv(maxiter, "maxiter"),
      NULL);
    /*
     * 
     * %% QP.M solution. Find matrices for QP problem
     * %%
     * %H=inv(KduINV);
     * %f=xk'*Kx+r'*Kr+uk1'*Ku1+vKv+...%dkd+...
     * %   utarget'*Kut;
     * %
     * % .... (to be continued) ....
     * 
     * % TEST: compute max number of iterations
     * %global ITER
     * %ITER=max(ITER,iter);
     * 
     * if iter > maxiter,
     */
    if (mclGtBool(mclVv(iter, "iter"), mclVv(maxiter, "maxiter"))) {
        /*
         * disp('Warning: Maximum number of iterations exceeded.')
         */
        mlfDisp(_mxarray9_);
        /*
         * disp('         Solution is unreliable. Augment MAXITER. ');
         */
        mlfDisp(_mxarray11_);
    /*
     * 
     * elseif iter < 0
     */
    } else if (mclLtBool(mclVv(iter, "iter"), _mxarray4_)) {
        /*
         * % This should never happen, because there's a slack variable !!!
         * % It's just for robustness of the code...
         * 
         * how='infeasible';
         */
        mlfAssign(how, _mxarray13_);
        /*
         * disp('Warning: The constraints are overly stringent. No feasible solution.')
         */
        mlfDisp(_mxarray15_);
        /*
         * disp('         Previous optimal sequence will be used.');
         */
        mlfDisp(_mxarray17_);
        /*
         * duold=Jm*optimalseq;
         */
        mlfAssign(
          &duold, mclMtimes(mclVa(Jm, "Jm"), mclVa(optimalseq, "optimalseq")));
        /*
         * zopt=[duold(1+nu:nu*p);zeros(nu,1)]; % shifts
         */
        mlfAssign(
          &zopt,
          mlfVertcat(
            mclVe(
              mclArrayRef1(
                mclVsv(duold, "duold"),
                mlfColon(
                  mclPlus(_mxarray7_, mclVa(nu, "nu")),
                  mclMtimes(mclVa(nu, "nu"), mclVa(p, "p")),
                  NULL))),
            mclVe(mlfZeros(mclVa(nu, "nu"), _mxarray7_, NULL)),
            NULL));
        /*
         * 
         * % Rebuilds optimalseq from zopt
         * %free=find(kron(DUFree(:),ones(nu,1))); % Indices of free moves
         * free=find(DUFree(:));
         */
        mlfAssign(
          &free,
          mlfFind(
            NULL,
            NULL,
            mclVe(
              mclArrayRef1(mclVsa(DUFree, "DUFree"), mlfCreateColonIndex()))));
        /*
         * epsslack=Inf; % Slack variable for soft output constraints
         */
        mlfAssign(epsslack, _mxarray19_);
        /*
         * zopt=zopt(free);
         */
        mlfAssign(
          &zopt, mclArrayRef1(mclVsv(zopt, "zopt"), mclVsv(free, "free")));
        /*
         * return
         */
        goto return_;
    /*
     * end    
     */
    }
    /*
     * 
     * % Extract the solution to the QP problem
     * how='feasible';
     */
    mlfAssign(how, _mxarray5_);
    /*
     * zopt=zeros(degrees+1,1);
     */
    mlfAssign(
      &zopt,
      mlfZeros(
        mclPlus(mclVa(degrees, "degrees"), _mxarray7_), _mxarray7_, NULL));
    /*
     * for j=1:degrees+1
     */
    {
        int v_ = mclForIntStart(1);
        int e_ = mclForIntEnd(mclPlus(mclVa(degrees, "degrees"), _mxarray7_));
        if (v_ > e_) {
            mlfAssign(&j, _mxarray20_);
        } else {
            /*
             * if il(j) <= 0
             * zopt(j)=zmin(j);
             * else
             * zopt(j)=basis(il(j))+zmin(j);
             * end
             * end
             */
            for (; ; ) {
                if (mclLeBool(
                      mclVe(mclIntArrayRef1(mclVsv(il, "il"), v_)),
                      _mxarray4_)) {
                    mclIntArrayAssign1(
                      &zopt, mclIntArrayRef1(mclVsa(zmin, "zmin"), v_), v_);
                } else {
                    mclIntArrayAssign1(
                      &zopt,
                      mclPlus(
                        mclVe(
                          mclArrayRef1(
                            mclVsv(basis, "basis"),
                            mclIntArrayRef1(mclVsv(il, "il"), v_))),
                        mclVe(mclIntArrayRef1(mclVsa(zmin, "zmin"), v_))),
                      v_);
                }
                if (v_ == e_) {
                    break;
                }
                ++v_;
            }
            mlfAssign(&j, mlfScalar(v_));
        }
    }
    /*
     * epsslack=zopt(degrees+1); % Slack variable for soft output constraints
     */
    mlfAssign(
      epsslack,
      mclArrayRef1(
        mclVsv(zopt, "zopt"), mclPlus(mclVa(degrees, "degrees"), _mxarray7_)));
    /*
     * zopt=zopt(1:degrees);
     */
    mlfAssign(
      &zopt,
      mclArrayRef1(
        mclVsv(zopt, "zopt"),
        mlfColon(_mxarray7_, mclVa(degrees, "degrees"), NULL)));
    /*
     * 
     * % end MPC2.M
     */
    return_:
    mclValidateOutput(zopt, 1, nargout_, "zopt", "mpc2");
    mclValidateOutput(*epsslack, 2, nargout_, "epsslack", "mpc2");
    mclValidateOutput(*how, 3, nargout_, "how", "mpc2");
    mxDestroyArray(rhsc);
    mxDestroyArray(rhsa);
    mxDestroyArray(basisi);
    mxDestroyArray(nc);
    mxDestroyArray(ibi);
    mxDestroyArray(ili);
    mxDestroyArray(maxiter);
    mxDestroyArray(basis);
    mxDestroyArray(ib);
    mxDestroyArray(il);
    mxDestroyArray(iter);
    mxDestroyArray(ans);
    mxDestroyArray(duold);
    mxDestroyArray(free);
    mxDestroyArray(j);
    mxDestroyArray(isunconstr);
    mxDestroyArray(optimalseq);
    mxDestroyArray(degrees);
    mxDestroyArray(p);
    mxDestroyArray(nu);
    mxDestroyArray(vKv);
    mxDestroyArray(r);
    mxDestroyArray(utarget);
    mxDestroyArray(uk1);
    mxDestroyArray(xk);
    mxDestroyArray(DUFree);
    mxDestroyArray(Jm);
    mxDestroyArray(TAB);
    mxDestroyArray(rhsa0);
    mxDestroyArray(Mvv);
    mxDestroyArray(Mu1);
    mxDestroyArray(Mx);
    mxDestroyArray(Mlim);
    mxDestroyArray(rhsc0);
    mxDestroyArray(zmin);
    mxDestroyArray(Kr);
    mxDestroyArray(Kut);
    mxDestroyArray(Ku1);
    mxDestroyArray(Kx);
    mxDestroyArray(KduINV);
    mxDestroyArray(MuKduINV);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    return zopt;
}