optim_private_diagnose.c

ASUFIT－Matlab－全局拟合程序

                 * end
                 */
                }
                /*
                 * if hessflag
                 */
                if (mlfTobool(hessflag)) {
                    /*
                     * disp('-->Ignoring OPTIONS.Hessian --no user Hessian function provided')
                     */
                    mlfDisp(
                      mxCreateString(
                        "-->Ignoring OPTIONS.Hessian --no "
                        "user Hessian function provided"));
                /*
                 * end
                 */
                }
            /*
             * 
             * case 'fun_then_grad_then_hess'
             */
            } else if (mclSwitchCompare(
                         t_, mxCreateString("fun_then_grad_then_hess"))) {
                /*
                 * disp([' Objective:                            ',funformula]);
                 */
                mlfDisp(
                  mlfHorzcat(
                    mxCreateString(" Objective:                            "),
                    funformula,
                    NULL));
                /*
                 * if gradflag & hessflag
                 */
                if (mlfTobool(gradflag)
                    && mlfTobool(mlfAnd(gradflag, hessflag))) {
                    /*
                     * disp([' Gradient:                             ',gradformula]);
                     */
                    mlfDisp(
                      mlfHorzcat(
                        mxCreateString(
                          " Gradient:                             "),
                        gradformula,
                        NULL));
                    /*
                     * disp([' Hessian:                              ',hessformula]);
                     */
                    mlfDisp(
                      mlfHorzcat(
                        mxCreateString(
                          " Hessian:                              "),
                        hessformula,
                        NULL));
                /*
                 * elseif gradflag
                 */
                } else if (mlfTobool(gradflag)) {
                    /*
                     * disp([' Gradient:                             ',gradformula]);
                     */
                    mlfDisp(
                      mlfHorzcat(
                        mxCreateString(
                          " Gradient:                             "),
                        gradformula,
                        NULL));
                /*
                 * end   
                 */
                }
            /*
             * otherwise
             */
            } else {
            /*
             * 
             * end
             */
            }
            mxDestroyArray(t_);
        }
        /*
         * 
         * if ~gradflag
         */
        if (mlfTobool(mlfNot(gradflag))) {
            /*
             * disp(' Gradient:                             finite-differencing')
             */
            mlfDisp(
              mxCreateString(
                " Gradient:                             finite-differencing"));
        /*
         * end
         */
        }
        /*
         * % shape of grad
         * 
         * if ~hessflag & (isequal('fmincon',caller) | isequal('fminunc',caller))
         */
        {
            mxArray * a_ = mclInitialize(mlfNot(hessflag));
            if (mlfTobool(a_)) {
                mxArray * b_ = mclInitialize(
                                 mlfIsequal(
                                   mxCreateString("fmincon"), caller, NULL));
                if (mlfTobool(b_)) {
                    mlfAssign(&b_, mlfScalar(1));
                } else {
                    mlfAssign(
                      &b_,
                      mlfOr(
                        b_,
                        mlfIsequal(mxCreateString("fminunc"), caller, NULL)));
                }
                {
                    int c_0 = mlfTobool(mlfAnd(a_, b_));
                    mxDestroyArray(b_);
                    mxDestroyArray(a_);
                    if (c_0) {
                        /*
                         * disp(' Hessian:                              finite-differencing (or Quasi-Newton)')
                         */
                        mlfDisp(
                          mxCreateString(
                            " Hessian:                              f"
                            "inite-differencing (or Quasi-Newton)"));
                    }
                }
            /*
             * end
             */
            } else {
                mxDestroyArray(a_);
            }
        }
    /*
     * % shape of hess
     * 
     * end
     */
    }
    /*
     * 
     * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
     * 
     * if ~isempty(confcn{1})
     */
    if (mlfTobool(
          mlfNot(
            mlfFeval(
              mclValueVarargout(),
              mlxIsempty,
              mlfIndexRef(confcn, "{?}", mlfScalar(1.0)),
              NULL)))) {
        /*
         * switch confcn{1}
         */
        mxArray * t_ = mclUnassigned();
        mlfAssign(&t_, mlfIndexRef(confcn, "{?}", mlfScalar(1.0)));
        /*
         * 
         * case 'fun'
         */
        if (mclSwitchCompare(t_, mxCreateString("fun"))) {
            /*
             * disp([' Nonlinear constraints:                ',conformula]);
             */
            mlfDisp(
              mlfHorzcat(
                mxCreateString(" Nonlinear constraints:                "),
                conformula,
                NULL));
        /*
         * case 'fungrad'
         */
        } else if (mclSwitchCompare(t_, mxCreateString("fungrad"))) {
            /*
             * if gradconstflag
             */
            if (mlfTobool(gradconstflag)) {
                /*
                 * disp([' Nonlinear constraints and gradient:   ',conformula]);
                 */
                mlfDisp(
                  mlfHorzcat(
                    mxCreateString(" Nonlinear constraints and gradient:   "),
                    conformula,
                    NULL));
            /*
             * else
             */
            } else {
                /*
                 * disp([' Nonlinear constraints:                ',conformula]);
                 */
                mlfDisp(
                  mlfHorzcat(
                    mxCreateString(" Nonlinear constraints:                "),
                    conformula,
                    NULL));
                /*
                 * disp( '   (set OPTIONS.GradConstr to ''on'' to use user provided gradient of constraints function)') 
                 */
                mlfDisp(
                  mxCreateString(
                    "   (set OPTIONS.GradConstr to 'on' to use user"
                    " provided gradient of constraints function)"));
            /*
             * end
             */
            }
        /*
         * 
         * case 'fun_then_grad'
         */
        } else if (mclSwitchCompare(t_, mxCreateString("fun_then_grad"))) {
            /*
             * disp([' Nonlinear constraints:                ',conformula]);
             */
            mlfDisp(
              mlfHorzcat(
                mxCreateString(" Nonlinear constraints:                "),
                conformula,
                NULL));
            /*
             * if gradconstflag
             */
            if (mlfTobool(gradconstflag)) {
                /*
                 * disp([' Nonlinear constraints gradient:       ',gradcformula]);
                 */
                mlfDisp(
                  mlfHorzcat(
                    mxCreateString(" Nonlinear constraints gradient:       "),
                    gradcformula,
                    NULL));
            /*
             * end
             */
            }
        /*
         * 
         * otherwise
         */
        } else {
        /*
         * 
         * end
         */
        }
        mxDestroyArray(t_);
        /*
         * 
         * if ~constflag
         */
        if (mlfTobool(mlfNot(constflag))) {
            /*
             * disp(' Nonlinear constraints:                finite-differencing')
             */
            mlfDisp(
              mxCreateString(
                " Nonlinear constraints:                finite-differencing"));
        /*
         * end
         */
        }
        /*
         * if ~gradconstflag
         */
        if (mlfTobool(mlfNot(gradconstflag))) {
            /*
             * 
             * disp(' Gradient of nonlinear constraints:    finite-differencing')
             */
            mlfDisp(
              mxCreateString(
                " Gradient of nonlinear constraints:    finite-differencing"));
        /*
         * end
         */
        }
        /*
         * disp([sprintf('\n'),'Constraints'])  
         */
        mlfDisp(
          mlfHorzcat(
            mlfSprintf(NULL, mxCreateString("\\n"), NULL),
            mxCreateString("Constraints"),
            NULL));
        /*
         * disp([' Number of nonlinear inequality constraints: ',int2str(non_ineq)])
         */
        mlfDisp(
          mlfHorzcat(
            mxCreateString(" Number of nonlinear inequality constraints: "),
            mlfInt2str(non_ineq),
            NULL));
        /*
         * disp([' Number of nonlinear equality constraints:   ',int2str(non_eq)])
         */
        mlfDisp(
          mlfHorzcat(
            mxCreateString(" Number of nonlinear equality constraints:   "),
            mlfInt2str(non_eq),
            NULL));
    /*
     * 
     * elseif isequal(caller,'fmincon') | isequal(caller,'fminimax') | ...
     */
    } else {
        mxArray * a_ = mclInitialize(
                         mlfIsequal(caller, mxCreateString("fmincon"), NULL));
        if (mlfTobool(a_)) {
            mlfAssign(&a_, mlfScalar(1));
        } else {
            mlfAssign(
              &a_,
              mlfOr(a_, mlfIsequal(caller, mxCreateString("fminimax"), NULL)));
        }
        if (mlfTobool(a_)) {
            mlfAssign(&a_, mlfScalar(1));
        } else {
            mlfAssign(
              &a_,
              mlfOr(
                a_, mlfIsequal(caller, mxCreateString("fgoalattain"), NULL)));
        }
        if (mlfTobool(a_)
            || mlfTobool(
                 mlfOr(
                   a_, mlfIsequal(caller, mxCreateString("fseminf"), NULL)))) {
            mxDestroyArray(a_);
            /*
             * isequal(caller,'fgoalattain') | isequal(caller,'fseminf')
             * disp([sprintf('\n'),'Constraints'])
             */
            mlfDisp(
              mlfHorzcat(
                mlfSprintf(NULL, mxCreateString("\\n"), NULL),
                mxCreateString("Constraints"),
                NULL));
            /*
             * disp(' Nonlinear constraints:             do not exist')
             */
            mlfDisp(
              mxCreateString(
                " Nonlinear constraints:             do not exist"));
        } else {
            mxDestroyArray(a_);
        }
    /*
     * 
     * end
     */
    }
    /*
     * 
     * disp(' ')
     */
    mlfDisp(mxCreateString(" "));
    /*
     * 
     * 
     * switch caller
     * 
     * case {'fmincon','linprog','quadprog','lsqlin','fminimax','fseminf','fgoalattain'}
     */
    if (mclSwitchCompare(
          caller,
          mlfCellhcat(
            mxCreateString("fmincon"),
            mxCreateString("linprog"),