newcompileinterfacedata.m

国外专家做的求解LMI鲁棒控制的工具箱,可以相对高效的解决LMI问题

if  ~options.relax &(~isempty(quad_info) & solver.qp==0 | (~isempty(quad_info) & strcmp(solver.tag,'bnb') & localsolver.qp==0))
   t = sdpvar(1,1);
   x = quad_info.x;
   R = quad_info.R;
   c = quad_info.c;
   f = quad_info.f;
   F = F + lmi(cone([2*R*x;1-(t-c'*x-f)],1+t-c'*x-f));
   h = t;
   quad_info = [];
end
%if solver.rotsocp == 0
if solver.constraint.inequalities.rotatedsecondordercone == 0    
    [F,changed] = convertlorentz(F);
    if changed
        options.saveduals = 0; % We cannot calculate duals since we change the problem
    end
end
% Whoa, horrible tests to find out when to convert SOCP to SDP
% This should not be done if :
%   1. Problem is actually a QCQP and solver supports this
%   2. Problem is integer, local solver supports SOCC
%   3. Solver supports SOCC

if ~((solver.qc == 1) & socp_are_really_qc)
    if ~(strcmp(solver.tag,'bnb') & socp_are_really_qc & localsolver.qc==1 )
        if ((solver.socp == 0) | (strcmp(solver.tag,'bnb') & localsolver.socp==0)) 
            [F,changed] = convertsocp(F);
            if changed
                options.saveduals = 0; % We cannot calculate duals since we change the problem
            end
        end
    end
end

if ((solver.complex==0) & ismember('DX',ProblemString)) | ((strcmp(solver.tag,'bnb') & localsolver.complex==0) & ismember('DX',ProblemString))
    showprogress('Converting to real constraints',options.showprogress)
    F = imag2reallmi(F);
    options.saveduals = 0; % We cannot calculate duals since we change the problem
end

% **********************************************
% CREATE OBJECTIVE FUNCTION c'*x+x'*Q*x
% **********************************************
showprogress('Processing objective h(x)',options.showprogress);
try
    [c,Q,f,onlyfeasible]=createobjective(h,G,options,quad_info);
catch
    error(lasterr)
end

% **********************************************
% Convert {F(x),G(x)} to internal formats 
% **********************************************
showprogress('Processing F(x)',options.showprogress);
[F_struc,K,KCut] = lmi2sedumistruct(F);
K.m = length(sdpvar(G));

% **********************************************
% SOME HORRIBLE CODE TO DETERMINE USED VARIABLES
% **********************************************
% Which sdpvar variables are actually in the problem
used_variables_LMI = find(any(F_struc(:,2:end),1));
used_variables_obj = find(any(c',1) | any(Q));
used_variables = uniquestripped([used_variables_LMI used_variables_obj]);
% The problem is that linear terms might be missing
monomtable = yalmip('monomtable');
if options.relax
    monomtable = [];
    nonlinearvariables = [];
else
    nonlinearvariables = find(~(sum(monomtable~=0,2)==1 & sum(monomtable,2)==1));
end
linearvariables = setdiff(used_variables,nonlinearvariables);
needednonlinear = nonlinearvariables(ismember(nonlinearvariables,used_variables));
linearinnonlinear = find(any(full(monomtable(needednonlinear,:)),1));

missinglinear = setdiff(linearinnonlinear(:),linearvariables);
used_variables = unique(sort([used_variables(:);missinglinear(:)])');

% Check for unbounded variables
if 0%isempty(sqrList) WHY did I remove these
    unbounded_variables = setdiff(used_variables_obj,used_variables_LMI);
    if ~isempty(unbounded_variables)
        % Remove unbounded variable from problem
        used_variables = setdiff(used_variables,unbounded_variables);
    end
end

% ****************************************
% REMOVE UNNECESSARY VARIABLES FROM PROBLEM
% ****************************************
if length(used_variables)<sdpvar('nvars')
    c = c(used_variables);
    Q = Q(:,used_variables);Q = Q(used_variables,:);
    if ~isempty(F_struc)
        F_struc = sparse(F_struc(:,[1 1+used_variables]));
    end
end

% ****************************************
% Map variables and constraints in low-rank definition to local stuff
% ****************************************
if ~isempty(lowrankdetails)
    % Identifiers of the SDP constraints
    lmiid = getlmiid(F);
    %lmiid = find(ismember(lmiid(is(F,'sdp'),);
    for i = 1:length(lowrankdetails)
        lowrankdetails{i}.id = find(ismember(lmiid,lowrankdetails{i}.id));
        if ~isempty(lowrankdetails{i}.variables)
            lowrankdetails{i}.variables = find(ismember(used_variables,lowrankdetails{i}.variables));
        end
    end
end

% ****************************************
% SPECIAL VARIABLES
% ****************************************
if options.relax
    nonlins = [];
end

if options.relax
    integer_variables = [];
    binary_variables  = [];
else
    integer_variables = find(ismember(used_variables,integer_variables));
    binary_variables  = find(ismember(used_variables,binary_variables));
end
parametric_variables  = find(ismember(used_variables,parametric_variables));
extended_variables =  find(ismember(used_variables,yalmip('extvariables')));

if (K.f>0) 
    % If user explicitely says remove, or user says nothing but solverdefinitions does
    % FIX : CHECK FOR NONLINEARS
    if ((options.removeequalities==1) & isempty(intersect(used_variables,nonlinearvariables))) | ((options.removeequalities==0) & (solver.equalities==-1))
        showprogress('Solving equalities',options.showprogress);   
        [x_equ,H,A_equ,b_equ] = solveequalities(F_struc,K);
        % Exit if no consistent solution exist
        if (norm(A_equ*x_equ-b_equ)>10)%sqrt(eps)*size(A_equ,2))            
            diagnostic.solvertime = 0;
            diagnostic.info = yalmiperror(1,'YALMIP');
            diagnostic.problem = 0;
            solution = diagnostic;
            solution.variables = used_variables(:);
            solution.optvar = x_equ;
            % And we are done! Save the result
            sdpvar('setSolution',solution);
            return
        end
        % We dont need the rows for equalities anymore
        F_struc = F_struc(K.f+1:end,:);
        K.f = 0;
        Fold = F;
        [nlmi neq]=size(F);
        F = lmi;
        for i = 1:nlmi+neq
            if ~is(Fold(i),'equality')
                F = F + Fold(i);
            end
        end
        
        % No variables left!
        if size(H,2)==0            
            diagnostic.solvertime = 0;
            diagnostic.info = yalmiperror(0,'YALMIP');
            diagnostic.problem = 0;
            solution = diagnostic;
            solution.variables = used_variables(:);
            solution.optvar = x_equ;
            % And we are done! Save the result
            % Note, no dual is saved        
            sdpvar('setSolution',solution);
            p = checkset(F);
            if any(p<1e-5)
                diagnostic.info = yalmiperror(1,'YALMIP');
                diagnostic.problem = 1;
            end
            return
        end
        showprogress('Converting problem to new basis',options.showprogress)
        % objective in new basis
        c = H'*c;
        Q = H'*Q*H;
        % LMI in new basis
        F_struc = [F_struc*[1;x_equ] F_struc(:,2:end)*H];    
    else
        % Solver does not support equality constraints
        % and they hould be removed using double-sided
        % or user just want to remove them
         if (solver.equalities==0 | options.removeequalities==2)
            % Add equalities
            F_struc = [-F_struc(1:1:K.f,:);F_struc];
            K.l = K.l+K.f*2;
            % Keep this in mind...
            K.fold = K.f;   
            K.f = 0;
        end
        % For simpliciy we introduce a dummy coordinate change
        x_equ = 0;
        H     = 1;
    end
else
    x_equ = 0;
    H     = 1;
end    


% **************************************************
% INITIAL SOLUTION
% **************************************************
x0 = [];
if options.usex0
    x0_used = double(recover(used_variables));
    x0 = zeros(sdpvar('nvars'),1);
    x0(used_variables)  = x0_used(:);   
    x0(isnan(x0))=0;
end

if ~isempty(x0)
    % Get a coordinate in the reduced space
    x0 = H\(x0(used_variables)-x_equ);
end

solveroutput = [];


% Monomial table for nonlinear variables
% FIX : Why here!!! mt handled above also
mt = yalmip('monomtable');
if size(mt,1)>size(mt,2)
    mt(size(mt,1),size(mt,1)) = 0;
end
% In local variables
mt = mt(used_variables,used_variables);
if options.relax
    mt = eye(length(used_variables));
end

% ********************************
% GENERAL DATA EXCANGE WITH SOLVER
% ********************************
interfacedata.F_struc = F_struc;
interfacedata.c = c;
interfacedata.Q = Q;
interfacedata.f = f;
interfacedata.K = K;
interfacedata.KCut = KCut;
interfacedata.integer_variables = integer_variables;
interfacedata.binary_variables  = binary_variables;
interfacedata.parametric_variables  = parametric_variables;
interfacedata.extended_variables    = extended_variables;
interfacedata.options = options;
interfacedata.solver = solver;
interfacedata.monomtable = mt;
interfacedata.x0 = x0;
interfacedata.solver = solver;
interfacedata.lb = [];
interfacedata.ub = [];
interfacedata.lowrankdetails = lowrankdetails;

% ********************************
% GENERAL DATA EXCANGE SOLUTION
% ********************************
recoverdata.H = H;
recoverdata.x_equ = x_equ;
recoverdata.used_variables = used_variables;