Robotics
/
Dynamic-Calibration
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Dynamic-Calibration/utils/YALMIP-master/modules/robust/decomposeUncertain.m

631 lines
25 KiB
Matlab
Executable File
Raw Blame History

function [UncertainModel,Uncertainty,VariableType,ops,failure] = decomposeUncertain(F,h,w,ops)
failure = 0;
% Do we have any uncertainty declarations variables?
[F,w] = extractUncertain(F,w);
if isempty(w)
error('There is no uncertainty in the model.');
end
% Partition the model into
% F_x : Constraints in decision variables only
% F_w : The uncertainty description
% F_xw : The uncertain constraints
% Note that this analysis might also declare som of the auxiliary variables
% as simple uncertain variables. It might also create a new objective
% function in order to have all uncertainty in the constraints
F_original = F;
[VariableType,F_x,F_w,F_xw,h] = robust_classify_variables_newest(F,h,ops,w);
if length(F_w)==0
error('There is no uncertainty description in the model.');
end
if ops.verbose
dispsilent(ops.verbose,'***** Starting YALMIP robustification module. *********************');
if length(w)<length(VariableType.w_variables)
dispsilent(ops.verbose,[' - Detected ' num2str(length(VariableType.w_variables)) ' uncertain variables (' num2str(length(VariableType.w_variables)-length(w)) ' artificial)']);
else
dispsilent(ops.verbose,[' - Detected ' num2str(length(w)) ' uncertain variables']);
end
end
% Integer variables are OK in x, but not in the uncertainty
integervars = [yalmip('binvariables') yalmip('intvariables')];
ind = find(is(F_original,'integer') | is(F_original,'binary'));
if ~isempty(ind)
integervars = [integervars getvariables(F(ind))];
if any(ismember(VariableType.w_variables,integervars))
failure = 1;
return
end
end
% Convert quadratic constraints in uncertainty model to SOCPs. This will
% enable us to use duality based removal of uncertainties in linear
% inequalities. We keep information about quadratic expression though, in
% order to use them if possible in 2-norm explicit maximization
F_w = convertquadratics(F_w);
% Convert quadratic constraints in uncertain model to SOCPs. This will
% enable us to use conic/conic robustification
F_xw = convertquadratics(F_xw);
% Export uncertainty model to numerical format
ops.solver = '';
ops.removeequalities = 0;
[aux1,aux2,aux3,Zmodel] = export(F_w-F_w(find(is(F_w,'uncertain'))),[],ops,[],[],1);
if ~isempty(Zmodel)
if length(Zmodel.c) ~= length(VariableType.w_variables)
error('Some uncertain variables are unconstrained.')
end
else
error('Failed when exporting a model of the uncertainty.')
end
% The uncertainty model is in the full w-space. However, it might
% happen that the uncertainty is separable. Find groups of uncertain
% variables that can/should be treated separately.
uncertaintyGroups = findSeparate(Zmodel);
if ops.verbose
dispsilent(ops.verbose,[' - Detected ' num2str(length(uncertaintyGroups)) ' independent group(s) of uncertain variables']);
end
% Trying to take care of cases such as norm([x+w;x-w]), i.e. epigraphs with
% uncertainty.
%[F_xw,ops] = prepareforAuxiliaryRemoval(VariableType,F_xw,F_w,ops);
x = recover(VariableType.x_variables);
w = recover(VariableType.w_variables);
ops.robust.forced_enumeration = 0;
switch ops.robust.auxreduce
case {'none','affine','','projection','enumeration'}
otherwise
disp(' ');
dispsilent(ops.verbose,['The flag ''auxreduce'' is wrong. Turning off removal of auxilliary variables']);
disp(' ');
ops.robust.auxreduce = 'none';
end
if ~isempty(VariableType.aux_with_w_dependence)
if ~strcmp('none',ops.robust.auxreduce)
dispsilent(ops.verbose,[' - Detected ' num2str(length(VariableType.aux_with_w_dependence)) ' uncertainty dependent auxilliary variables']);
end
if strcmp('none',ops.robust.auxreduce)
dispsilent(ops.verbose,[' - Using possibly conservative approach to deal with uncertainty dependent auxilliary variables.']);
dispsilent(ops.verbose,[' - (change robust.auxreduce to ''projection'', ''enumeration'' for exact solution.)'])
VariableType.x_variables = unique([VariableType.aux_with_w_dependence(:)' VariableType.x_variables(:)']);
elseif strcmp('affine',ops.robust.auxreduce)
% Add linear feedback on all uncertainty dependent auxilliary
% variables. The new model is dealt with as usual
dispsilent(ops.verbose,[' - Adding affine feedback on auxilliary variables.'])
[F_xw,xnew,info] = adjustable(F_xw,w,unique(VariableType.aux_with_w_dependence),uncertaintyGroups,ops,VariableType);
dispsilent(ops.verbose,[' - Feedback structure had sparsity ' num2str(info.sparsity) ' and required ' num2str(info.nvars) ' variable(s)'])
%xnew = [];
VariableType.x_variables = unique([VariableType.aux_with_w_dependence(:)' VariableType.x_variables(:)' getvariables(xnew)]);
elseif strcmp('enumeration',ops.robust.auxreduce)
% Uncertainty model is polytopic, hence enumeration can be used.
if isequal(Zmodel.K.s,0) & isequal(Zmodel.K.q,0)
dispsilent(ops.verbose,[' - Using enumeration to deal with uncertainty dependent auxilliary variables']);
ops.robust.lplp = 'enumeration';
else
disp([' - Cannot robustify model exactly with uncertainty dependent auxilliary variables and conic uncertainty']);
disp([' - Change the option robust.auxreduce to ''projection'', ''affine'' or ''none''.'])
error('robustification failed');
end
% User wants to do enumeration based removal of auxilliary
% variables, hence we cannot switch later
ops.robust.forced_enumeration = 1;
elseif ~(any(is(F_xw,'sdp')) | any(is(F_xw,'socp'))) | ~isempty(strfind('projection',ops.robust.auxreduce))
if isequal(ops.robust.auxreduce,'projection')
dispsilent(ops.verbose,[' - Projecting out auxilliary variables. This can take time...']);
end
F_xw = projectOut(F_xw,w,unique(VariableType.aux_with_w_dependence),uncertaintyGroups,ops);
else
dispsilent(ops.verbose,[' - Cannot robustify model exactly with uncertainty dependent auxilliary variables and conic uncertainty']);
dispsilent(ops.verbose,[' - Change the option robust.auxreduce to ''affine'' or ''none'' to compute conservative solution'])
error('robustification failed');
end
end
% Separate the uncertainty models accroding to uncertainty groups
separatedZmodel = separateUncertainty(Zmodel,uncertaintyGroups);
% Conversion of bounded variables that have been modelled using
% the norm operator (remove the epigraph variable to ensure explicit
% maximization is used). This will be generalized in the next version
[separatedZmodel, uncertaintyGroups] = convertUncertaintyGroups(separatedZmodel,uncertaintyGroups,VariableType);
% Code will be added to detect uncertainty cases in a more general and
% modular way. Additional code will also be added to find hidden simple
% structures, such as norm(w,1)<1, which currently is treated as a general
% polytopic uncertainty, since the expansion hides the simplicity
% 'Bounds', 'Simplex', 'Conic', 'Polytopic', '2-norm', '1-norm', 'inf-norm'
[uncertaintyTypes,separatedZmodel,uncertaintyGroups] = classifyUncertainty(separatedZmodel,uncertaintyGroups,w);
% Misplaced constraints. Really isn't uncertain, but when we expanded an
% uncertain operator, a new auxilliary variable was introduced, but has not
% made dependent on w. Hewnce, it should really be moved. Taken care
% outside now though
% if length(F_xw)>0
% move = zeros(length(F_xw),1);
% for i = 1:length(F_xw)
% if all(ismember(getvariables(F_xw(i)),VariableType.x_variables))
% move(i) = 1;
% end
% end
% if any(move)
% F_x = [F_x, F_xw(find(move))];
% F_xw(find(move))=[];
% end
% end
UncertainModel.F_x = F_x;
UncertainModel.F_xw = F_xw;
UncertainModel.h = h;
Uncertainty.F_w = F_w;
Uncertainty.Zmodel = Zmodel;
Uncertainty.separatedZmodel = separatedZmodel;
Uncertainty.uncertaintyTypes = uncertaintyTypes;
Uncertainty.separatedZmodel = separatedZmodel;
Uncertainty.uncertaintyGroups = uncertaintyGroups;
VariableType.x = recover(VariableType.x_variables);
VariableType.w = recover(VariableType.w_variables);
failure = 0;
function dispsilent(notsilent,text)
if notsilent
disp(text);
end
function [F,w] = extractUncertain(F,w);
if isempty(w)
unc_declarations = is(F,'uncertain');
if any(unc_declarations)
w = recover(getvariables(sdpvar(F(find(unc_declarations)))));
F = F(find(~unc_declarations));
else
error('There is no uncertainty definition in the model.')
end
end
function groups = findSeparate(model)
% This is an early bail-out to avoid any errors during the devlopment of
% new features. Separable constraints are only support for Polya models
if any(model.K.s > 0) %| any(model.K.q >0)
groups{1} = 1:size(model.F_struc,2)-1;
return
end
X = zeros(size(model.F_struc,2)-1);
top = 1;
if model.K.f + model.K.l > 0
A = model.F_struc(top:model.K.f+model.K.l,2:end);
for i = 1:size(A,1)
X(find(A(i,:)),find(A(i,:))) = 1;
end
top = top + model.K.f + model.K.l;
end
if any(model.K.q > 0)
for j = 1:length(model.K.q)
A = model.F_struc(top:top+model.K.q(j)-1,2:end);top = top + model.K.q(j);
A = sum(abs(A),1);
for i = 1:size(A,1)
X(find(A),find(A)) = 1;
end
end
end
if any(model.K.s > 0)
for j = 1:length(model.K.s)
A = model.F_struc(top:top+model.K.s(j)^2-1,2:end);top = top + model.K.s(j)^2;
A = sum(abs(A),1);
for i = 1:size(A,1)
X(find(A),find(A)) = 1;
end
end
end
[a,b,c,d] = dmperm(X);
for i = 1:length(d)-1
groups{i} = sort(a(d(i):d(i+1)-1));
end
function newModels = separateUncertainty(Zmodel,uncertaintyGroups);
for i = 1:length(uncertaintyGroups)
data = Zmodel.F_struc(:,[1 1+uncertaintyGroups{i}]);
data_f = data(1:Zmodel.K.f,:);
data_l = data(Zmodel.K.f+1:Zmodel.K.f+Zmodel.K.l,:);
%data_q = data(Zmodel.K.f+Zmodel.K.l+1:sum(Zmodel.K.q),:);
%data_s = data(Zmodel.K.f+Zmodel.K.l+1:sum(Zmodel.K.q)+1:end,:);
eqIndex = find(any(data_f(:,2:end),2));
liIndex = find(any(data_l(:,2:end),2));
newModels{i}.F_struc = [data_f(eqIndex,:);data_l(liIndex,:)];
newModels{i}.K.f = length(eqIndex);
newModels{i}.K.l = length(liIndex);
newModels{i}.K.q = [];
top = Zmodel.K.f+Zmodel.K.l+1;
if Zmodel.K.q(1)>0
for j = 1:length(Zmodel.K.q)
data_q = data(top:top+Zmodel.K.q(j)-1,:);
if nnz(data_q(:,2:end))>0
newModels{i}.K.q(end+1) = Zmodel.K.q(j);
newModels{i}.F_struc = [newModels{i}.F_struc;data_q];
end
top = top + Zmodel.K.q(j);
end
end
if isempty(newModels{i}.K.q)
newModels{i}.K.q = 0;
end
newModels{i}.K.s = [];
top = Zmodel.K.q+Zmodel.K.f+Zmodel.K.l+1;
if Zmodel.K.s(1)>0
for j = 1:length(Zmodel.K.s)
data_s = data(top:top+Zmodel.K.s(j)^2-1,:);
if nnz(data_s(:,2:end))>0
newModels{i}.K.s(end+1) = Zmodel.K.s(j);
newModels{i}.F_struc = [newModels{i}.F_struc;data_s];
end
top = top + Zmodel.K.s(j)^2;
end
end
if isempty(newModels{i}.K.s)
newModels{i}.K.s = 0;
end
% newModels{i}.K.s = 0;
newModels{i}.variabletype = Zmodel.variabletype(uncertaintyGroups{i});
end
function Zmodel = convertuncertainty(Zmodel);
% Temoporary hack, will be generalized once the framework for multiple
% uncertainty models is supported
% We are looking for k>t, -tw<t
if size(Zmodel,1) == 1+(size(Zmodel,2)-1)*2 & Zmodel.K.f==0 & Zmodel.K.l==size(Zmodel.F_struc,1)
n = size(Zmodel.F_struc,2)-1;
if isequal(Zmodel.F_struc(:,2:end),sparse([zeros(1,n-1) -1;[eye(n-1);-eye(n-1)] ones(2*(n-1),1)]))
Zmodel.F_struc = [ones(2*n,1)*Zmodel.F_struc(1,1) [eye(n);-eye(n)]];
Zmodel.K.l = 2*n;
end
end
function [separatedZmodel, uncertaintyGroups,VariableType] = convertUncertaintyGroups(separatedZmodel,uncertaintyGroups,VariableType);
% Temporary hack, will be generalized once the framework for multiple
% uncertainty models is supported
% We are looking for k>t, -t<w<t. This is the slightly redundant model for
for i = 1:length(separatedZmodel)
% -k<w<k genrated when YALMIP encounters norm(w,inf)<k
if size(separatedZmodel{i},1) == 1+(size(separatedZmodel{i},2)-1)*2 & separatedZmodel{i}.K.f==0 & separatedZmodel{i}.K.l==size(separatedZmodel{i}.F_struc,1)
n = size(separatedZmodel{i}.F_struc,2)-1;
if isequal(separatedZmodel{i}.F_struc(:,2:end),sparse([zeros(1,n-1) -1;[eye(n-1);-eye(n-1)] ones(2*(n-1),1)]))
k = separatedZmodel{i}.F_struc(1,1);
c = separatedZmodel{i}.F_struc(2:2+n-2,1);
separatedZmodel{i}.F_struc = [[k-c;k;c+k;k] [-eye(n);eye(n)]];
separatedZmodel{i}.K.l = 2*n;
end
elseif separatedZmodel{i}.K.l == 1 & separatedZmodel{i}.K.q(1)>0 & length(separatedZmodel{i}.K.q(1))==1
% Could be norm(w,2) < r.
[n,m] = size(separatedZmodel{i}.F_struc);
if n==m & n>=3
n = n-2;
if isequal(separatedZmodel{i}.F_struc(:,2:end),sparse([zeros(2,n) [-1;1];eye(n) zeros(n,1)]))% isequal(separatedZmodel{i}.F_struc(:,2:end),sparse([zeros(2,n) [-1;1];eye(n) zeros(n,1)]))
if separatedZmodel{i}.F_struc(1,1)>0 %& nnz(separatedZmodel{i}.F_struc(2:end,1))==0
% the user has written norm(w-xc) < r. YALMIP will handle
% this using the nonlinear operator framework, and
% introduce a variable t and write it as norm(w)<t, t<r
% The variable t will be appended to the list of
% uncertain variables, and thus the model is a SOCP
% uncertainty in (w,t). We however want to interpret it
% as a simple quadratic model. We thus write it as
% (w,t)Q(w,t) < 1. Since t actually is unbounded in
% this form (since t is an auxilliary variable that we
% now through away, we arbitrarily say Q=[I/r^2 0;0 1]
r = separatedZmodel{i}.F_struc(1,1);
center = -separatedZmodel{i}.F_struc(3:end,1);
% separatedZmodel{i}.Q = blkdiag(r*eye(n),1);
% separatedZmodel{i}.center = [center;0];
separatedZmodel{i}.K.l = 0;
separatedZmodel{i}.K.q = n+1;
% r = separatedZmodel{i}.F_struc(1,1);
% center = -separatedZmodel{i}.F_struc(3:end,1);
separatedZmodel{i}.F_struc = [[1+r^2;-2*center;1-r^2] [zeros(1,n);eye(n)*2;zeros(1,n)]];
% VariableType.w_variables = setdiff(VariableType.w_variables,uncertaintyGroups{1}(end));
uncertaintyGroups{1}(end)=[];
end
end
end
end
end
function [uncertaintyTypes,separatedZmodel,uncertaintyGroups] = classifyUncertainty(separatedZmodel,uncertaintyGroups,w)
for i = 1:length(separatedZmodel)
uncertaintyTypes{i} = 'unclassified';
end
% Look for simplicies, which can be used in Polya
simplex_members = find_simplex_models(separatedZmodel);
for i = find(simplex_members)
uncertaintyTypes{i} = 'simplex';
end
% Look for simple bounds, and them combine them
for i = 1:length(separatedZmodel)
if strcmp(uncertaintyTypes{i},'unclassified')
if any(separatedZmodel{i}.K.q > 0) | any(separatedZmodel{i}.K.s > 0)
simplebounds = 0;
else
[aux,lower,upper] = find_simple_variable_bounds(separatedZmodel{i});
simplebounds = ~isinf(lower) & ~isinf(upper);
end
if all(simplebounds)
if aux.K.l == 0
uncertaintyTypes{i} = 'inf-norm';
separatedZmodel{i}.lb = lower;
separatedZmodel{i}.ub = upper;
end
end
end
end
j = find(strcmp(uncertaintyTypes,'inf-norm'));
if length(j)>1
allBounded = [];
lb = [];
ub = [];
for i = 1:length(j)
allBounded = [allBounded; uncertaintyGroups{j(i)}];
lb = [lb;separatedZmodel{j(i)}.lb];
ub = [ub;separatedZmodel{j(i)}.ub];
if any(lb > ub)
error('There are inconsistent bounds in the uncertainty model');
end
end
separatedZmodel{j(1)}.lb = lb;
separatedZmodel{j(1)}.ub = ub;
uncertaintyGroups{j(1)} = allBounded(:)';
keep = setdiff(1:length(separatedZmodel),j(2:end));
separatedZmodel = {separatedZmodel{keep}};
uncertaintyGroups = {uncertaintyGroups{keep}};
uncertaintyTypes = {uncertaintyTypes{keep}};
end
% Look for 2-norm balls norm(w) < r, written using norm(w) or w'*w
for i = 1:length(separatedZmodel)
if strcmp(uncertaintyTypes{i},'unclassified')
if ~any(separatedZmodel{i}.K.s > 0) & separatedZmodel{i}.K.l==0 & separatedZmodel{i}.K.f==0 & length(separatedZmodel{i}.K.q)==1
% Hmm, only 1 SOCP
if all(separatedZmodel{i}.F_struc(1,2:end)==0)
if isequal(separatedZmodel{i}.F_struc(2:end,2:end),speye(separatedZmodel{i}.K.q(1)-1))
% r > norm(x)
uncertaintyTypes{i} = '2-norm';
separatedZmodel{i}.center = -separatedZmodel{i}.F_struc(2:end,1);
separatedZmodel{i}.r = sqrt(max(0,separatedZmodel{i}.F_struc(1,1)^2));
elseif size(separatedZmodel{i}.F_struc,1)==size(separatedZmodel{i}.F_struc,2)
S = separatedZmodel{i}.F_struc(2:end,2:end);
[ii,jj,kk] = find(S);
if all(kk==2) & length(ii)==length(unique(ii)) & length(jj)==length(unique(jj))
% r > norm(x-center)
uncertaintyTypes{i} = '2-norm';
separatedZmodel{i}.center = -separatedZmodel{i}.F_struc(2:end,1)/2;
separatedZmodel{i}.r = sqrt((separatedZmodel{i}.F_struc(1,1)^2-separatedZmodel{i}.F_struc(end,1)^2)/4);
end
elseif separatedZmodel{i}.F_struc(1,1)^2-separatedZmodel{i}.F_struc(end,1)^2>0
S = separatedZmodel{i}.F_struc(2:end,2:end);
[ii,jj,kk] = find(S);
if all(kk==2) & length(ii)==length(unique(ii)) & length(jj)==length(unique(jj))
uncertaintyTypes{i} = '2-norm';
separatedZmodel{i}.center = -separatedZmodel{i}.F_struc(2:end-1,1)/2;
separatedZmodel{i}.r = sqrt((separatedZmodel{i}.F_struc(1,1)^2-separatedZmodel{i}.F_struc(end,1)^2)/4);
end
end
end
end
end
end
% Look for quadratic constraints, other than norm models
% A bit redundant code should be integrated with the case above
for i = 1:length(separatedZmodel)
if strcmp(uncertaintyTypes{i},'unclassified')
if ~any(separatedZmodel{i}.K.s > 0) & separatedZmodel{i}.K.l==0 & separatedZmodel{i}.K.f==0 & length(separatedZmodel{i}.K.q)==1
% 1 single SOCP ||Ax+b|| <= cx+d
A = separatedZmodel{i}.F_struc(2:end,2:end);
b = separatedZmodel{i}.F_struc(2:end,1);
c = separatedZmodel{i}.F_struc(1,2:end);
d = separatedZmodel{i}.F_struc(1,1);
if min(eig(full(A'*A-c'*c)))
% Originates in a quadratic constraint
rhs = c*w(uncertaintyGroups{i}(:))+d;
lhs = A*w(uncertaintyGroups{i}(:))+b;
uncertaintyTypes{i} = 'quadratic';
separatedZmodel{i}.g = rhs^2-lhs'*lhs;
separatedZmodel{i}.center = [];
separatedZmodel{i}.r = [];
end
end
end
end
% Look for 1-norm balls |w|1 < r^2
% We are looking for the auto-generate model -t<w<t, sum(t)<s,s<r^2
for i = 1:length(separatedZmodel)
if strcmp(uncertaintyTypes{i},'unclassified')
if ~any(separatedZmodel{i}.K.s > 0) & separatedZmodel{i}.K.l>0 & separatedZmodel{i}.K.f==0 & ~any(separatedZmodel{i}.K.q > 0)
%if all(separatedZmodel{i}.F_struc(2:end,1)==0)
if separatedZmodel{i}.F_struc(1,1)>0
n = (size(separatedZmodel{i}.F_struc,2)-2)/2;
if n==fix(n)
try
if all(separatedZmodel{i}.F_struc(n+2:end-1,1)==-separatedZmodel{i}.F_struc(2:2+n-1,1))
shouldbe = [zeros(1,n) -1 zeros(1,n);eye(n) zeros(n,1) eye(n);-eye(n) zeros(n,1) eye(n);zeros(1,n) 1 -ones(1,n)];%; zeros(n,n+1) eye(n)];;zeros(1,n) 1 zeros(1,n)];
if isequal(full(separatedZmodel{i}.F_struc(:,2:end)),shouldbe)
%if all(separatedZmodel{i}.F_struc(2:end,1)==0)
uncertaintyTypes{i} = '1-norm';
separatedZmodel{i}.r = separatedZmodel{i}.F_struc(1,1);
separatedZmodel{i}.center =separatedZmodel{i}.F_struc(n+2:end-1,1);
%end
end
end
catch
%FIX ME, caught by -1<w<1, sum(w)<1
end
end
end
%end
end
end
end
% Look for polytopes
for i = 1:length(separatedZmodel)
if strcmp(uncertaintyTypes{i},'unclassified')
if ~any(separatedZmodel{i}.K.q > 0) | any(separatedZmodel{i}.K.s > 0)
end
end
end
function Fnew = projectOut(F,w,newAuxVariables,uncertaintyGroups,ops)
w_variables = getvariables(w);
Graph = yalmip('getdependence');
for i = 1:length(uncertaintyGroups)
Graph(w_variables(uncertaintyGroups{i}),w_variables(uncertaintyGroups{i}))=1;
end
aux_and_w = union(newAuxVariables,w_variables);
F_lp = F(find(is(F,'elementwise')));
X = sdpvar(F_lp);
Xvars = getvariables(X);
G = getbase(X);G = G(:,2:end);
for i = 1:size(G,1)
j = Xvars(find(G(i,:)));
Graph(j,j) = 1;
end
Graph(:,setdiff(1:size(Graph,2),aux_and_w))=0;
Graph(setdiff(1:size(Graph,2),aux_and_w),:)=0;
Graph2 = Graph(1:max(aux_and_w),1:max(aux_and_w));
Graph2 = Graph2 + speye(length(Graph2));
[aa,bb,cc,dd] = dmperm(Graph2);
commonProjections = {};
for r = 1:length(dd)-1
comps = dd(r):dd(r+1)-1;
comps = intersect(aa(comps),newAuxVariables);
if ~isempty(comps)
commonProjections{end+1} = comps;
end
end
if ops.verbose
disp([' - * Partitioned these into ' num2str(length(commonProjections)) ' group(s)']);
end
keep = ones(length(F),1);
Fnew = [];
started = 0;
for clique = 1:length(commonProjections)
F_lp = [];
for i = 1:length(F)
F_vars = getvariables(F(i));
var_w = intersect(F_vars,w_variables);
var_aux = intersect(F_vars,commonProjections{clique});
if is(F(i),'elementwise')
if any(ismember(getvariables(F(i)),commonProjections{clique}))
F_lp = [F_lp, F(i)];
keep(i) = 0;
if ~started
started = 1;
if ops.verbose
disp([' - * Performing projections of uncertain graph variables...']);
end
end
end
end
end
if ~isempty(F_lp)
X = sdpvar(F_lp);
[Ab] = getbase(X);
b = Ab(:,1);
A = -Ab(:,2:end);
allVariables = getvariables(X);
newAuxVariables = intersect(commonProjections{clique},allVariables);
j = [];
for i = 1:length(newAuxVariables)
j(i) = find(allVariables==newAuxVariables(i));
end
[A,b] = fourierMotzkin(A,b,sort(j));
A(:,j)=[];
left = recover(setdiff(allVariables,newAuxVariables));
X = b-A*left(:);
Fnew = [Fnew,[[X >= 0] : 'Projected uncertain']];
end
end
if started & ops.verbose
d = length(sdpvar(Fnew))-length(sdpvar(F_lp));
if d>0
disp([' - * Done with projections (generated ' num2str(d) ' new constraints)']);
elseif d<0
disp([' - * Done with projections (actually reduced model with ' num2str(-d) ' constraints)']);
else
disp([' - * Done with projections (model size unchanged)']);
end
end
Fnew = [Fnew,F(find(keep))];
function [A,b] = fourierMotzkin(A,b,dim)
% Brute-force projection through Fourier-Motzkin
for i = dim(:)'
a = A(:,i);
zero = find(a == 0);
pos = find(a > 0);
neg = find(a < 0);
T = spalloc(length(zero) + length(pos)*length(neg),size(A,1),length(zero)+length(pos)*length(neg)*2);
row = 1;
for j = zero(:)'
T(row,j) = 1;
row = row+1;
end
for j = pos(:)'
for k = neg(:)'
T(row,j) = -a(k);
T(row,k) = a(j);
row = row+1;
end
end
A = T*A;
b = T*b;
end
function [Fnew,xnew,info] = adjustable(F,w,newAuxVariables,uncertaintyGroups,ops,VariableType)
L = sdpvar(length(recover(newAuxVariables)),length(w),'full');
L = L.*VariableType.Graph(VariableType.aux_with_w_dependence,VariableType.w_variables);
y0 = sdpvar(length(recover(newAuxVariables)),1);
Fnew = replace(F,recover(newAuxVariables),y0+L*w);
xnew = recover([getvariables(y0) getvariables(L)]);
info.nvars = length(getvariables(L));
info.sparsity = length(getvariables(L))/prod(size(L));
Reference in New Issue View Git Blame Copy Permalink