YALMIP supports complex-valued constraints for all solvers by automatically converting complex-valued problems to real-valued problems.

To begin with, let us just define a simple linear complex problem to illustrate how complex variables and constraints are generated and interpreted.

p = sdpvar(1,1,'full','complex');      % A complex scalar (4 arguments necessary)
s = sdpvar(1,1)+sqrt(-1)*sdpvar(1,1);  % Alternative definition
F = [0.9 >= imag(p)];                  % Imaginary part constrained
F = [F, 0.01 >= real(p)];              % Real part constrained
F = [F, 0.1+0.5*sqrt(-1) >= p];        % Both parts constrained
F = [F, s+p == 2+4*sqrt(-1)];          % Both parts constrained


To see how complex-valued constraints can be used in a more advanced setting, we solve the covariance estimation problem from the sedumi manual. The problem is to find a positive-definite Hermitian Toeplitz matrix Z such that the Frobenious norm of P-Z is minimized (P is a given complex matrix.)

The matrix P is

P = [4 1+2*i 3-i;1-2*i 3.5 0.8+2.3*i;3+i 0.8-2.3*i 4];


We define a complex-valued Toeplitz matrix of the corresponding dimension

Z = sdpvar(3,3,'toeplitz','complex')


A complex Toeplitz matrix is not Hermitian, but we can make it Hermitian if we remove the imaginary part on the diagonal.

Z = Z-diag(imag(diag(Z)))*sqrt(-1);


Minimizing the Frobenious norm of P-Z can be cast as minimizing the Euclidean norm of the vectorized difference P(:)-Z(:). By using a Schur complement, we see that this can be written as the following SDP.

e = P(:)-Z(:)
t = sdpvar(1,1);
F = [Z>=0];
F = [F, [t e';e eye(9)]>=0];
optimize(F,t);


The problem can be implemented more efficiently using a second order cone constraint.

e = Z(:)-P(:)
t = sdpvar(1,1);
F = [Z>=0];
F = [F, cone(e,t)];
optimize(F,t);


…with a second order cone constraint that we let YALMIP model automatically

e = Z(:)-P(:)
F = [Z>=0];
optimize(F,norm(e,2));


…or by using a quadratic objective function

e = Z(:)-P(:)
F = [Z>=0];
optimize(F,e'*e);


…or by simply using the nonlinear operator framework which supports matrix norms

F = [Z>=0];
optimize(F,norm(P-Z,'fro'));