TRANSTATION

robustify Derives robust counterpart.

[Frobust,objrobust,failure] = robustify(F,h,options,w^[1])

is used to derive the robust counterpart of an uncertain YALMIP model.


                            min        h(x,w)
    subject to
F(x,w) >(=) 0  for all w in W

The constraints and objective have to satisfy a number of conditions for the robustification to be possible. Please refer to the YALMIP Wiki for the current assumptions.
Some options for the robustification strategies can be altered via the solver tag 'robust' in sdpsettings

'robust.lplp' : Controls how linear constraints with affine parameterization in an uncertainty with polytopic description is handled. Can be either 'duality' or 'enumeration'

'robust.auxred' : Controls how uncertainty dependent auxiliary variables are handled Can be either 'projection' or 'enumeration' (exact), or 'none' or 'affine' (conservative)

'robust.reducedual' Controls if the system equality constraints derived when using the duality filter should be eliminated, thus reducing the number of variables, possibly destroying sparsity .

'robust.polya' : Controls the relaxation order of polynomials. If set to NAN, the polynomials will be eliminated by forcing the coefficients to zero

See also uncertain

[1] It should be 4 inputs there, modified by @Trancemania

optimizer Container for optimization problem

OPT = optimizer(Constraints,Objective,options,x,u)

exports an object that contains precompiled numerical data to be solved for varying arguments x, returning the optimal value of the expression u.

optimizer works most efficiently if the varying data x enters the optmization problem affinely. For the general cae, much more logic has to be applied when instantiating the numerical data for a parametric value, and when compiling the model, it is harder fpr YALMIP to understand what kind of model it will be once th parameters are fixed.

By default, display is turned off (since optimizer is used in situations where many problems are solved repeatedly. To turn on display, set the verbose option in sdpsetting to 2.

Example

The following problem creates an LP with varying upper and lower bounds on the decision variable.


                                A = randn(10,3);
    b = rand(10,1)*19;
    c = randn(3,1);
    z = sdpvar(3,1);
    sdpvar UB LB
    Constraints = [A*z <= b, LB <= z <= UB];
    Objective = c'*z
    % We want the optimal z as a function of [LB;UB]
    optZ = optimizer(Constraints,Objective,[],[LB; UB],z);
    % Compute the optimal z when LB=1, UB = 3;
    zopt = optZ{[1; 3]}
    % Compute two solutions, one for (LB,UB) [1;3] and one for (LB,UB) [2;6]
    zopt = optZ{[[1; 3], [2;6]]}
    % A second output argument can be used to catch infeasibility
    [zopt,infeasible] = optZ{[1; 3]}
    % To avoid the need to vectorize in order to handle multiple
    % parameters, a cell-based definition can be used
    optZ = optimizer(Constraints,Objective,[],{LB,UB},{z,sum(z)})
    [zopt,infeasible] = optZ{{1,3}};
    zopt{1}
    zopt{2}


                        1   % YALMIP options
2       yalmip('clear')
3       yopts = sdpsettings('robust.polya',1);
4   % Model data
5       A1 = [0.85 0;0.25 0.65];
6       A2 = [0.85 0;-0.3 0.65];
7       B1 = [1;-1];
8       B2 = [1;1];
9       B{1} = B1;
10      B{2} = B2;
11  % System sizes
12      nx   = 2; % Number of states
13      nu   = 1; % Number of inputs
14      ndyn = 2; % Number of vertex systems
15  % State and input constraints
16      xmin = [-10;-10];
17      xmax = [  8;  8];
18      umin = -0.5;
19      umax =   1 ;
20  % MPC data
21      Q   = eye(nx);
22      R   = 0.01;
23      N   = 3;
24      xref = [0;0];
25  % States x(k), ..., x(k+N)
26      x = sdpvar(repmat(nx,1,N),repmat(1,1,N));
27  % Inputs u(k), ..., u(k+N) (last one not used)
28      u = sdpvar(repmat(nu*ndyn,1,N),repmat(1,1,N));
29  % Scheduling parameter
30      th = binvar(repmat(ndyn,1,N),repmat(1,1,N));
31  % Epigraph variable
32      sdpvar w;
33      for k = N:-1:1   % shifted: N-1:-1:0
34      % Parameter simplex
35         F = [uncertain(th{k}), sum(th{k}) == 1, 0 <= th{k} <= 1];
36      % Epigraph variable, MPT requires a bounded set so let us add artificial upper bound
37         F = [F, 0 <= w <= 10000];
38      % Uncertain predictions and control
39         uth = kron(th{k},eye(nu))'*u{k};    % u(th)
40         Ath = [A1 A2]*kron(th{k},eye(nx));  % A(th) = A1*th1 + A2*th2 + ...
41         Bth = [B1 B2]*kron(th{k},eye(nu));  % B(th)
42         xp  = Ath*x{k} + Bth*uth;
43      % Input constraints
44         F = [F, repmat(umin,ndyn,1) <= u{k} <=  repmat(umax,ndyn,1)];
45      % State constraints
46         F = [F, xmin  <= x{k} <= xmax];
47      % Insert step-specific code here
48
49         if k == N
50       % Initial step
51       % |x| written as max(a[x;u]+b)
52             a = [kron(eye(nx),[1 -1]') zeros(2*nx,nu)];
53             b = zeros(2*nx,1);
54       % |u| written as max(c[x;u]+d)
55             c = [zeros(2*nu,nx) kron(eye(nu),[1 -1]')];
56             d = zeros(2*nu,1);
57       % |x|+|u| written as max(aa[x;u]+bb)
58             aa = repmat(a,2*nu,1) + kron(c,ones(size(a,1),1));
59             bb = repmat(b,2*nu,1) + kron(d,ones(size(a,1),1));
60       % Final state constraints
61             F = [F, xmin  <= xp   <= xmax];
62       % Cost function
63             F   = [F, aa*[Q*(xp-xref);R*uth]+bb + norm(Q*(x{k}-xref),inf) <= w];
64             obj = w;
65
66         elseif k > 1
67       % Intermediate step
68       % Get the hyperplanes for cost-to-go
69             S = unique(([reshape([sol{k+1}{1}.Bi{:}]' ,nx,[])'  reshape([sol{k+1}{1}.Ci{:}]' ,[],nu)]),'rows');
70             a = [S(:,1:nx) zeros(size(S,1),nu)];
71             b = S(:,nx+1:end);
72       % Jp+|u| = max(a[x;u]+b)+|u|=max(a[x;u]+b)+max(c[x;u]+d)=max(aa[x;u]+bb)
73             aa = repmat(a,2*nu,1) + kron(c,ones(size(a,1),1));
74             bb = repmat(b,2*nu,1) + kron(d,ones(size(a,1),1));
75       % Constrain predicted state
76             [H,K] = double(sol{k+1}{1}.Pfinal);
77             F     = [F, H*xp <= K];
78       % Cost function
79             F   = [F, aa*[xp;R*uth]+bb <= w];
80             obj = norm(Q*(x{k}-xref),inf) + w;
81
82         else
83       % Final step
84       % Get the hyperplanes for cost-to-go
85             S = unique(([reshape([sol{k+1}{1}.Bi{:}]',nx,[])' reshape([sol{k+1}{1}.Ci{:}]',[],nu)]),'rows');
86             a = [S(:,1:nx) zeros(size(S,1),nu)];
87             b = S(:,nx+1:end);
88       % Jp+|u| = max(a[x;u]+b)+|u|=max(a[x;u]+b)+max(c[x;u]+d)=max(aa[x;u]+bb)
89             aa = repmat(a,2*nu,1) + kron(c,ones(size(a,1),1));
90             bb = repmat(b,2*nu,1) + kron(d,ones(size(a,1),1));
91       % State update equation
92             xp = x{k} + Bth*uth; % x{1} = z
93       % Constrain predicted state
94             [H,K] = double(sol{k+1}{1}.Pfinal);
95             F     = [F, H*xp <= K];
96       % Cost function
97             F   = [F, aa*[xp;R*uth]+bb <= w];
98             obj = w;
99       % add eps-penalty on vertex predictions
100            for v = 1:ndyn
101                xpv{v} = x{k} + B{v}*u{k}(v);
102                obj = obj + 0.001*norm(Q*xpv{v},inf);
103            end
104        end
105
106     % Determine robust counterpart
107        [F,obj] = robustify(F,obj,yopts,th{k});
108     % Solve multi-parametric problem
109        [sol{k},diagnost{k},Uz{k},J{k},Optimizer{k}] = solvemp(F,obj,yopts,x{k},u{k});
110     end


                        ***** Starting YALMIP robustification module. *********************
- Detected 2 uncertain variables
- Detected 2 independent group(s) of uncertain variables
- Complicating terms in w encountered. Trying to eliminate by forcing some decision variables to 0
- Eliminating uncertainty using explicit maximization of inf-norm
***** Derivation of robust counterpart done ***********************
++++++++++++++++++++++++++++++++++++++++++++++++++
|    ID|                               Constraint|
++++++++++++++++++++++++++++++++++++++++++++++++++
|    #1|                  Equality constraint 1x1|
|    #2|                  Equality constraint 1x1|
|    #3|                  Equality constraint 1x1|
|    #4|                  Equality constraint 1x1|
|    #5|                  Equality constraint 1x1|
|    #6|                  Equality constraint 1x1|
|    #7|                  Equality constraint 1x1|
|    #8|                  Equality constraint 1x1|
|    #9|                  Equality constraint 1x1|
|   #10|                  Equality constraint 1x1|
|   #11|                  Equality constraint 1x1|
|   #12|                  Equality constraint 1x1|
|   #13|                  Equality constraint 1x1|
|   #14|                  Equality constraint 1x1|
|   #15|                  Equality constraint 1x1|
|   #16|                  Equality constraint 1x1|
|   #17|                  Equality constraint 1x1|
|   #18|                  Equality constraint 1x1|
|   #19|                  Equality constraint 1x1|
|   #20|                  Equality constraint 1x1|
|   #21|                  Equality constraint 1x1|
|   #22|                  Equality constraint 1x1|
|   #23|                  Equality constraint 1x1|
|   #24|                  Equality constraint 1x1|
|   #25|                  Equality constraint 1x1|
|   #26|                  Equality constraint 1x1|
|   #27|                  Equality constraint 1x1|
|   #28|                  Equality constraint 1x1|
|   #29|                  Equality constraint 1x1|
|   #30|                  Equality constraint 1x1|
|   #31|                  Equality constraint 1x1|
|   #32|                  Equality constraint 1x1|
|   #33|                  Equality constraint 1x1|
|   #34|                  Equality constraint 1x1|
|   #35|                  Equality constraint 1x1|
|   #36|                  Equality constraint 1x1|
|   #37|    Element-wise inequality (derived) 1x1|
|   #38|    Element-wise inequality (derived) 1x1|
|   #39|    Element-wise inequality (derived) 1x1|
|   #40|    Element-wise inequality (derived) 1x1|
|   #41|   Element-wise inequality (derived) 60x1|
|   #42|              Element-wise inequality 2x1|
|   #43|              Element-wise inequality 4x1|
|   #44|              Element-wise inequality 4x1|
++++++++++++++++++++++++++++++++++++++++++++++++++


                        ***** Starting YALMIP robustification module. *********************
- Detected 2 uncertain variables
- Detected 1 independent group(s) of uncertain variables
- Complicating terms in w encountered. Trying to eliminate by forcing some decision variables to 0
- Enumerated 2 vertices
***** Derivation of robust counterpart done ***********************
++++++++++++++++++++++++++++++++++++++++++++++++++
|    ID|                               Constraint|
++++++++++++++++++++++++++++++++++++++++++++++++++
|    #1|                  Equality constraint 1x1|
|    #2|                  Equality constraint 1x1|
|    #3|                  Equality constraint 1x1|
|    #4|                  Equality constraint 1x1|
|    #5|                  Equality constraint 1x1|
|    #6|                  Equality constraint 1x1|
|    #7|                  Equality constraint 1x1|
|    #8|                  Equality constraint 1x1|
|    #9|                  Equality constraint 1x1|
|   #10|                  Equality constraint 1x1|
|   #11|                  Equality constraint 1x1|
|   #12|                  Equality constraint 1x1|
|   #13|                  Equality constraint 1x1|
|   #14|                  Equality constraint 1x1|
|   #15|                  Equality constraint 1x1|
|   #16|                  Equality constraint 1x1|
|   #17|                  Equality constraint 1x1|
|   #18|                  Equality constraint 1x1|
|   #19|                  Equality constraint 1x1|
|   #20|                  Equality constraint 1x1|
|   #21|                  Equality constraint 1x1|
|   #22|                  Equality constraint 1x1|
|   #23|                  Equality constraint 1x1|
|   #24|                  Equality constraint 1x1|
|   #25|                  Equality constraint 1x1|
|   #26|                  Equality constraint 1x1|
|   #27|                  Equality constraint 1x1|
|   #28|                  Equality constraint 1x1|
|   #29|                  Equality constraint 1x1|
|   #30|                  Equality constraint 1x1|
|   #31|                  Equality constraint 1x1|
|   #32|                  Equality constraint 1x1|
|   #33|                  Equality constraint 1x1|
|   #34|                  Equality constraint 1x1|
|   #35|                  Equality constraint 1x1|
|   #36|                  Equality constraint 1x1|
|   #37|   Element-wise inequality (derived) 26x1|
|   #38|              Element-wise inequality 2x1|
|   #39|              Element-wise inequality 4x1|
|   #40|              Element-wise inequality 4x1|
++++++++++++++++++++++++++++++++++++++++++++++++++

Paper3 simulation

I. Cost function

problems:

codes in main_v0.m:

source files:

hints to problems:

hints to hints to problems:

full copy of YALMIP LPV1 codes:

result and conclusion to all hints:

pre analysis of YALMIP LPV1 example :

post analysis of YALMIP LPV1 example :

CONCLUSION:

II. CLOTURE