sdpsettings.m

来自「国外专家做的求解LMI鲁棒控制的工具箱,可以相对高效的解决LMI问题」· M 代码 · 共 1,007 行 · 第 1/2 页

    options.sos.extlp = 1;
    options.sos.impsparse = 0;
    options.sos.sparsetol = 1e-5;
    options.sos.inconsistent = 0;
    options.sos.clean = eps;
    options.sos.savedecomposition = 1;
    options.sos.traceobj = 0;
    options.sos.reuse = 1;
    
    options.moment.order = [];
    options.moment.solver = '';
    options.moment.refine = 0;
    options.moment.extractrank = 0;
    options.moment.rceftol = -1;
    
    options.bnb.branchrule = 'max';
    options.bnb.method = 'depthbest';
    options.bnb.verbose = 1;
    options.bnb.solver = '';
    options.bnb.uppersolver = 'rounder';
    options.bnb.presolve = 0;
    options.bnb.inttol = 1e-4;
    options.bnb.feastol = 1e-7;
    options.bnb.gaptol = 1e-4;
    
    options.bnb.round = 1;
    options.bnb.maxiter = 300;
    
    try
        options.bpmpd.opts = bpopt;    
    catch
        options.bpmpd.opts =[];
    end
    
        
    % Options for global BMI solver
    options.bmibnb.branchmethod = 'best';
    options.bmibnb.branchrule = 'omega';
    options.bmibnb.sdpcuts = 0;
    options.bmibnb.lpreduce = 1;
    options.bmibnb.lowrank  = 0;
    options.bmibnb.lowersolver = '';
    options.bmibnb.uppersolver = '';
    options.bmibnb.lpsolver = 'glpk';
    options.bmibnb.target = -inf;
    options.bmibnb.vartol = 1e-3;
    options.bmibnb.relgaptol = 1e-2;
    options.bmibnb.absgaptol = 1e-2;
    options.bmibnb.pdtol = -1e-6;
    options.bmibnb.eqtol = 1e-6;
    options.bmibnb.maxiter = 100;
    options.bmibnb.maxtime = 3600;
    options.bmibnb.roottight = 1;
    options.bmibnb.numglobal = inf;
    
    options.cutsdp.solver = '';
    options.cutsdp.maxiter = 100;
    options.cutsdp.cutlimit = inf;
    options.cutsdp.feastol = -1e-8;
    options.cutsdp.recoverdual = 0;
    options.cutsdp.variablebound = inf;
    
    options.global.branchmethod = 'best';
    options.global.branchrule = 'omega';
    options.global.lowersolver = '';
    options.global.uppersolver = '';
    options.global.lpsolver = '';    
    options.global.sdpcuts = 0;
    options.global.lpreduce = 1;
    options.global.roottight = 1;    
    options.global.lowrank  = 0;
    options.global.target = -inf;
    options.global.vartol = 1e-3;
    options.global.relgaptol = 1e-2;
    options.global.absgaptol = 1e-2;
    options.global.pdtol = -1e-6;
    options.global.eqtol = 1e-6;
    options.global.inttol = 1e-4;
    options.global.round = 1;    
    options.global.maxiter = 100;
    options.global.maxtime = 3600;
    
    % Options for approximate multi-parametric
    %     options.mpcvx.solver = '';
    %     options.mpcvx.eps = 0.25;
    
    options.cdd.method = 'criss-cross';
    
    options.clp.solver = 1;
    options.clp.maxnumiterations = 99999999;
    options.clp.maxnumseconds = 3600;
    options.clp.primaltolerance  = 1e-7;
    options.clp.dualtolerance    = 1e-7;
    options.clp.primalpivot = 1;
    options.clp.dualpivot = 1;
    
    options.cplex.presol = 1;
    options.cplex.niter = 1;
    options.cplex.epgap = 1e-4;
    options.cplex.epagap = 1e-6;
    options.cplex.relobjdif = 0.0;
    options.cplex.objdif = 0.0;
    options.cplex.tilim = 1e75;
    
    options.csdp.axtol  = 1e-8;
    options.csdp.atytol = 1e-8;
    options.csdp.objtol = 1e-8;
    options.csdp.pinftol = 1e8;
    options.csdp.dinftol = 1e8;
    options.csdp.maxiter = 100;
    options.csdp.minstepfrac = 0.90;
    options.csdp.maxstepfrac = 0.97;
    options.csdp.minstepp = 1e-8;
    options.csdp.minstepd = 1e-8;
    options.csdp.usexzgap = 1;
    options.csdp.tweakgap = 0;
    
    % Options for DSDP 5.6
    options.dsdp.r0 = -1;
    options.dsdp.zbar = 0;
    options.dsdp.penalty  = 1e8;
    options.dsdp.boundy  = 1e6;
    options.dsdp.gaptol = 1e-7;
    options.dsdp.maxit  = 500;
    options.dsdp.steptol=5e-2;      
    options.dsdp.inftol=1e-8;      
    options.dsdp.dual_bound = 1e20;
    options.dsdp.rho = 3;  
    options.dsdp.dynamicrho = 1;  
    options.dsdp.bigM = 0;  
    options.dsdp.mu0 = -1;
    options.dsdp.reuse = 4;
    options.dsdp.lp_barrier = 1;    

    % Older versions
    options.dsdp.objectiveconstant = 0;    
    options.dsdp.matrixfreesize = 3000;
    options.dsdp.scale_data = 1;    
    options.dsdp.max_trust_radius = -1;
    options.dsdp.maxtrustradius = 1e10;
    options.dsdp.max_infeasible_trust_radius = -1;
    options.dsdp.max_infeasible_mu_reduction = 2;
    options.dsdp.max_mu_reduction = 1e8;    
    options.dsdp.maxlanczos = 20;
    
    % Options for GLPK
    options.glpk.lpsolver = 1;
    options.glpk.scale = 1;
    options.glpk.dual = 0;
    options.glpk.price = 1;
    options.glpk.relax = 0.07;
    options.glpk.tolbnd = 1e-7;
    options.glpk.toldj = 1e-7;
    options.glpk.tolpiv = 1e-9;
    options.glpk.round = 0;
    options.glpk.objll = -1e12;
    options.glpk.objul = 1e12;
    options.glpk.itlim = 1e4;
    options.glpk.tmlim = -1;
    options.glpk.branch = 2;
    options.glpk.btrack = 2;
    options.glpk.tolint = 1e-6;
    options.glpk.tolobj = 1e-7;
    options.glpk.presol = 1;
    options.glpk.save = 0;
    
    %     options.specsdp.gatol1 = 5d-1;
    %     options.specsdp.gatol2 = 5d-3;
    %     options.specsdp.niter=20;
    %     options.specsdp.faiseps=1d-8;
    %     options.specsdp.compleps=1d-6;
    %     options.specsdp.stateps=1e-6;
    %     options.specsdp.penfact=2;
    %     options.specsdp.penmin=300;
    %     options.specsdp.pendiv= 5;
    %     options.specsdp.peneps=1.0d-8;
    %     options.specsdp.Vinit = 1.0;
    %     options.specsdp.radius= 1e9;
    
    options.kypd.solver = '';
    options.kypd.lyapunovsolver = 'schur';
    options.kypd.reduce = 0;
    options.kypd.transform = 0;
    options.kypd.rho = 1;
    options.kypd.tol = 1e-8;
    
    options.lmilab.reltol = 1e-3;
    options.lmilab.maxiter = 100;
    options.lmilab.feasradius = 1e9;
    options.lmilab.L = 10;
   
    options.lmirank.solver = '';
    options.lmirank.maxiter = 100;      
    options.lmirank.maxiter = 1000;
    options.lmirank.eps = 1e-9;
    options.lmirank.itermod = 1;
   
    options.lpsolve.scalemode = 0;
    
    % Options for MAXDET solver
    options.maxdet.AbsTol = 1e-6;
    options.maxdet.RelTol = 1e-6;
    options.maxdet.gam    = 25;
    options.maxdet.NTiters= 50;
    
    options.nag.featol = sqrt(eps);
    options.nag.itmax = 500;
    options.nag.bigbnd = 1e10;
    options.nag.orthog = 0;
    
    options.penbmi.DEF = 1;
    options.penbmi.PBM_MAX_ITER = 50;
    options.penbmi.UM_MAX_ITER = 100;
    options.penbmi.OUTPUT = 1;
    options.penbmi.DENSE = 0;
    options.penbmi.LS = 0;
    options.penbmi.XOUT = 0;
    options.penbmi.UOUT = 0;
    options.penbmi.NWT_SYS_MODE = 0;
    options.penbmi.PREC_TYPE = 0;
    options.penbmi.DIMACS = 0;
    options.penbmi.TR_MODE = 0;
    options.penbmi.U0 = 1;
    options.penbmi.MU = 0.7;
    options.penbmi.MU2 = 0.1;
    options.penbmi.PBM_EPS = 1e-7;
    options.penbmi.P_EPS = 1e-6;
    options.penbmi.UMIN = 1e-14;
    options.penbmi.ALPHA = 1e-2;
    options.penbmi.P0 = 0.01;
    options.penbmi.PEN_UP = 0;
    options.penbmi.ALPHA_UP = 1.0;
    options.penbmi.PRECISION_2 = 1e-7;
    options.penbmi.CG_TOL_DIR = 5e-2;
    
    options.pennlp.maxit = 100;
    options.pennlp.nwtiters = 100;
    options.pennlp.hessianmode = 0;
    options.pennlp.autoscale = 1;
    options.pennlp.convex = 0;
    options.pennlp.eqltymode = 1;
    options.pennlp.ignoreinit = 0;
    options.pennlp.ncmode = 0;
    options.pennlp.nwtstopcrit = 2;
    options.pennlp.penalty = 0;
    options.pennlp.nwtmode = 0;
    options.pennlp.prec = 0;
    options.pennlp.cmaxnzs =-1;
    options.pennlp.autoini = 1;
    options.pennlp.ipenup = 1;
    
    options.pennlp.precision = 1e-7;
    options.pennlp.uinit = 1;
    options.pennlp.pinit = 1;
    options.pennlp.alpha = 0.01;
    options.pennlp.mu = 0.5;
    options.pennlp.dpenup = 0.1;
    options.pennlp.peps = 1e-8;
    options.pennlp.umin = 1e-12;
    options.pennlp.preckkt = 1e-1;
    options.pennlp.cgtolmin = 5e-2;
    options.pennlp.cgtolup = 1;
    options.pennlp.uinitbox = 1;
    options.pennlp.uinitnc = 1;
    
      
    options.pensdp.DEF = 1;
    options.pensdp.PBM_MAX_ITER = 50;
    options.pensdp.UM_MAX_ITER = 100;
    options.pensdp.OUTPUT = 1;
    options.pensdp.DENSE = 0;
    options.pensdp.LS = 0;
    options.pensdp.XOUT = 0;
    options.pensdp.UOUT = 0;
    options.pensdp.U0 = 1;
    options.pensdp.MU = 0.7;
    options.pensdp.MU2 = 0.1;
    options.pensdp.PBM_EPS = 1e-7;
    options.pensdp.P_EPS = 1e-6;
    options.pensdp.UMIN = 1e-14;
    options.pensdp.ALPHA = 1e-2;
    options.pensdp.P0 = 0.9;
    
    % Options for SDPA
    options.sdpa.maxIteration = 40 ;
    options.sdpa.epsilonStar = 1.0E-7;
    options.sdpa.lambdaStar  = 1.0E2  ;
    options.sdpa.omegaStar  = 2.0 ;
    options.sdpa.lowerBound  = -1.0E5  ;
    options.sdpa.upperBound  = 1.0E5  ;
    options.sdpa.betaStar  = 0.1  ;
    options.sdpa.betaBar  = 0.2 ;
    options.sdpa.gammaStar  = 0.9 ;
    options.sdpa.epsilonDash  = 1.0E-7 ;
    options.sdpa.searchDir = 1 ;
    options.sdpa.isSymmetric = 0 ;
    
    options.sdplr.feastol = 1e-5;
    options.sdplr.centol = 1e-1;
    options.sdplr.dir = 1;
    options.sdplr.penfac = 2;
    options.sdplr.reduce = 1;
    options.sdplr.limit = 3600;
    options.sdplr.soln_factored = 0;
    options.sdplr.maxrank = 0;
    
    % Options for SDPT3 (2.3 -> 3.01)
    options.sdpt3.vers     = 2;
    options.sdpt3.gam      = 0;
    options.sdpt3.predcorr = 1;
    options.sdpt3.expon    = [3 1 1 1];
    options.sdpt3.gaptol   = 1e-7;
    options.sdpt3.inftol   = 1e-7;
    options.sdpt3.steptol  = 1e-6;
    options.sdpt3.maxit    = 50;
    options.sdpt3.sw2PC_tol  = inf;
    options.sdpt3.use_corrprim  = 0;
    options.sdpt3.printyes   = 1;
    options.sdpt3.scale_data = 0;
    options.sdpt3.schurfun   = [];
    options.sdpt3.schurfun_parms = [];
    options.sdpt3.randnstate = 0;
    options.sdpt3.spdensity   = 0.5;
    options.sdpt3.rmdepconstr = 0;
    options.sdpt3.CACHE_SIZE = 256;
    options.sdpt3.LOOP_LEVEL = 8;
    options.sdpt3.cachesize = 256;
    options.sdpt3.linsys_options = 'raugmatsys';
    options.sdpt3.smallblkdim = 15;
    
    % Options for SeDuMi (1.03 -> 1.05)
    options.sedumi.alg    = 2;
    options.sedumi.beta   = 0.5;
    options.sedumi.theta  = 0.25;
    options.sedumi.free   = 1;
    options.sedumi.sdp    = 0;
    options.sedumi.stepdif= 0;
    options.sedumi.w      = [1 1];
    options.sedumi.mu     = 1.0;
    options.sedumi.eps    = 1e-9;
    options.sedumi.bigeps = 1e-3;
    options.sedumi.maxiter= 150;
    options.sedumi.vplot  = 0;
    options.sedumi.stopat     = -1;
    options.sedumi.denq   = 0.75;
    options.sedumi.denf   = 10;
    options.sedumi.numtol = 5e-7;
    options.sedumi.bignumtol = 0.9;
    options.sedumi.numlvlv = 0;
    options.sedumi.chol.skip = 1;
    options.sedumi.chol.canceltol = 1e-12;
    options.sedumi.chol.maxu   = 5e5;
    options.sedumi.chol.abstol = 1e-20;
    options.sedumi.chol.maxuden= 5e2;
    options.sedumi.cg.maxiter = 25;
    options.sedumi.cg.restol  = 5e-3;
    options.sedumi.cg.refine  = 1;
    options.sedumi.cg.stagtol = 5e-14;
    options.sedumi.cg.qprec   = 0;
    options.sedumi.maxradius = inf;
    
    
    options.qsopt.dual = 0;
    options.qsopt.primalprice = 1;
    options.qsopt.dualprice = 6;
    options.qsopt.scale = 1;
    options.qsopt.maxiter = 300000;
    options.qsopt.maxtime = 10000.0;
    
    options.xpress.presol = 1;
    options.xpress.niter  = 1;
    
    try
        % Maybe we already created these above
        if exist('fminconops','var')
            options.quadprog = quadprogops;
            options.linprog  = linprogops;
            options.bintprog  = bintprogops;
            options.fmincon  = fminconops;
            options.fminsearch  = fminsearchops;
        else
            options.quadprog = optimset('quadprog');
            options.linprog  = optimset('linprog');
            options.bintprog  = optimset('linprog');
            options.fmincon  = optimset('fmincon');
            options.fminsearch  = optimset('fminsearch');
        end
    catch
        try
            % Ok, what about tomlab then?
            options.quadprog = optimset;
            options.linprog  = optimset;
            options.bintprog = optimset;
            options.fmincon  = optimset;
            options.fminsearch  = optimset;
        catch
            options.quadprog = [];
            options.linprog  = [];
            options.bintprog = [];
            options.fmincon  = [];
            options.fminsearch  = [];
        end
    end
end

i = paramstart;
% A finite state machine to parse name-value pairs.
if rem(nargin-i+1,2) ~= 0
    error('Arguments must occur in name-value pairs.');
end
expectval = 0;                          % start expecting a name, not a value
while i <= nargin
    arg = varargin{i};
    
    if ~expectval
        if ~isstr(arg)
            error(sprintf('Expected argument %d to be a string property name.', i));
        end
        
        lowArg = lower(arg);
        
        j_old = strmatch(lowArg,obsoletenames);
        if ~isempty(j_old)
            % For compability...
            
            if strcmp(lowArg,'sedumi.removeequalities')
                lowArg = 'removeequalities';
                arg = lowArg;
                
            elseif strcmp(lowArg,'silent')
                lowArg = 'verbose';
                if varargin{i+1}==1
                    varargin{i+1} = 0;
                else
                    varargin{i+1} = 1;
                end
                warning('The field ''silent'' is obsolete. Use ''verbose'' instead')
            elseif strcmp(lowArg,'sedumi.maxradius')
                lowArg = 'radius';
                arg = lowArg;
                warning('The field ''sedumi.maxradius'' is obsolete. Use ''radius'' instead')
            elseif strcmp(lowArg,'sos.solvedual')
                lowArg = 'sos.model';
                arg = lowArg;
            else
                error(sprintf('The property name ''%s'' is obsolete. Sorry...', arg));
            end
        end
        
        j = strmatch(lowArg,names);
        if isempty(j)                       % if no matches
            error(sprintf('Unrecognized property name ''%s''.', arg));
        elseif length(j) > 1                % if more than one match
            % Check for any exact matches (in case any names are subsets of others)
            k = strmatch(lowArg,names,'exact');
            if length(k) == 1
                j = k;
            else
                msg = sprintf('Ambiguous property name ''%s'' ', arg);
                msg = [msg '(' deblank(Names{j(1)})];
                for k = j(2:length(j))'
                    msg = [msg ', ' deblank(Names{k})];
                end
                msg = sprintf('%s).', msg);
                error(msg);
            end
        end
        expectval = 1;                      % we expect a value next
    else
        eval(['options.' Names{j} '= arg;']);
        expectval = 0;
    end
    i = i + 1;
end

if expectval
    error(sprintf('Expected value for property ''%s''.', arg));
end


function [Names,solvernames,solverops] = trytoset(solver,Names)

try
    solverops = optimset(solver);
    solvernames = fieldnames(solverops);

    if any(strcmp(solvernames,'LargeScale'))
        solverops.LargeScale = 'off';
    else
        solvernames{end+1} = 'LargeScale';
        solverops.LargeScale = 'off';
    end

    for i = 1:length(solvernames)
        Names = [Names;{[solver '.' solvernames{i}]}];
    end

catch
    solvernames = {'LargeScale'};
    solverops = struct('LargeScale','off');
end