YALMIP

https://yalmip.github.io
Admin
YALMIP is a modeling language for disciplined convex and nonconvex programming, providing a unified...
Tokens:230,776
Snippets:3,160
Trust Score:9.7
Update:3 months ago
Show doc for...
Tokens:
Raw
### Sum-of-Squares SDP Setup

Source: https://yalmip.github.io/_posts/commands/2016-09-17-sosmodel

Example demonstrating the setup of an SDP for finding a polynomial lower bound using sosmodel.

```matlab
sdpvar x t
p = 8*x^4+x+5;
Model = [sos(p-t)];
[F,objective,monomials] = sosmodel(Model,-t,sdpsettings('sos.scale',0),t);
sdisplay(sdpvar(F(1)))
ans =

    '5-t'                    '0.5'                   '-0.4472*internal(1)'
    '0.5'                    '0.8944*internal(1)'    '0'                  
    '-0.4472*internal(1)'    '0'                     '8'  
sdisplay(monomials{1})
ans =

    '1'
    'x'
    'x^2'
```

--------------------------------

### Install DAQP in MATLAB

Source: https://yalmip.github.io/_posts/solvers/2022-08-12-daqp

Use these commands to download and run the DAQP installation script directly within the MATLAB environment.

```matlab
websave('install_daqp','https://raw.githubusercontent.com/darnstrom/daqp/master/interfaces/daqp-matlab/install_daqp.m')
install_daqp
```

--------------------------------

### Setup Simulation Parameters

Source: https://yalmip.github.io/_posts/examples/2017-08-21-simulink

Initializes the state-space model and simulation parameters for the Simulink environment.

```matlab
% System
Plant = ss(tf(1,[1 0 0]));
A = Plant.A;
B = Plant.B;
C = Plant.C;
D = Plant.D;
% Global sampling-time
Ts = 0.1;
% Initial state for simulation
x0 = [1;1];
```

--------------------------------

### Use warmstart for solver initialization

Source: https://yalmip.github.io/_posts/commands/2022-06-21-warmstart

Example of providing an initial guess to a solver using the warmstart option.

```matlab
x = sdpvar(1,1);
warmstart(x,pi);
optimize([sin(x)^2 <= .1],x,sdpsettings('warmstart',1));
```

--------------------------------

### Run default installation test

Source: https://yalmip.github.io/_posts/commands/2016-09-17-yalmiptest

Executes the full test suite using default settings.

```matlab
yalmiptest
```

--------------------------------

### Set up binary linear programs

Source: https://yalmip.github.io/_posts/commands/2016-09-17-binary

Examples of setting up binary linear programs using binvar or the binary constraint.

```MATLAB
x = binvar(n,1);
optimize(A*x<=b,c'*x)
```

```MATLAB
x = sdpvar(n,1);
optimize([A*x<=b, binary(x)],c'*x)
```

--------------------------------

### Set up integer linear programs

Source: https://yalmip.github.io/_posts/commands/2016-09-17-integer

Examples showing how to define integer variables or apply constraints within an optimization problem.

```matlab
x = intvar(n,1);
optimize([A*x<=b],c'*x)
```

```matlab
x = sdpvar(n,1);
optimize([A*x<=b, integer(x)],c'*x)
```

--------------------------------

### Bisection Solver Usage

Source: https://yalmip.github.io/_posts/commands/2016-09-17-bisection

Examples of calling the bisection algorithm as a command or as a standard solver.

```matlab
P = sdpvar(2);
sdpvar t
Constraint = [P <= t*P + eye(2), P >= eye(2)/3]
Objective = t;
diagnostics = bisection(Constraint,Objective,sdpsettings('solver','mosek'))
```

```matlab
P = sdpvar(2);
sdpvar t
Constraint = [P <= t*P + eye(2), P >= eye(2)/3]
Objective = t;
diagnostics = bisection(Constraint,Objective,sdpsettings('solver','bisection','bisection.solver','mosek'))
```

--------------------------------

### Example of cut usage

Source: https://yalmip.github.io/_posts/commands/2016-09-17-cut

Demonstrates defining a matrix inequality as a cut for the solver.

```matlab
P = sdpvar(2,2);
F = cut((P-eye(2))*(P-eye(2))>=0);
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|   ID|      Constraint|                                Type|
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|   #1|   Numeric value|   Matrix inequality (quadratic) 2x2|
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
```

--------------------------------

### Handling nonlinear callback functions

Source: https://yalmip.github.io/optimizerupdates

Example of using nonlinear functions within the optimizer framework.

```MATLAB
Objective = (x-4*sin(b))^2;
Saturation = optimizer([-a <= x <= 1 + cos(a) ], Objective,sdpsettings('solver','mosek'), { a , b}, x);
[A,B] = meshgrid(0.5:0.25:2*pi,-2*pi:0.2:2*pi);
Optimal = Saturation(A(:)',B(:)');
mesh(A,B,reshape(Optimal,size(A)));
```

--------------------------------

### Optimize with sdpfun

Source: https://yalmip.github.io/_posts/commands/2016-09-17-sdpfun

Example of using a nonlinear solver to find a local optimizer for a trigonometric problem.

```matlab
sdpvar x
y = sdpfun(10*x,'sin')
optimize([-pi <= x <= pi],y+abs(x))
```

--------------------------------

### Inspecting sdpvar expressions with see

Source: https://yalmip.github.io/_posts/commands/2021-05-06-see

Examples demonstrating how to use see to inspect various sdpvar variable configurations and expressions.

```matlab
yalmip('clear')
x = sdpvar(1);
y = sdpvar(1);
z = 1 + 2*x + 3*y + 4*x^2;

see(x)
Constant matrix
 
     0

Base matrices
 
     1

 
Used variables
 
     1
     
see(y)
Constant matrix
 
     0

Base matrices
 
     1

 
Used variables
 
     2

see(z) 
Constant matrix
 
     1

Base matrices
 
     2

 
     3

 
     4

 
Used variables
 
     1     2     3
     
see([5*x 6*y+7*x^2])
 
Constant matrix
 
     0     0

Base matrices
 
     5     0

 
     0     6

 
     0     7

 
Used variables
 
     1     2     3     
```

--------------------------------

### Relaxed Problem Optimization

Source: https://yalmip.github.io/_posts/commands/2016-09-16-relaxvalue

Setup and optimization of a trivial relaxed problem using sdpsettings.

```MATLAB
sdpvar x
Model = [[2 3] <= [x x^2]];
Objective = x + x^2
optimize(Model,Objective,sdpsettings('relax',1))
```

--------------------------------

### Define Model with Constant Parameters

Source: https://yalmip.github.io/fixedconstraints

Initial model setup where k and m are treated as symbolic constants.

```matlab
sdpvar x y
Constraints = [x >= 1, y >= k*y + m]
optimize(F,obj)
```

--------------------------------

### Visualizing Star-convex Sets

Source: https://yalmip.github.io/_posts/examples/2021-04-28-starshaped

Example script demonstrating the construction and plotting of star-convex sets with various transformations and vantage points.

```matlab
n = 6;
th = linspace(-pi, pi, 2*n+1);
xi = 1+(1+rem((1:2*n+1),3)).*cos(th).^3;
yi = 2+(1+rem((1:2*n+1),2)).*sin(th);
clf;
hold on;
grid on
plot( xi, yi, 'b*-' );
axis equal;

sdpvar x y
Model = starpolygon(xi,yi,[x;y],[],[],[1;2]);
plot(Model,[x;y],[],[],sdpsettings('plot.shade',.1))    

Model = starpolygon(xi,yi,[x;y],[],.25,[1;2]);
plot(Model,[x;y],'b')  

Model = starpolygon(xi,yi,[x;y],[],0.25,[1;1]);
plot(Model,[x;y],'g') 

Model = starpolygon(xi,yi,[x;y],[-4;0],[],[1;2]);
plot(Model,[x;y],'y')
```

--------------------------------

### Solve bilevel QP with manual dual bounds

Source: https://yalmip.github.io/_posts/commands/2016-09-17-kkt

Example of a bilevel program where dual bounds are manually added using the boundingbox operator.

```matlab
sdpvar x1 x2 y1 y2 y3

OO = -8*x1-4*x2+4*y1-40*y2-4*y3;
OO = OO+OO^2;
CO = [x1>=0, x2>=0];

OI = (x1+2*x2+y1+y2+2*y3)^2;
CI = [[y1 y2 y3] >= 0,
       -y1+y2+y3 <= 10,
      2*x1-y1+2*y2-0.5*y3 <= 10,
      2*x2+2*y1-y2-0.5*y3 <= 9.7];

[K,details] = kkt(CI,OI,[x1 x2])
optimize([K,CO,boundingbox([CI,CO]),details.dual<=100],OO)
```

--------------------------------

### Exporting a YALMIP model to AMPL

Source: https://yalmip.github.io/_posts/commands/2016-09-17-saveampl

Example demonstrating the conversion of a simple SDP model with integer constraints to an AMPL .mod file.

```matlab
x = sdpvar(3,1);
A = randn(5,3);
b = randn(5,1);
c = randn(3,1);
F = [A*x <= b, integer(x(2:3))];
saveampl(F,c'*x,'myamplmodel.mod');
```

--------------------------------

### Solve bilevel problem with default branching

Source: https://yalmip.github.io/_posts/commands/2016-09-17-solvebilevel

Example demonstrating the default branching strategy on a small bilevel problem.

```matlab
sdpvar x1 x2 y1 y2 y3

OO = -8*x1-4*x2+4*y1-40*y2-4*y3;
CO = [x1>=0, x2>=0];

OI = x1+2*x2+y1+y2+2*y3;
CI = [[y1 y2 y3] >= 0,
       -y1+y2+y3 <= 10,
      2*x1-y1+2*y2-0.5*y3 <= 10,
      2*x2+2*y1-y2-0.5*y3 <= 9.7];

solvebilevel(CO,OO,CI,OI,[y1 y2 y3])

>> value([y1 y2 y3])

ans =

         0    6.0000    4.0000

>> value([x1 x2])

ans =

         0    8.8500
```

--------------------------------

### Initialize Large SDP Constraint

Source: https://yalmip.github.io/_posts/commands/2016-09-17-dissect

Setup a large, low-bandwidth SDP constraint for dissection. Requires the MESHPART library.

```matlab
n = 500;
r = 3;
B = randn(n,r+1);
S = spdiags(B,0:r,n,n);S = S+S';
x = sdpvar(n,1);
X = diag(x)-S;
p = randperm(n);
X = X(p,p);
F = X >= 0
spy(F)
+++++++++++++++++++++++++++++++++++++++++++++++++++++
|   ID|      Constraint|                        Type|
+++++++++++++++++++++++++++++++++++++++++++++++++++++
|   #1|   Numeric value|   Matrix inequality 500x500|
+++++++++++++++++++++++++++++++++++++++++++++++++++++
```

--------------------------------

### Extracting SOS Decomposition

Source: https://yalmip.github.io/_posts/commands/2016-09-17-sosd

Example demonstrating solving an SOS problem and extracting the decomposition using sosd.

```matlab
x = sdpvar(1,1);
p = x^8+x^7+1;
F = sos(p);
solvesos(F);
sdisplay(sosd(F))
```

--------------------------------

### Restart solver from previous solution

Source: https://yalmip.github.io/warmstart

Re-runs the optimization using the values from the previous solve as the new starting point.

```matlab
optimize(Constraints,Objective,ops)
```

--------------------------------

### Create a linear programming optimizer

Source: https://yalmip.github.io/_posts/commands/2016-09-17-optimizer

Example of creating an optimizer object for a linear programming model with a scalar parameter.

```matlab
sdpvar a x
Constraints = [a+1 <= x];
Objective = x^2;
P = optimizer(Constraints,Objective,[],a,x)
Optimizer object with 1 inputs and 1 outputs. Solver: MOSEK-LP/QP
```

--------------------------------

### Derive KKT conditions for a parametric LP

Source: https://yalmip.github.io/_posts/commands/2016-09-17-kkt

Example showing the derivation of KKT conditions for a linear program with a cost function dependent on a parameter z.

```matlab
% min c(z)'*x s.t Ax<=b
A = randn(6,2);
b = rand(6,1);
c = rand(2,1);

x = sdpvar(2,1);
z = sdpvar(1);
c = c + randn(2,1)*z;

[Constraints,details] = kkt([A*x <= b, -1 <= z <= 1],c'*x,z);
```

--------------------------------

### Supply initial guess using usex0

Source: https://yalmip.github.io/warmstart

Assigns an initial value to the variable and enables the 'usex0' option to guide the solver.

```matlab
assign(x,0.5);
ops = sdpsettings('usex0',1);
optimize(Constraints,Objective,ops);
```

--------------------------------

### Failing example using standard zeros

Source: https://yalmip.github.io/_posts/commands/2018-06-12-zeros

Demonstrates a common approach that leads to NaN errors when assigning sdpvar objects to a standard zero matrix.

```matlab
y = sdpvar(1,1);
X = zeros(5,5);
X(1,5) = y;
```

--------------------------------

### yalmiptest

Source: https://yalmip.github.io/_posts/commands/2016-09-17-yalmiptest

Runs a set of test examples to verify the YALMIP installation. Can be called without arguments for default tests, or with specific tags or option structures to test individual solvers.

```APIDOC
## yalmiptest

### Description
Runs a set of test examples to test the YALMIP installation and solver integration.

### Syntax
`yalmiptest`
`yalmiptest(ops)`

### Parameters
- **ops** (string or struct) - Optional - A solver tag (e.g., 'sdpt3') or an options structure created via `sdpsettings` to test a specific solver configuration.

### Examples
Run default tests:
`yalmiptest`

Test a specific solver:
`yalmiptest('sdpt3')`

Test with specific settings:
`yalmiptest(sdpsettings('solver','sdpt3'))`
```

--------------------------------

### Invalid parameter assignment example

Source: https://yalmip.github.io/optimizerupdates

Example of an incorrect way to pass parameters that will not work.

```matlab
xoptimal = Saturation([a;b] == [1;3])
```

--------------------------------

### Numerical Instability Example

Source: https://yalmip.github.io/debuggingunbounded

Example of a model with poor numerical scaling that can lead to solver confusion.

```matlab
Model = [-1 <= [x y] <= 1, z <= 0]
Objective = x^2 + y*1e12+(z-1)^2*1e18;
optimize(Model,Objective)
```

--------------------------------

### Linear Optimization with SOS2 Approximation

Source: https://yalmip.github.io/_posts/commands/2016-09-30-interp2

Examples showing the creation of a grid, interpolation, and solving using both nonlinear and mixed-integer linear approaches.

```matlab
N = 40;
M = 40;
[xi,yi] = meshgrid(-1:2/(M-1):1,-1:2/(N-1):1);
zi = (xi).^4 + (yi).^4 + xi.*yi + sin(xi.*yi*4*pi).*(1 + xi + yi);
clf;mesh(xi,yi,zi)
```

```matlab
sdpvar x y z
z = interp2(xi,yi,zi,x,y,'spline');
optimize([],z)
value([x y z])
```

```matlab
z =  (x).^4 + (y).^4 + x.*y + sin(x.*y*4*pi).*(1 + x + y);
optimize([-1 <= [x y] <= 1],z)
value([x y z])
```

```matlab
z =  (x).^4 + (y).^4 + x.*y + sin(x.*y*4*pi).*(1 + x + y);
optimize([-1 <= [x y] <= 1],z,sdpsettings('solver','bmibnb'))
value([x y z])
```

```matlab
z = interp2(xi,yi,zi,x,y,'sos2');
optimize([],z)
value([x y z])
clf;mesh(xi,yi,zi);hold on
l = line([value(x) value(x)],[value(y) value(y)],[5 value(z)]);
set(l,'LineWidth',4)
```

```matlab
z =  (x).^4 + (y).^4 + x.*y + sin(x.*y*4*pi).*(1 + x + y);
optimize([-1 <= [x y] <= 1],z,sdpsettings('usex0',1))
value([x y z])
l = line([value(x) value(x)],[value(y) value(y)],[5 value(z)]);
set(l,'LineWidth',4,'Color','red');
```

--------------------------------

### Chebyball Usage Example

Source: https://yalmip.github.io/_posts/commands/2017-10-10-chebyball

Example demonstrating the definition of a box constraint and the calculation of its inscribed ball.

```MATLAB
sdpvar x y
Box = -1 <= [x y] <= 1;
[xc,r] = chebyball(Box);
plot(Box);
hold on
plot((x-xc(1)^2 + (y-xc(2))^2 <= r^2,[],'y')
```

--------------------------------

### Instantiate and sample from optimizer models

Source: https://yalmip.github.io/_posts/examples/2016-09-30-scenariosampling

Creates an optimizer with uncertain parameters and demonstrates manual instantiation versus automatic sampling.

```matlab
Model = [v'*x <= 1, uncertain(v,'unif',[-1;-1],[1;1])];
OneHyperPlaneModel = optimizer(Model, -sum(x),ops,v,x);
```

```matlab
model = OneHyperPlaneModel([-1;1],'nosolve');
```

```matlab
model = sample(OneHyperPlaneModel)
```

--------------------------------

### Sort Operator Usage Example

Source: https://yalmip.github.io/_posts/commands/2016-09-17-sort

Example of using the sort operator to constrain the sum of the largest and smallest elements of a decision variable.

```matlab
A = randn(20,5);
b = randn(20,1)*20;
x = sdpvar(5,1);

e = b-A*x;
[s,location] = sort(x);
F = [s(1)+s(end) == 1, -100 <= x <= 100];
optimize(F,norm(e,1));
```

--------------------------------

### Syntax for warmstart

Source: https://yalmip.github.io/_posts/commands/2022-06-21-warmstart

Basic syntax for the warmstart command.

```matlab
warmstart(X,Y)
```

--------------------------------

### Solve Regularized Problem

Source: https://yalmip.github.io/tutorial/nonlinearoperatorsgraphs

Example of combining norms for a regularized optimization problem.

```matlab
optimize([],1e-3*norm(a_hat,2)+norm(residuals,inf));
a_regLinf = value(a_hat)
```

--------------------------------

### Initialize integer variables and optimize

Source: https://yalmip.github.io/warmstart

Use the assign function to set initial values and enable warm-starting with the usex0 setting.

```matlab
assign(x,1);
assign(z,2);
optimize(Constraint,Objective, sdpsettings('usex0',1));
```

--------------------------------

### Set Up Problem Parameters

Source: https://yalmip.github.io/_posts/examples/2016-09-17-maxplus

Define the prediction horizon, initial conditions, and decision variables for the control input.

```matlab
N    = 8;
u0   = 0;
x0   = [0;0;10];
u    = sdpvar(N,1);
```

--------------------------------

### Define Linear Regression Problem

Source: https://yalmip.github.io/tutorial/nonlinearoperatorsgraphs

Setup for a linear regression problem with residuals.

```matlab
a = [1 2 3 4 5 6]';
t = (0:0.2:2*pi)';
x = [sin(t) sin(2*t) sin(3*t) sin(4*t) sin(5*t) sin(6*t)];
y = x*a+(-4+8*rand(length(x),1));
a_hat = sdpvar(6,1);
residuals = y-x*a_hat;
```

--------------------------------

### Define Polynomial Program

Source: https://yalmip.github.io/_posts/commands/2016-09-17-momentmodel

Setup of variables, constraints, and objective for a polynomial program.

```matlab
sdpvar x y
Con = [x^4 + y^4 + x*y <= 1];
Obj = x^2 +y^3;
```

--------------------------------

### Get yalmiperror syntax

Source: https://yalmip.github.io/_posts/commands/2016-09-17-yalmiperror

Basic syntax for retrieving an error description string.

```matlab
string = yalmiperror(n)
```

--------------------------------

### Configure First Step Constraints and Cost

Source: https://yalmip.github.io/_posts/examples/2016-09-17-explicitlpvmpc

Sets up the epigraph formulation for the infinity-norm and defines final state constraints for the first iteration step.

```matlab
% |x| written as max(a[x;u]+b)
a = [kron(eye(nx),[1 -1]') zeros(2*nx,nu)];
b = zeros(2*nx,1);
% |u| written as max(c[x;u]+d)
c = [zeros(2*nu,nx) kron(eye(nu),[1 -1]')];
d = zeros(2*nu,1);

% |x|+|u| written as max(aa[x;u]+bb)
aa = repmat(a,2*nu,1) + kron(c,ones(size(a,1),1));
bb = repmat(b,2*nu,1) + kron(d,ones(size(a,1),1));

% Final state constraints
F = [F, xmin  <= xp   <= xmax];

% Cost function
F   = [F, aa*[Q*(xp-xref);R*uth]+bb + norm(Q*(x{k}-xref),inf) <= w];
obj = w;
```

--------------------------------

### Unbounded Solver Output

Source: https://yalmip.github.io/debuggingunbounded

Example of YALMIP output indicating an unbounded objective function.

```text
    yalmipversion: '20210331'
    matlabversion: '9.9.0.1524771 (R2020b) Update 2'
       yalmiptime: 2.220583525175668e-01
       solvertime: 7.194164748243008e-02
             info: 'Unbounded objective function (learn to debug)(GUROBI-GUROBI)'
          problem: 2
```

--------------------------------

### warmstart(X, Y, [mode])

Source: https://yalmip.github.io/_posts/commands/2022-06-21-warmstart

Assigns values to sdpvar objects for initialization or warm-starting solvers.

```APIDOC
## warmstart(X, Y, [mode])

### Description
Assigns the value Y to the sdpvar object X. This is typically used to provide initial guesses for nonlinear solvers or to test feasibility of decision variables.

### Parameters
- **X** (sdpvar) - Required - The sdpvar object to assign values to.
- **Y** (numeric) - Required - The value to assign to the variable.
- **mode** (numeric) - Optional - If provided, performs a least squares assignment for inconsistent dimensions.
```

--------------------------------

### Maximize Box Volume

Source: https://yalmip.github.io/_posts/tutorials/2016-09-17-geometricprogramming

Example of maximizing the volume of a box under area and dimension constraints.

```MATLAB
sdpvar h w d

Awall  = 1;
Afloor = 1;

C = [0.5 <= h/w <= 2,  0.5 <= d/w <= 2, h>=0, w>=0];
C = [C, 2*(h*w+h*d) <= Awall, w*d <= Afloor];

optimize(C,-(h*w*d))
```

--------------------------------

### Warm-starting solvers with assign

Source: https://yalmip.github.io/_posts/commands/2016-09-17-assign

Using assign to provide an initial guess for a solver with usex0 enabled.

```matlab
x = sdpvar(1,1);
assign(x,pi);
optimize([sin(x)^2 <= .1],x,sdpsettings('usex0',1));
```

--------------------------------

### Test YALMIP solver performance

Source: https://yalmip.github.io/faq/itisslow

Run this command to benchmark solver detection and initialization time.

```matlab
yalmiptest(sdpsettings('verbose',0,'solver','sedumi'))
```

--------------------------------

### Initialize Model Constraints and Objective

Source: https://yalmip.github.io/_posts/examples/2016-09-17-unitcommitment

Construct the basic optimization model by iterating over the forecast horizon.

```matlab
Constraints = [];
Objective = 0;
for k = 1:Horizon
  Constraints = [Constraints, onoff(:,k).*Pmin <= P(:,k) <= onoff(:,k).*Pmax];
  Constraints = [Constraints, sum(P(:,k))+DemandSlack(k) >= Pforecast(k)];
  Constraints = [Constraints, DemandSlack(k) >= 0];
  Objective = Objective + P(:,k)'*Q*P(:,k) + C*P(:,k);
  Objective = Objective + DemandPenalty*DemandSlack(k);
end
```

--------------------------------

### Get variables syntax

Source: https://yalmip.github.io/_posts/commands/2018-08-17-getvariables

Basic syntax for retrieving internal indices of an sdpvar variable.

```matlab
k = getvariables(x)
```

--------------------------------

### Fully Automatic Parameterized System

Source: https://yalmip.github.io/_posts/examples/2016-09-17-lpvstatefeedback

Demonstrates parameterizing the system matrix directly using sdpvar.

```matlab
alpha = sdpvar(1);
A = Anomial;
Anominal(1,3) = alpha;
```

```matlab
alpha = sdpvar(1);
A = [0 1 alpha;0 0 1;0 0 0];
```

```matlab
F = [Y >=0];
F = [F, [-A*Y-B*L + (-A*Y-B*L)' Y L';Y inv(Q) zeros(3,1);L zeros(1,3) inv(R)] > 0]

F = [F, -0.1 <= alpha <= 0.1, uncertain(alpha)];

optimize(F,-trace(Y))

K = value(L)*inv(value(Y))
```

--------------------------------

### Initialize Binary Sudoku Model

Source: https://yalmip.github.io/_posts/examples/2016-09-17-sudoku

Sets up a 3D binary variable A(i,j,k) and basic row/column/value constraints.

```MATLAB
S = [0,0,1,9,0,0,0,0,8;6,0,0,0,8,5,0,3,0;0,0,7,0,6,0,1,0,0;...
     0,3,4,0,9,0,0,0,0;0,0,0,5,0,4,0,0,0;0,0,0,0,1,0,4,2,0;...
     0,0,5,0,7,0,9,0,0;0,1,0,8,4,0,0,0,7;7,0,0,0,0,9,2,0,0];

p = 3;
A = binvar(p^2,p^2,p^2,'full');
F = [sum(A,1) == 1, sum(A,2) == 1, sum(A,3) == 1];
```

--------------------------------

### Infeasible or Unbounded Solver Output

Source: https://yalmip.github.io/debuggingunbounded

Example of YALMIP output when the solver cannot distinguish between infeasibility and unboundedness.

```text
    yalmipversion: '20210331'
    matlabversion: '9.9.0.1524771 (R2020b) Update 2'
       yalmiptime: 2.220583525175668e-01
       solvertime: 7.194164748243008e-02
             info: 'Either infeasible or unbounded (learn to debug)(GUROBI-GUROBI)'
          problem: 12
```

--------------------------------

### Solve mixed-integer semidefinite programs

Source: https://yalmip.github.io/_posts/tutorials/2016-09-17-integerprogramming

Example of using BNB to solve problems with semidefinite constraints.

```matlab
F = [toeplitz(x_hat) > 0];
optimize(F,residuals'*residuals);
x_L2_toep = value(x_hat);
```

--------------------------------

### Apply complements to linear constraints

Source: https://yalmip.github.io/_posts/commands/2017-04-21-complements

Example demonstrating the application of complementarity constraints to linear expressions.

```matlab
sdpvar x y z
F = complements(y >= 0, x+z >= 1)
```

--------------------------------

### Automate dualization with sdpsettings

Source: https://yalmip.github.io/tutorial/automaticdualization

Use the 'dualize' option in sdpsettings to have YALMIP automatically handle dualization, solving, and variable recovery.

```matlab
optimize(F,obj,sdpsettings('dualize',1));
value(t)
ans =
   -1.9099
    0.7358
```

--------------------------------

### Warm-starting a model with sumk operator

Source: https://yalmip.github.io/warmstart

Demonstrates an optimization attempt where an initial guess for x is provided, but auxiliary variables created by the sumk operator may not inherit the assignment.

```matlab
x = sdpvar(3,1);
Constraint = [sumk(x,2) <= 1];
Objective = sum(1./x);
assign(x,.5);
optimize(Constraint,Objective,sdpsettings('usex0',1))
```

--------------------------------

### Plotting a p-norm constraint

Source: https://yalmip.github.io/_posts/commands/2016-09-16-pnorm

Example demonstrating the visualization of a p-norm constraint using the plot function.

```matlab
x = sdpvar(2,1);
plot(pnorm(x,7/2) <= 1);
```

--------------------------------

### Generalizing partial instantiation to multiple variables

Source: https://yalmip.github.io/optimizerupdates

Illustrates partial instantiation with multiple variables using curly brace syntax.

```MATLAB
sdpvar c d
ops = sdpsettings('solver','mosek');
Saturation = optimizer([-a - c - d <= x <= a + c + d], Objective,ops, { a , b , [c;d]}, x)
Saturation_fixed_ac = Saturation{[a == 1, [c;d] == 0]};
Saturation_fixed_ac = Saturation{1,[],[0;0]};
xoptimal = Saturation_fixed_ac{3}
```

--------------------------------

### Define Uncertain Optimization Problem

Source: https://yalmip.github.io/_posts/commands/2016-09-17-robustmodel

Setup for an optimization problem involving an uncertain variable w.

```MATLAB
sdpvar x w
F = [x+w <= 1];
W = [uncertain(w),-0.5 <= w <= 0.5];
objective = -x;
```

--------------------------------

### Optimize over K and P

Source: https://yalmip.github.io/badsdps

Demonstrates the progression from a naive cubic model to a linear model using variable substitution.

```MATLAB
K = sdpvar(1,2);
P = sdpvar(2);
A = [-1 2;2 -3];
B = [1;1];
MyLMI = [ (A + B*K)'*P*(A + B*K) - P <= 0];
optimize(MyLMI)
```

```MATLAB
K = sdpvar(1,2);
P = sdpvar(2);
A = [-1 2;2 -3];
B = [1;1];
MyLMI = [ [P (A + B*K)';(A + B*K) inv(P)] >= 0];
optimize(MyLMI)
```

```MATLAB
K = sdpvar(1,2);
P = sdpvar(2);
A = [-1 2;2 -3];
B = [1;1];
MyLMI = [ [inv(P) inv(P)*(A + B*K)';(A + B*K)*inv(P) inv(P)] >= 0];
optimize(MyLMI)
```

```MATLAB
Y = sdpvar(1,2);
Q = sdpvar(2);
A = [-1 2;2 -3];
B = [1;1];
MyLMI = [ [Q (A*Q + B*Y)';(A*Q + B*Y) Q] >= 0];
optimize(MyLMI)
K = value(Y)*inv(value(Q))
```

--------------------------------

### Verify YALMIP installation

Source: https://yalmip.github.io/_posts/tutorials/2016-09-17-installation

Commands to test if YALMIP is functioning and to debug specific solver issues.

```matlab
% Does YALMIP work at all? If not, we might not even be able to create a variable
x = sdpvar(1)

% Can any solver be called?
optimize(x>= 0, x,sdpsettings('debug',1))

% Problems with a specific solver?
optimize(x>= 0, x,sdpsettings('debug',1,'solver','thissolver'))
```

--------------------------------

### Define sdpsettings Syntax

Source: https://yalmip.github.io/_posts/commands/2016-09-17-sdpsettings

General syntax for creating an options structure and passing it to an optimization command.

```matlab
options = sdpsettings('field',value,'field',value,...)
optimize(Constraints, Objective, options)
```

--------------------------------

### Create Options Structure

Source: https://yalmip.github.io/_posts/commands/2016-09-17-sdpsettings

Initialize an options structure with specific solver and verbosity settings.

```matlab
ops = sdpsettings('solver','mosek','verbose',1,'debug',1)
```

--------------------------------

### Initialize Simulation History

Source: https://yalmip.github.io/_posts/examples/2016-09-17-unitcommitment

Set the initial state of the plant history before starting the simulation loop.

```matlab
oldOnOff = repmat([1;1;0],1,Nhist);
oldP = repmat([100;40;0],1,Nhist);
```

--------------------------------

### Export SDP problem to ASCII file

Source: https://yalmip.github.io/_posts/commands/2016-09-17-savesdpafile

Demonstrates creating a basic SDP problem and exporting it to a file named 'mysdpamodel'.

```matlab
A = randn(3,3);
P = sdpvar(3,3);
F = [P>=0, A'*P+P*A <= -eye(3)];
savesdpafile(F,trace(P),'mysdpamodel');
```

--------------------------------

### Handling Bad Input Data

Source: https://yalmip.github.io/naninmodel

Example of how invalid mathematical operations in model construction lead to NaNs.

```MATLAB
woops = sin(0);
Model = [x <= 1/woops-1/woops^2];
```

--------------------------------

### Define initial variables and constraints

Source: https://yalmip.github.io/_posts/examples/2017-09-16-approximatingqp

Initialize the problem variables and define the basic constraints for the quadratic program.

```matlab
n = 10;
x = sdpvar(n,1);
y = sdpvar(n,1);
Q = randn(n);Q = Q*Q';
R = randn(n);R = R*R';
Model = [-1 <= [x y] <= 1, sum(x) + sum(y) == 1];
```

--------------------------------

### Invalid Uncertainty Set Definition

Source: https://yalmip.github.io/_posts/commands/2016-09-17-optimizer

Example of an unsupported configuration where uncertainty set geometry depends on parameters.

```matlab
sdpvar t U w
P = optimizer([uncertain(w), -U <= w <= U , b*w <= t],t,[],U,t)
```

--------------------------------

### Define target function and grid

Source: https://yalmip.github.io/_posts/commands/2016-09-30-interp1

Sets up the target function q(x) and the evaluation grid x.

```matlab
q = @(x)x.^2+min(0,8*x);
x = -0.5:0.05:1;
```

--------------------------------

### Inspect Default Options

Source: https://yalmip.github.io/_posts/commands/2016-09-17-sdpsettings

Display the default options structure and inspect specific solver settings.

```matlab
ops = sdpsettings;

ops
               solver: ''
              verbose: 1
              warning: 1
         cachesolvers: 0
                debug: 1
        beeponproblem: [-5 -4 -3 -2 -1]
         showprogress: 0
            saveduals: 1
     removeequalities: 0
     savesolveroutput: 0
      savesolverinput: 0
    convertconvexquad: 1
               radius: Inf
                relax: 0
                usex0: 0             
            savedebug: 0
                  sos: [1x1 struct]
               moment: [1x1 struct]
                  bnb: [1x1 struct]                
               bmibnb: [1x1 struct]
               cutsdp: [1x1 struct]
               global: [1x1 struct]
                  cdd: [1x1 struct]
                  clp: [1x1 struct]
                cplex: [1x1 struct]
                 csdp: [1x1 struct]
                 dsdp: [1x1 struct]
                 glpk: [1x1 struct]                 
               lmilab: [1x1 struct]
              lmirank: [1x1 struct]
              lpsolve: [1x1 struct]
               maxdet: [1x1 struct]                  
               penbmi: [1x1 struct]
               pennlp: [1x1 struct]
               pensdp: [1x1 struct]
                 sdpa: [1x1 struct]
                sdplr: [1x1 struct]
                sdpt3: [1x1 struct]
               sedumi: [1x1 struct]
                qsopt: [1x1 struct]
               xpress: [1x1 struct]
             quadprog: [1x1 struct]
              linprog: [1x1 struct]             
              fmincon: [1x1 struct]
           fminsearch: [1x1 struct]

ops.sedumi

ans = 

          alg: 2
         beta: 0.5000
        theta: 0.2500
         free: 1
          sdp: 0
      stepdif: 0
            w: [1 1]
           mu: 1
          eps: 1.0000e-09
       bigeps: 1.0000e-03
      maxiter: 150
        vplot: 0
       stopat: -1
         denq: 0.7500
         denf: 10
       numtol: 5.0000e-07
    bignumtol: 0.9000
      numlvlv: 0
         chol: [1x1 struct]
           cg: [1x1 struct]
    maxradius: Inf
```

--------------------------------

### Initialize Decision Variables

Source: https://yalmip.github.io/_posts/examples/2016-09-17-unitcommitment

Creates binary variables for plant status and continuous variables for power output.

```matlab
onoff = binvar(Nunits,Horizon,'full');
P     = sdpvar(Nunits,Horizon,'full');
```

--------------------------------

### Solve SOS Problem and Extract Decomposition

Source: https://yalmip.github.io/_posts/commands/2016-09-17-sos

Example demonstrating the definition, solving, and display of a sum-of-squares decomposition.

```matlab
x = sdpvar(1,1);
p = x^8+x^7+1;
F = sos(p);
solvesos(F);
sdisplay(sosd(F))
ans =
    '0.12828-0.062411x+0.12427x^2-0.49555x^3-0.99602x^4'
    '0.99174+0.008073x-0.018071x^2+0.072068x^3+0.089115x^4'
```

--------------------------------

### Solve a linear program

Source: https://yalmip.github.io/_posts/commands/2016-09-17-optimize

Example of defining variables, constraints, and an objective function to solve a linear program.

```matlab
x = sdpvar(length(c),1);
F = [A*x<=b];
h = c'*x;
optimize(F,h);
solution = value(x);
```

--------------------------------

### Complete Optimization Workflow

Source: https://yalmip.github.io/_posts/tutorials/2016-09-17-basics

Demonstrates the full cycle of clearing the database, defining variables, constraints, and objectives, solving, and analyzing results.

```matlab
% It's good practice to start by clearing YALMIPs internal database 
% Every time you call sdpvar etc, an internal database grows larger
yalmip('clear')

% Define variables
x = sdpvar(10,1);

% Define constraints 
Constraints = [sum(x) <= 10, x(1) == 0, 0.5 <= x(2) <= 1.5];
for i = 1 : 7
  Constraints = [Constraints, x(i) + x(i+1) <= x(i+2) + x(i+3)];
end

% Define an objective
Objective = x'*x+norm(x,1);

% Set some options for YALMIP and solver
options = sdpsettings('verbose',1,'solver','quadprog','quadprog.maxiter',100);

% Solve the problem
sol = optimize(Constraints,Objective,options);

% Analyze error flags
if sol.problem == 0
 % Extract and display value
 solution = value(x)
else
 display('Hmm, something went wrong!');
 sol.info
 yalmiperror(sol.problem)
end
```

--------------------------------

### Plotting a TV-screen with cpower

Source: https://yalmip.github.io/_posts/commands/2016-09-17-cpower

Example demonstrating the use of cpower to define a constraint for plotting a TV-screen shape.

```matlab
x = sdpvar(2,1);
plot(sum(cpower(x,4)) <= 1);
```

--------------------------------

### Configure REFINER with standard solver

Source: https://yalmip.github.io/_posts/solvers/2016-06-21-refiner

Sets up a linear program using REFINER with an internal solver like SeDuMi.

```matlab
A = rand(15,5);
x = sdpvar(5,1);
b = rand(15,1);
ops = sdpsettings('solver', 'refiner', 'verbose', 1);
ops = sdpsettings(ops,'refiner.precdigits', 14, 'refiner.internalsolver', 'sedumi');
ops = sdpsettings(ops,'sedumi.eps', 1e-5);
optimize([A*x>=b], sum(x), ops)    
```

--------------------------------

### Check constraint satisfaction after optimization

Source: https://yalmip.github.io/_posts/commands/2016-09-17-check

Example demonstrating how to evaluate constraint residuals after calling the optimize function.

```matlab
x = sdpvar(2,1);
F = [-1 <= x <= 1];
optimize(F,sum(x));
check(F)
```

--------------------------------

### Specify a solver with options

Source: https://yalmip.github.io/_posts/commands/2016-09-17-optimize

Using sdpsettings to configure a specific solver for the optimization problem.

```matlab
options = sdpsettings('solver','quadprog')
optimize(F,[],options);
```

--------------------------------

### Usage of alldifferent with integer variables

Source: https://yalmip.github.io/_posts/commands/2016-09-17-alldifferent

Example demonstrating the use of alldifferent on an integer vector with defined bounds.

```MATLAB
x = intvar(5,1);
F = [alldifferent(x), 1<=x<=5];
optimize(F)
value(x)
```

--------------------------------

### Define Primal SDP Problem

Source: https://yalmip.github.io/_posts/commands/2016-09-17-dualize

Setup of a primal SDP problem using sdpvar variables and constraints.

```matlab
X = sdpvar(3,3);
Y = sdpvar(3,3);
F = [X>=0, Y>=0];
F = [F, X(1,3)==9, Y(1,1)==X(2,2)];
F = [F,sum(sum(X))+sum(sum(Y)) == 20];
obj = trace(X)+trace(Y);
```

--------------------------------

### Automated YALMIP installation script

Source: https://yalmip.github.io/_posts/tutorials/2016-09-17-installation

A script to download, unzip, and add YALMIP to the MATLAB path automatically.

```matlab
cd YALMIPfolderShouldbeHere
urlwrite('https://github.com/yalmip/yalmip/archive/master.zip','yalmip.zip');
unzip('yalmip.zip','yalmip')
addpath(genpath([pwd filesep 'yalmip']));
savepath
```

--------------------------------

### Model with Infeasible Fixed Constraint

Source: https://yalmip.github.io/fixedconstraints

Example of an infeasible model resulting from fixed parameters, which triggers an error in YALMIP.

```matlab
Constraints = [x-1 >= 0, -1 >= 0]
optimize(F,obj)
```

--------------------------------

### Implement robust optimization problems

Source: https://yalmip.github.io/_posts/commands/2016-09-17-uncertain

Examples of defining robust optimization problems using uncertain variables and constraints.

```matlab
sdpvar x w
F = [x+w <= 1];
W = [-0.5 <= w <= 0.5, uncertain(w)];
objective = -x;
optimize([F, W],objective)
```

```matlab
F = [x+w <= 1];
W = [uncertain(-0.5 <= w <= 0.5)];
objective = -x;
optimize([F, W],objective)
```
Tokens:
Raw