BaseQPSVR.m

Go to the documentation of this file.

namespace general{
namespace regression{


/* (Autoinserted by mtoc++)
 * This source code has been filtered by the mtoc++ executable,
 * which generates code that can be processed by the doxygen documentation tool.
 *
 * On the other hand, it can neither be interpreted by MATLAB, nor can it be compiled with a C++ compiler.
 * Except for the comments, the function bodies of your M-file functions are untouched.
 * Consequently, the FILTER_SOURCE_FILES doxygen switch (default in our Doxyfile.template) will produce
 * attached source files that are highly readable by humans.
 *
 * Additionally, links in the doxygen generated documentation to the source code of functions and class members refer to
 * the correct locations in the source code browser.
 * However, the line numbers most likely do not correspond to the line numbers in the original MATLAB source files.
 */

class BaseQPSVR
  :public general.regression.BaseScalarSVR {
    public: /* ( setObservable ) */

        integer MaxIterations = 5000;
        QuadProgOpts = optimset("'Display','off','Algorithm','active-set'");
    public: /* ( setObservable ) */

        BaseQPSVR() {
            this = this@general.regression.BaseScalarSVR;

            this.registerProps(" MaxIterations "," QuadProgOpts ");
        }
        function copy = clone(copy) {
            if nargin == 1
                error(" Cannot call clone without subclass argument. ");
            end
            copy = clone@general.regression.BaseScalarSVR(this, copy);
            copy.MaxIterations= this.MaxIterations;
            copy.QuadProgOpts= this.QuadProgOpts;
        }

    
    protected: /* ( setObservable ) */

        function [p , d , info ] = solve(matrix Q,colvec c,colvec lb,colvec ub,matrix A,matrix Alb,matrix Aub,x0) {

            /*  Check for MaxIterations */
            if KerMor.App.Verbose > 0
                it = 100*(size(Q,1)+size(A,1));
                if KerMor.App.Verbose > 3 && this.MaxIterations < it
                    fprintf(" BaseQPSVR: MaxIterations of %d smaller than recommended value %d.\n ",this.MaxIterations,it);
                end
            end

            if nargin < 9
                x0 = [];
            end

            s = tic;
            /*  Call internal solver algorithm (currently: only matlab's quadprog) */
            [p,d,cflag,info] = this.internal_solve(Q,c,lb,ub,A,Alb,Aub,x0);

            /*  Adds a CompTime field */
            info.CompTime= toc(s);
            info.NumVariables= size(Q,1);
            info.NumConstraints= size(A,1);

            /*  Evaluate */
            if ~cflag
                disp(info);
                if isfield(info," message ")
                    fprintf(" Message: %s\n ",info.message);
                end
                m = MException(" BaseQPSVR:notconverged "," quadprog solver did not converge. ");
                m.throw;
            end

            /*  Verbose output */
            if KerMor.App.Verbose > 2
                fprintf(" QP-SVR finished after %d/%d Iterations and %f seconds. Info:\n ",info.Iterations,this.MaxIterations, info.CompTime);
                disp(info);
            end
        }
    private: /* ( setObservable ) */

        function [p , d , cflag , info ] = internal_solve(Q,c,lb,ub,A,lbA,ubA,x0) {

            /*  Problem setup */
            prog.H= Q;
            prog.f= c;

            /*  Bounds */
            if ~isempty(A)
                /*  Convert to equality and inequality bounds for this
                 * interface (quadprog) */
                eq = abs(lbA-ubA) < sqrt(eps);
                if any(eq)
                    prog.Aeq= A(eq,:);
                    prog.beq= lbA(eq);
                end
                if any(~eq)
                    prog.Aineq= A(~eq,:);
                    prog.bineq= ubA(~eq,:);
                end
            end
            prog.lb= lb;
            prog.ub= ub;

             /*  Set starting point if given */
            if nargin == 9
                prog.x0= x0;
            end

            /*  Further options */
            opts = this.QuadProgOpts;
            if ~isempty(this.MaxIterations)
               opts = optimset(opts," MaxIter ",this.MaxIterations);
            end
            prog.options= opts;
            prog.solver= " quadprog ";

            /*  Solve QP */
            [p, ~, exitflag, out, la] = quadprog(prog);

            /*  CARE! The -la.eqlin is subject to investigation and has to be
             * specified as soon as a suitable QP solver interface is
             * fixed/found */
            d = [la.lower + la.upper; -la.eqlin; la.ineqlin];
            cflag = exitflag == 1;
            info = out;
            info.exitflag= exitflag;
            info.Iterations= out.iterations; /* bummer! */

        }
};
}
}