source: proiecte/pmake3d/make3d_original/Make3dSingleImageStanford_version0.1/third_party/opt/yalmip/extras/sdpsettings.m @ 37

Last change on this file since 37 was 37, checked in by (none), 14 years ago

Added original make3d
File size: 29.0 KB
Line 
1function options = sdpsettings(varargin)
2%SDPSETTINGS Create/alter solver options structure.
3%
4%   OPTIONS = SDPSETTINGS with no input arguments returns
5%   setting structure with default values
6%c
7%   OPTIONS = SDPSETTINGS('NAME1',VALUE1,'NAME2',VALUE2,...) creates a
8%   solution options structure OPTIONS in which the named properties have
9%   the specified values.  Any unspecified properties have default values.
10%   It is sufficient to type only the leading characters that uniquely
11%   identify the property.  Case is ignored for property names.
12%
13%   OPTIONS = SDPSETTINGS(OLDOPTS,'NAME1',VALUE1,...) alters an existing options
14%   structure OLDOPTS.
15%
16%
17%   SDPSETTINGS PROPERTIES
18%
19%   GENERAL
20%
21%    solver             - Specify solver [''|sdpt3|sedumi|sdpa|pensdp|penbmi|csdp|dsdp|maxdet|lmilab|cdd|cplex|xpress|mosek|nag|quadprog|linprog|bnb|bmibnb|kypd|mpt|none ('')]
22%    verbose            - Display-level [0|1|2|...(0)] (0-silent, 1-normal, >1-loud)
23%    usex0              - Use the current values obtained from double as initial iterate [0|1 (0)]
24%    dimacs             - Compute DIMACS error measures [0|1(1)]
25%
26%    showprogress       - Show progress of YALMIP (suitable for large problems) [0|1 (0)]
27%    cachesolvers       - Check for available solvers only first time solvesdp is called [0|1 (0)]
28%    warning            - Shows a warning if a problems occurs when solving a problem (infeasibility, numerical problem etc.) [0|1 (1)]
29%    beeponproblem      - Beeps when certain warning/error occurs [ integers -2|-1|1|2|3|4|5|6|7|8|9|10|11]
30%    saveduals          - Dual variables are saved in YALMIP [0|1 (1)]
31%    savesolverinput    - Keep all data sent to solver [0|1 (0)]
32%    savesolveroutput   - Keep all data returned from solver [0|1 (0)]
33%    removeequalities   - Let YALMIP remove equality constraints [-1|0|1 (0)] (-1:with double inequalities, 0:don't, 1:by QR decomposition, 2:basis from constraints)
34%    convertconvexquad  - Convert convex quadratic constraints to second order cones [0|1 (1)]
35%    radius             - Add radius constraint on all pimal variables ||x||<radius [double >=0 (inf)]
36%    shift              - Add small perturbation to (try to) enforce strict feasibility [double >=0 (0)]
37%    relax              - Disregard integrality constraint and/or relax nonlinear terms  [0 | 1 (both) 2 (relax integrality) 3 (relax nonlinear terms) (0)]
38%    allowmilp          - Allow introduction of binary variables to model nonlinear operators [0 | 1 (0)]
39%    expand             - Expand nonlinear operators [0|1 (1)]. Should always be true except in rare debugging cases.
40%
41%   SUM-OF-SQUARES
42%
43%    options.sos, see help solvesos
44%
45%   BRANCH AND BOUND for mixed integer programs
46%
47%    options.bnb, see help bnb
48%
49%   BRANCH AND BOUND for polynomial programs
50%
51%    options.bmibnb, see help bmibnb
52%
53%   EXTERNAL SOLVERS
54%
55%    See solver manuals.
56%
57%   See also SOLVESDP, SET, SDPVAR
58
59% Author Johan Löfberg (ripped from odeset)
60% $Id: sdpsettings.m,v 1.46 2006/09/26 08:15:56 joloef Exp $
61
62% Print out possible values of properties.
63if (nargin == 0) & (nargout == 0)
64    help sdpsettings
65    return;
66end
67
68Names = {'solver'
69    'verbose'
70    'showprogress'
71    'cachesolvers'
72    'savesolveroutput'
73    'savesolverinput'
74    'saveduals'
75    'removeequalities'
76    'convertconvexquad'
77    'beeponproblem'
78    'warning'
79    'dimacs'
80    'radius'
81    'shift'
82    'reduce'
83    'dualize'
84    'relax'
85    'usex0'
86    'expand'
87    'allowmilp'
88    'allownonconvex'
89    'savedebug'
90    'debug'
91    'bnb.branchrule'
92    'bnb.method'
93    'bnb.verbose'
94    'bnb.solver'
95    'bnb.uppersolver'
96    'bnb.presolve'
97    'bnb.inttol'
98    'bnb.feastol'
99    'bnb.gaptol'
100    'bnb.maxiter'
101    'bnb.round'
102    'bnb.weight'
103    'bnb.nodefix'
104    'bnb.nodetight'
105    'bnb.prunetol'
106    'bnb.multiple'
107    'bmilin.trust'
108    'bmilin.alpha'
109    'bmilin.beta'
110    'bmilin.solver'
111    'bmilin.maxiterls'
112    'bmilin.maxiter'
113    'bmibnb.branchmethod'
114    'bmibnb.branchrule'
115    'bmibnb.lpreduce'
116    'bmibnb.lowrank'
117    'bmibnb.lowersolver'
118    'bmibnb.uppersolver'
119    'bmibnb.lpsolver'
120    'bmibnb.target'
121    'bmibnb.vartol'
122    'bmibnb.relgaptol'
123    'bmibnb.absgaptol'
124    'bmibnb.pdtol'
125    'bmibnb.eqtol'
126    'bmibnb.maxiter'
127    'bmibnb.maxtime'
128    'bmibnb.roottight'
129    'bmibnb.numglobal'
130    'cutsdp.solver'
131    'cutsdp.maxiter'
132    'cutsdp.cutlimit'
133    'cutsdp.feastol'
134    'cutsdp.variablebound'
135    'cutsdp.recoverdual'
136    'cutsdp.nodefix'
137    'cutsdp.nodetight'
138    'mp.algorithm'
139    'mp.unbounded'
140    'mp.simplify'
141    'mp.presolve'
142    'global.branchmethod'
143    'global.branchrule'
144    'global.lpreduce'
145    'global.roottight'
146    'global.lowrank'
147    'global.lowersolver'
148    'global.uppersolver'
149    'global.lpsolver'
150    'global.target'
151    'global.vartol'
152    'global.relgaptol'
153    'global.absgaptol'
154    'global.pdtol'
155    'global.eqtol'
156    'global.inttol'
157    'global.maxiter'
158    'global.maxtime'
159    'mpcvx.solver'
160    'mpcvx.eps'
161    'bpmpd.opts'
162    'sp.AbsTol'
163    'sp.RelTol'
164    'sp.nu'
165    'sp.tv'
166    'sp.Mfactor'
167    'sp.NTiters'
168    'maxdet.AbsTol'
169    'maxdet.RelTol'
170    'maxdet.gam'
171    'socp.AbsTol'
172    'socp.RelTol'
173    'socp.target'
174    'socp.max_iter'
175    'socp.nu'
176    'socp.outmode'
177    'sdpt3.vers'
178    'sdpt3.gam'
179    'sdpt3.predcorr'
180    'sdpt3.expon'
181    'sdpt3.gaptol'
182    'sdpt3.inftol'
183    'sdpt3.steptol'
184    'sdpt3.maxit'
185    'sdpt3.stoplevel'
186    'sdpt3.sw2PC_tol'
187    'sdpt3.use_corrprim'
188    'sdpt3.printyes'
189    'sdpt3.scale_data'
190    'sdpt3.schurfun'
191    'sdpt3.schurfun_parms'
192    'sdpt3.randnstate'
193    'sdpt3.spdensity'
194    'sdpt3.rmdepconstr'
195    'sdpt3.CACHE_SIZE'
196    'sdpt3.LOOP_LEVEL'
197    'sdpt3.cachesize'
198    'sdpt3.linsys_options'
199    'sdpt3.smallblkdim'
200    'sedumi.removeequalities'
201    'sedumi.alg'
202    'sedumi.beta'
203    'sedumi.theta'
204    'sedumi.free'
205    'sedumi.sdp'
206    'sedumi.stepdif'
207    'sedumi.w'
208    'sedumi.mu'
209    'sedumi.eps'
210    'sedumi.bigeps'
211    'sedumi.maxiter'
212    'sedumi.vplot'
213    'sedumi.stopat'
214    'sedumi.denq'
215    'sedumi.denf'
216    'sedumi.numtol'
217    'sedumi.bignumtol'
218    'sedumi.numlvl'
219    'sedumi.chol.skip'
220    'sedumi.chol.abstol'
221    'sedumi.chol.canceltol'
222    'sedumi.chol.maxu'
223    'sedumi.chol.maxuden'
224    'sedumi.chol.numlvl'
225    'sedumi.chol.deptol'
226    'sedumi.chol.ph1tol'
227    'sedumi.cg.qprec'
228    'sedumi.cg.restol'
229    'sedumi.cg.stagtol'
230    'sedumi.cg.maxiter'
231    'sedumi.cg.refine'     
232    'dsdp.r0' 
233    'dsdp.zbar'
234    'dsdp.penalty'
235    'dsdp.boundy'
236    'dsdp.gaptol'
237    'dsdp.maxit'
238    'dsdp.steptol'
239    'dsdp.inftol'
240    'dsdp.dual_bound'
241    'dsdp.dobjmin'
242    'dsdp.rho'
243    'dsdp.dynamicrho'
244    'dsdp.cc'   
245    'dsdp.bigM'   
246    'dsdp.mu0'
247    'dsdp.reuse'
248    'dsdp.lp_barrier'     
249    'dsdp.objectiveconstant'   
250    'dsdp.matrixfreesize'
251    'dsdp.scale_data'   
252    'dsdp.maxlanczos'
253    'dsdp.max_trust_radius'
254    'dsdp.maxtrustradius'
255    'dsdp.max_mu_reduction'
256    'dsdp.max_infeasible_trust_radius'
257    'dsdp.max_infeasible_mu_reduction'   
258    'sdplr.feastol'
259    'sdplr.centol'
260    'sdplr.dir'
261    'sdplr.penfac'
262    'sdplr.reduce'
263    'sdplr.limit'
264    'sdplr.maxrank'
265    'sdplr.soln_factored'
266    'sdpa.maxIteration'
267    'sdpa.epsilonStar'
268    'sdpa.lambdaStar'
269    'sdpa.omegaStar'
270    'sdpa.lowerBound'
271    'sdpa.upperBound'
272    'sdpa.betaStar'
273    'sdpa.betaBar'
274    'sdpa.gammaStar'
275    'sdpa.epsilonDash'
276    'sdpa.searchDir'
277    'sdpa.isSymmetric'
278    'glpk.lpsolver'
279    'glpk.scale'
280    'glpk.dual'
281    'glpk.price'
282    'glpk.relax'
283    'glpk.tolbnd'
284    'glpk.toldj'
285    'glpk.tolpiv'
286    'glpk.round'
287    'glpk.objll'
288    'glpk.objul'
289    'glpk.itlim'
290    'glpk.tmlim'
291    'glpk.branch'
292    'glpk.btrack'
293    'glpk.tolint'
294    'glpk.tolobj'
295    'glpk.presol'
296    'glpk.save'
297    'cplex.presol'
298    'cplex.niter'
299    'cplex.epgap'
300    'cplex.epagap'
301    'cplex.relobjdif'
302    'cplex.objdif'
303    'cplex.tilim'
304    'cplex.logfile'
305    'cplex.param.double'
306    'cplex.param.int'
307    'qsopt.dual'
308    'qsopt.primalprice'
309    'qsopt.dualprice'
310    'qsopt.scale'
311    'qsopt.maxiter'
312    'qsopt.maxtime'
313    'xpress.presol'
314    'xpress.niter'
315    'lpsolve.scalemode'
316    'cdd.method'
317    'clp.solver'
318    'clp.maxnumiterations'
319    'clp.maxnumseconds'
320    'clp.primaltolerance'
321    'clp.dualtolerance'
322    'clp.primalpivot'
323    'clp.dualpivot'
324    'pensdp.DEF'
325    'pensdp.PBM_MAX_ITER'
326    'pensdp.UM_MAX_ITER'
327    'pensdp.OUTPUT'
328    'pensdp.DENSE'
329    'pensdp.LS'
330    'pensdp.XOUT'
331    'pensdp.UOUT'   
332    'pensdp.U0'
333    'pensdp.MU'
334    'pensdp.MU2'
335    'pensdp.PBM_EPS'
336    'pensdp.P_EPS'
337    'pensdp.UMIN'
338    'pensdp.ALPHA'
339    'pensdp.P0'
340    'penbmi.DEF'
341    'penbmi.PBM_MAX_ITER'
342    'penbmi.UM_MAX_ITER'
343    'penbmi.OUTPUT'
344    'penbmi.DENSE'
345    'penbmi.LS'
346    'penbmi.XOUT'
347    'penbmi.UOUT'
348    'penbmi.NWT_SYS_MODE'
349    'penbmi.PREC_TYPE'
350    'penbmi.DIMACS'
351    'penbmi.TR_MODE'
352    'penbmi.U0'
353    'penbmi.MU'
354    'penbmi.MU2'
355    'penbmi.PBM_EPS'
356    'penbmi.P_EPS'
357    'penbmi.UMIN'
358    'penbmi.ALPHA'
359    'penbmi.P0'   
360    'penbmi.PEN_UP'
361    'penbmi.ALPHA_UP' 
362    'penbmi.PRECISION'
363    'penbmi.PRECISION_2' 
364    'penbmi.CG_TOL_DIR' 
365   
366    'pennlp.maxit'
367    'pennlp.nwtiters'
368    'pennlp.hessianmode'
369    'pennlp.autoscale'
370    'pennlp.convex'
371    'pennlp.eqltymode'
372    'pennlp.ignoreinit'
373    'pennlp.ncmode'
374    'pennlp.nwtstopcrit'
375    'pennlp.penalty'
376    'pennlp.nwtmode'
377    'pennlp.prec'
378    'pennlp.cmaxnzs'
379    'pennlp.autoini'
380    'pennlp.ipenup'   
381    'pennlp.precision'
382    'pennlp.uinit'
383    'pennlp.pinit'
384    'pennlp.alpha'
385    'pennlp.mu'
386    'pennlp.dpenup'
387    'pennlp.peps'
388    'pennlp.umin'
389    'pennlp.preckkt'
390    'pennlp.cgtolmin'
391    'pennlp.cgtolup'
392    'pennlp.uinitbox'
393    'pennlp.uinitnc'
394
395    'lmirank.solver'
396    'lmirank.maxiter'   
397    'lmirank.eps'
398    'lmirank.itermod'
399    'lmilab.reltol'
400    'lmilab.maxiter'
401    'lmilab.feasradius'
402    'lmilab.L'
403   
404    'lindo.LS_IPARAM_NLP_SOLVER'
405    'lindo.LS_IPARAM_NLP_MAXLOCALSEARCH'
406    'lindo.METHOD'
407   
408
409    'mosek.param'   
410    'sos.model'
411    'sos.newton'
412    'sos.congruence'
413    'sos.scale'
414    'sos.numblkdg'
415    'sos.postprocess'
416    'sos.sparsetol'
417    'sos.impsparse'
418    'sos.extlp'
419    'sos.csp'
420    'sos.savedecomposition'
421    'sos.clean'
422    'sos.traceobj'
423    'sos.reuse'
424    'sos.inconsistent'
425    'sos.separable'
426    'csdp.axtol'
427    'csdp.atytol'
428    'csdp.objtol'
429    'csdp.pinftol'
430    'csdp.dinftol'
431    'csdp.maxiter'
432    'csdp.minstepfrac'
433    'csdp.maxstepfrac'
434    'csdp.minstepp'
435    'csdp.minstepd'
436    'csdp.usexzgap'
437    'csdp.tweakgap'
438    'specsdp.gatol1'
439    'specsdp.gatol2'
440    'specsdp.niter=20'
441    'specsdp.faiseps'
442    'specsdp.compleps'
443    'specsdp.stateps'
444    'specsdp.penfact'
445    'specsdp.penmin'
446    'specsdp.pendiv'
447    'specsdp.peneps'
448    'specsdp.Vinit'
449    'specsdp.radius'
450    'nag.featol'
451    'nag.itmax'
452    'nag.bigbnd'
453    'nag.orthog'
454    'kypd.solver'
455    'kypd.lyapunovsolver'
456    'kypd.reduce'
457    'kypd.transform'
458    'kypd.rho'
459    'kypd.tol'
460    'kypd.lowrank'
461    'moment.order'
462    'moment.blockdiag'
463    'moment.solver'
464    'moment.refine'
465    'moment.extractrank'
466    'moment.rceftol'
467};
468
469% Try to run optimset
470[Names,quadprognames,quadprogops]     = trytoset('quadprog',Names);
471[Names,linprognames,linprogops]       = trytoset('linprog',Names);
472[Names,bintprognames,bintprogops]     = trytoset('bintprog',Names);
473[Names,fminconnames,fminconops]       = trytoset('fmincon',Names);
474[Names,fminsearchnames,fminsearchops] = trytoset('fminsearch',Names);
475
476obsoletenames ={
477    'abstol'
478    'reltol'
479    'accelerator'
480    'maxiters'
481    'abstol_init'
482    'reltol_init'
483    'accelerator_init'
484    'maxiters_init'
485    'tv'
486    'mfactor'
487    'sedumi.maxradius'
488    'sedumi.uselpsolver'
489    'sedumi.removeequalities'
490    'silent'
491    'sos.solvedual'
492    'reduce'
493    'penbmi.pbm_eps'};
494
495[m,n] = size(Names);
496names = lower(Names);
497
498if (nargin>0) & isstruct(varargin{1})
499    options = varargin{1};
500    paramstart = 2;
501else
502    paramstart = 1;
503    % YALMIP options
504    options.solver = '';
505    options.verbose = 1;
506    options.dimacs = 1;
507    options.warning = 1;
508    options.cachesolvers = 0;
509    options.beeponproblem = [-5 -4 -3 -2 -1];
510    options.showprogress = 0;
511    options.saveduals = 1;
512    options.removeequalities = 0;
513    options.savesolveroutput = 0;
514    options.savesolverinput  = 0;
515    options.convertconvexquad = 1;
516    options.radius = inf;
517    options.relax = 0;
518    options.dualize = 0;
519    options.usex0 = 0;
520    options.shift = 0;
521    options.savedebug = 0;
522    options.debug = 0;
523    options.expand = 1;   
524    options.allowmilp = 1;
525    options.allownonconvex = 0;
526   
527    options.sos.model = 0;
528    options.sos.newton = 1;   
529    options.sos.congruence = 2;
530    options.sos.scale = 1;
531    options.sos.numblkdg = 0;
532    options.sos.postprocess = 0;
533    options.sos.csp = 0;   
534    options.sos.extlp = 1;
535    options.sos.impsparse = 0;
536    options.sos.sparsetol = 1e-5;
537    options.sos.inconsistent = 0;
538    options.sos.clean = eps;
539    options.sos.savedecomposition = 1;
540    options.sos.traceobj = 0;
541    options.sos.reuse = 1;
542   
543    options.moment.order = [];
544    options.moment.blockdiag = 0;
545    options.moment.solver = '';
546    options.moment.refine = 0;
547    options.moment.extractrank = 0;
548    options.moment.rceftol = -1;
549   
550    options.bnb.branchrule = 'max';
551    options.bnb.method = 'depthbest';
552    options.bnb.verbose = 1;
553    options.bnb.solver = '';
554    options.bnb.uppersolver = 'rounder';
555    options.bnb.presolve = 0;
556    options.bnb.inttol = 1e-4;
557    options.bnb.feastol = 1e-7;
558    options.bnb.gaptol = 1e-4;
559    options.bnb.weight = [];
560    options.bnb.nodetight = 0;
561    options.bnb.nodefix = 0;
562   
563    options.bnb.round = 1;
564    options.bnb.maxiter = 300;
565   
566    options.bnb.prunetol = 1e-4;
567    options.bnb.multiple = 0;
568   
569    try
570        options.bpmpd.opts = bpopt;   
571    catch
572        options.bpmpd.opts =[];
573    end
574   
575       
576    % Options for global BMI solver
577    options.bmibnb.branchmethod = 'best';
578    options.bmibnb.branchrule = 'omega';
579    options.bmibnb.sdpcuts = 0;
580    options.bmibnb.lpreduce = 1;
581    options.bmibnb.lowrank  = 0;
582    options.bmibnb.lowersolver = '';
583    options.bmibnb.uppersolver = '';
584    options.bmibnb.lpsolver = '';
585    options.bmibnb.target = -inf;
586    options.bmibnb.vartol = 1e-3;
587    options.bmibnb.relgaptol = 1e-2;
588    options.bmibnb.absgaptol = 1e-2;
589    options.bmibnb.pdtol = -1e-6;
590    options.bmibnb.eqtol = 1e-6;
591    options.bmibnb.maxiter = 100;
592    options.bmibnb.maxtime = 3600;
593    options.bmibnb.roottight = 1;
594    options.bmibnb.numglobal = inf;
595   
596    options.cutsdp.solver = '';
597    options.cutsdp.maxiter = 100;
598    options.cutsdp.cutlimit = inf;
599    options.cutsdp.feastol = -1e-8;
600    options.cutsdp.recoverdual = 0;
601    options.cutsdp.variablebound = inf;
602    options.cutsdp.nodefix = 0;
603    options.cutsdp.nodetight = 0;
604   
605    options.mp.algorithm = 1;
606    options.mp.simplify  = 0;
607    options.mp.presolve  = 0;
608    options.mp.unbounded = 0;
609   
610    options.global.branchmethod = 'best';
611    options.global.branchrule = 'omega';
612    options.global.lowersolver = '';
613    options.global.uppersolver = '';
614    options.global.lpsolver = '';   
615    options.global.sdpcuts = 0;
616    options.global.lpreduce = 1;
617    options.global.roottight = 1;   
618    options.global.lowrank  = 0;
619    options.global.target = -inf;
620    options.global.vartol = 1e-3;
621    options.global.relgaptol = 1e-2;
622    options.global.absgaptol = 1e-2;
623    options.global.pdtol = -1e-6;
624    options.global.eqtol = 1e-6;
625    options.global.inttol = 1e-4;
626    options.global.round = 1;   
627    options.global.maxiter = 100;
628    options.global.maxtime = 3600;
629   
630    % Options for approximate multi-parametric
631    %     options.mpcvx.solver = '';
632    %     options.mpcvx.eps = 0.25;
633   
634    options.cdd.method = 'criss-cross';
635   
636    options.clp.solver = 1;
637    options.clp.maxnumiterations = 99999999;
638    options.clp.maxnumseconds = 3600;
639    options.clp.primaltolerance  = 1e-7;
640    options.clp.dualtolerance    = 1e-7;
641    options.clp.primalpivot = 1;
642    options.clp.dualpivot = 1;
643   
644    options.cplex.presol = 1;
645    options.cplex.niter = 1;
646    options.cplex.epgap = 1e-4;
647    options.cplex.epagap = 1e-6;
648    options.cplex.relobjdif = 0.0;
649    options.cplex.objdif = 0.0;
650    options.cplex.tilim = 1e75;
651    options.cplex.logfile = 0;
652    options.cplex.param.double = [];
653    options.cplex.param.int = [];
654
655    options.csdp.axtol  = 1e-8;
656    options.csdp.atytol = 1e-8;
657    options.csdp.objtol = 1e-8;
658    options.csdp.pinftol = 1e8;
659    options.csdp.dinftol = 1e8;
660    options.csdp.maxiter = 100;
661    options.csdp.minstepfrac = 0.90;
662    options.csdp.maxstepfrac = 0.97;
663    options.csdp.minstepp = 1e-8;
664    options.csdp.minstepd = 1e-8;
665    options.csdp.usexzgap = 1;
666    options.csdp.tweakgap = 0;
667   
668    options.mosek.param = [];
669   
670    % Options for DSDP 5.6
671    options.dsdp.r0 = -1;
672    options.dsdp.zbar = 0;
673    options.dsdp.penalty  = 1e8;
674    options.dsdp.boundy  = 1e6;
675    options.dsdp.gaptol = 1e-7;
676    options.dsdp.maxit  = 500;
677    options.dsdp.steptol=5e-2;     
678    options.dsdp.inftol=1e-8;     
679    options.dsdp.dual_bound = 1e20;
680    options.dsdp.rho = 3; 
681    options.dsdp.dynamicrho = 1; 
682    options.dsdp.bigM = 0; 
683    options.dsdp.mu0 = -1;
684    options.dsdp.reuse = 4;
685    options.dsdp.lp_barrier = 1;   
686
687    % Older versions
688    options.dsdp.objectiveconstant = 0;   
689    options.dsdp.matrixfreesize = 3000;
690    options.dsdp.scale_data = 1;   
691    options.dsdp.max_trust_radius = -1;
692    options.dsdp.maxtrustradius = 1e10;
693    options.dsdp.max_infeasible_trust_radius = -1;
694    options.dsdp.max_infeasible_mu_reduction = 2;
695    options.dsdp.max_mu_reduction = 1e8;   
696    options.dsdp.maxlanczos = 20;
697   
698    % Options for GLPK
699    options.glpk.lpsolver = 1;
700    options.glpk.scale = 1;
701    options.glpk.dual = 0;
702    options.glpk.price = 1;
703    options.glpk.relax = 0.07;
704    options.glpk.tolbnd = 1e-7;
705    options.glpk.toldj = 1e-7;
706    options.glpk.tolpiv = 1e-9;
707    options.glpk.round = 0;
708    options.glpk.objll = -1e12;
709    options.glpk.objul = 1e12;
710    options.glpk.itlim = 1e4;
711    options.glpk.tmlim = -1;
712    options.glpk.branch = 2;
713    options.glpk.btrack = 2;
714    options.glpk.tolint = 1e-6;
715    options.glpk.tolobj = 1e-7;
716    options.glpk.presol = 1;
717    options.glpk.save = 0;
718   
719    %     options.specsdp.gatol1 = 5d-1;
720    %     options.specsdp.gatol2 = 5d-3;
721    %     options.specsdp.niter=20;
722    %     options.specsdp.faiseps=1d-8;
723    %     options.specsdp.compleps=1d-6;
724    %     options.specsdp.stateps=1e-6;
725    %     options.specsdp.penfact=2;
726    %     options.specsdp.penmin=300;
727    %     options.specsdp.pendiv= 5;
728    %     options.specsdp.peneps=1.0d-8;
729    %     options.specsdp.Vinit = 1.0;
730    %     options.specsdp.radius= 1e9;
731   
732    options.kypd.solver = '';
733    options.kypd.lyapunovsolver = 'schur';
734    options.kypd.reduce = 0;
735    options.kypd.transform = 0;
736    options.kypd.rho = 1;
737    options.kypd.tol = 1e-8;
738    options.kypd.lowrank = 0;
739   
740    options.lmilab.reltol = 1e-3;
741    options.lmilab.maxiter = 100;
742    options.lmilab.feasradius = 1e9;
743    options.lmilab.L = 10;
744   
745    options.lmirank.solver = '';
746    options.lmirank.maxiter = 100;     
747    options.lmirank.maxiter = 1000;
748    options.lmirank.eps = 1e-9;
749    options.lmirank.itermod = 1;
750   
751    options.lindo.LS_IPARAM_NLP_SOLVER = 'LS_NMETHOD_MSW_GRG';
752    options.lindo.LS_IPARAM_NLP_MAXLOCALSEARCH = 1;
753    options.lindo.LS_METHOD = 'LS_METHOD_FREE';
754   
755    options.lpsolve.scalemode = 0;
756   
757    % Options for MAXDET solver
758    options.maxdet.AbsTol = 1e-6;
759    options.maxdet.RelTol = 1e-6;
760    options.maxdet.gam    = 25;
761    options.maxdet.NTiters= 50;
762   
763    options.nag.featol = sqrt(eps);
764    options.nag.itmax = 500;
765    options.nag.bigbnd = 1e10;
766    options.nag.orthog = 0;
767   
768    options.penbmi.DEF = 1;
769    options.penbmi.PBM_MAX_ITER = 50;
770    options.penbmi.UM_MAX_ITER = 100;
771    options.penbmi.OUTPUT = 1;
772    options.penbmi.DENSE = 1;          %!0
773    options.penbmi.LS = 0;
774    options.penbmi.XOUT = 0;
775    options.penbmi.UOUT = 0;
776    options.penbmi.NWT_SYS_MODE = 0;
777    options.penbmi.PREC_TYPE = 0;
778    options.penbmi.DIMACS = 0;
779    options.penbmi.TR_MODE = 0;
780    options.penbmi.U0 = 1;
781    options.penbmi.MU = 0.7;
782    options.penbmi.MU2 = 0.5;          %!0.1
783   % options.penbmi.PBM_EPS = 1e-6;     %!1e-7
784    options.penbmi.PRECISION = 1e-6;     %!1e-7   
785    options.penbmi.P_EPS = 1e-4;       %!1e-6
786    options.penbmi.UMIN = 1e-14;
787    options.penbmi.ALPHA = 1e-2;
788    options.penbmi.P0 = 0.1;           %!0.01
789    options.penbmi.PEN_UP = 0.5;       %!0
790    options.penbmi.ALPHA_UP = 1.0;
791    options.penbmi.PRECISION_2 = 1e-6; %!1e-7
792    options.penbmi.CG_TOL_DIR = 5e-2;
793   
794    options.pennlp.maxit = 100;
795    options.pennlp.nwtiters = 100;
796    options.pennlp.hessianmode = 0;
797    options.pennlp.autoscale = 1;
798    options.pennlp.convex = 0;
799    options.pennlp.eqltymode = 1;
800    options.pennlp.ignoreinit = 0;
801    options.pennlp.ncmode = 0;
802    options.pennlp.nwtstopcrit = 2;
803    options.pennlp.penalty = 0;
804    options.pennlp.nwtmode = 0;
805    options.pennlp.prec = 0;
806    options.pennlp.cmaxnzs =-1;
807    options.pennlp.autoini = 1;
808    options.pennlp.ipenup = 1;
809   
810    options.pennlp.precision = 1e-7;
811    options.pennlp.uinit = 1;
812    options.pennlp.pinit = 1;
813    options.pennlp.alpha = 0.01;
814    options.pennlp.mu = 0.5;
815    options.pennlp.dpenup = 0.1;
816    options.pennlp.peps = 1e-8;
817    options.pennlp.umin = 1e-12;
818    options.pennlp.preckkt = 1e-1;
819    options.pennlp.cgtolmin = 5e-2;
820    options.pennlp.cgtolup = 1;
821    options.pennlp.uinitbox = 1;
822    options.pennlp.uinitnc = 1;
823   
824     
825    options.pensdp.DEF = 1;
826    options.pensdp.PBM_MAX_ITER = 50;
827    options.pensdp.UM_MAX_ITER = 100;
828    options.pensdp.OUTPUT = 1;
829    options.pensdp.DENSE = 0;
830    options.pensdp.LS = 0;
831    options.pensdp.XOUT = 0;
832    options.pensdp.UOUT = 0;
833    options.pensdp.U0 = 1;
834    options.pensdp.MU = 0.7;
835    options.pensdp.MU2 = 0.1;
836    options.pensdp.PBM_EPS = 1e-7;
837    options.pensdp.P_EPS = 1e-6;
838    options.pensdp.UMIN = 1e-14;
839    options.pensdp.ALPHA = 1e-2;
840    options.pensdp.P0 = 0.9;
841   
842    % Options for SDPA
843    options.sdpa.maxIteration = 40 ;
844    options.sdpa.epsilonStar = 1.0E-7;
845    options.sdpa.lambdaStar  = 1.0E2  ;
846    options.sdpa.omegaStar  = 2.0 ;
847    options.sdpa.lowerBound  = -1.0E5  ;
848    options.sdpa.upperBound  = 1.0E5  ;
849    options.sdpa.betaStar  = 0.1  ;
850    options.sdpa.betaBar  = 0.2 ;
851    options.sdpa.gammaStar  = 0.9 ;
852    options.sdpa.epsilonDash  = 1.0E-7 ;
853    options.sdpa.searchDir = 1 ;
854    options.sdpa.isSymmetric = 0 ;
855   
856    options.sdplr.feastol = 1e-5;
857    options.sdplr.centol = 1e-1;
858    options.sdplr.dir = 1;
859    options.sdplr.penfac = 2;
860    options.sdplr.reduce = 1;
861    options.sdplr.limit = 3600;
862    options.sdplr.soln_factored = 0;
863    options.sdplr.maxrank = 0;
864   
865    % Options for SDPT3 (2.3 -> 3.01)
866    options.sdpt3.vers     = 1;
867    options.sdpt3.gam      = 0;
868    options.sdpt3.predcorr = 1;
869    options.sdpt3.expon    = 1;
870    options.sdpt3.gaptol   = 1e-7;
871    options.sdpt3.inftol   = 1e-7;
872    options.sdpt3.steptol  = 1e-6;
873    options.sdpt3.maxit    = 50;
874    options.sdpt3.stoplevel= 1;
875    options.sdpt3.sw2PC_tol  = inf;
876    options.sdpt3.use_corrprim  = 0;
877    options.sdpt3.printyes   = 1;
878    options.sdpt3.scale_data = 0;
879    options.sdpt3.schurfun   = [];
880    options.sdpt3.schurfun_parms = [];
881    options.sdpt3.randnstate = 0;
882    options.sdpt3.spdensity   = 0.5;
883    options.sdpt3.rmdepconstr = 0;
884    options.sdpt3.CACHE_SIZE = 256;
885    options.sdpt3.LOOP_LEVEL = 8;
886    options.sdpt3.cachesize = 256;
887    options.sdpt3.linsys_options = 'raugmatsys';
888    options.sdpt3.smallblkdim = 30;
889   
890    % Options for SeDuMi (1.03 -> 1.05)
891    options.sedumi.alg    = 2;
892    options.sedumi.beta   = 0.5;
893    options.sedumi.theta  = 0.25;
894    options.sedumi.free   = 1;
895    options.sedumi.sdp    = 0;
896    options.sedumi.stepdif= 0;
897    options.sedumi.w      = [1 1];
898    options.sedumi.mu     = 1.0;
899    options.sedumi.eps    = 1e-9;
900    options.sedumi.bigeps = 1e-3;
901    options.sedumi.maxiter= 150;
902    options.sedumi.vplot  = 0;
903    options.sedumi.stopat     = -1;
904    options.sedumi.denq   = 0.75;
905    options.sedumi.denf   = 10;
906    options.sedumi.numtol = 5e-7;
907    options.sedumi.bignumtol = 0.9;
908    options.sedumi.numlvlv = 0;
909    options.sedumi.chol.skip = 1;
910    options.sedumi.chol.canceltol = 1e-12;
911    options.sedumi.chol.maxu   = 5e5;
912    options.sedumi.chol.abstol = 1e-20;
913    options.sedumi.chol.maxuden= 5e2;
914    options.sedumi.cg.maxiter = 25;
915    options.sedumi.cg.restol  = 5e-3;
916    options.sedumi.cg.refine  = 1;
917    options.sedumi.cg.stagtol = 5e-14;
918    options.sedumi.cg.qprec   = 0;
919    options.sedumi.maxradius = inf;
920   
921   
922    options.qsopt.dual = 0;
923    options.qsopt.primalprice = 1;
924    options.qsopt.dualprice = 6;
925    options.qsopt.scale = 1;
926    options.qsopt.maxiter = 300000;
927    options.qsopt.maxtime = 10000.0;
928   
929    options.xpress.presol = 1;
930    options.xpress.niter  = 1;
931   
932    try
933        % Maybe we already created these above
934        if exist('fminconops','var')
935            options.quadprog = quadprogops;
936            options.linprog  = linprogops;
937            options.bintprog  = bintprogops;
938            options.fmincon  = fminconops;
939            options.fminsearch  = fminsearchops;
940        else
941            options.quadprog = optimset('quadprog');
942            options.linprog  = optimset('linprog');
943            options.bintprog  = optimset('linprog');
944            options.fmincon  = optimset('fmincon');
945            options.fminsearch  = optimset('fminsearch');
946        end
947    catch
948        try
949            % Ok, what about tomlab then?
950            options.quadprog = optimset;
951            options.linprog  = optimset;
952            options.bintprog = optimset;
953            options.fmincon  = optimset;
954            options.fminsearch  = optimset;
955        catch
956            options.quadprog = [];
957            options.linprog  = [];
958            options.bintprog = [];
959            options.fmincon  = [];
960            options.fminsearch  = [];
961        end
962    end
963end
964
965i = paramstart;
966% A finite state machine to parse name-value pairs.
967if rem(nargin-i+1,2) ~= 0
968    error('Arguments must occur in name-value pairs.');
969end
970expectval = 0;                          % start expecting a name, not a value
971while i <= nargin
972    arg = varargin{i};
973   
974    if ~expectval
975        if ~isstr(arg)
976            error(sprintf('Expected argument %d to be a string property name.', i));
977        end
978       
979        lowArg = lower(arg);
980       
981        j_old = strmatch(lowArg,obsoletenames);
982        if ~isempty(j_old)
983            % For compability...
984           
985            if strcmp(lowArg,'sedumi.removeequalities')
986                lowArg = 'removeequalities';
987                arg = lowArg;
988               
989            elseif strcmp(lowArg,'silent')
990                lowArg = 'verbose';
991                if varargin{i+1}==1
992                    varargin{i+1} = 0;
993                else
994                    varargin{i+1} = 1;
995                end
996                warning('The field ''silent'' is obsolete. Use ''verbose'' instead')
997            elseif strcmp(lowArg,'sedumi.maxradius')
998                lowArg = 'radius';
999                arg = lowArg;
1000                warning('The field ''sedumi.maxradius'' is obsolete. Use ''radius'' instead')
1001             elseif strcmp(lowArg,'penbmi.pbm_eps')
1002                lowArg = 'penbmi.precision';
1003                arg = lowArg;
1004                warning('The field ''penbmi.pbm_eps'' is obsolete. Use ''penbmi.precision'' instead')               
1005            elseif strcmp(lowArg,'sos.solvedual')
1006                lowArg = 'sos.model';
1007                arg = lowArg;
1008            else
1009                error(sprintf('The property name ''%s'' is obsolete. Sorry...', arg));
1010            end
1011        end
1012       
1013        j = strmatch(lowArg,names);
1014        if isempty(j)                       % if no matches
1015            error(sprintf('Unrecognized property name ''%s''.', arg));
1016        elseif length(j) > 1                % if more than one match
1017            % Check for any exact matches (in case any names are subsets of others)
1018            k = strmatch(lowArg,names,'exact');
1019            if length(k) == 1
1020                j = k;
1021            else
1022                msg = sprintf('Ambiguous property name ''%s'' ', arg);
1023                msg = [msg '(' deblank(Names{j(1)})];
1024                for k = j(2:length(j))'
1025                    msg = [msg ', ' deblank(Names{k})];
1026                end
1027                msg = sprintf('%s).', msg);
1028                error(msg);
1029            end
1030        end
1031        expectval = 1;                      % we expect a value next
1032    else
1033        eval(['options.' Names{j} '= arg;']);
1034        expectval = 0;
1035    end
1036    i = i + 1;
1037end
1038
1039if expectval
1040    error(sprintf('Expected value for property ''%s''.', arg));
1041end
1042
1043
1044function [Names,solvernames,solverops] = trytoset(solver,Names)
1045
1046try
1047    solverops = optimset(solver);
1048    solvernames = fieldnames(solverops);
1049
1050    if any(strcmp(solvernames,'LargeScale'))
1051        solverops.LargeScale = 'off';
1052    else
1053        solvernames{end+1} = 'LargeScale';
1054        solverops.LargeScale = 'off';
1055    end
1056
1057    for i = 1:length(solvernames)
1058        Names = [Names;{[solver '.' solvernames{i}]}];
1059    end
1060
1061catch
1062    solvernames = {'LargeScale'};
1063    solverops = struct('LargeScale','off');
1064end
1065
Note: See TracBrowser for help on using the repository browser.