source: proiecte/pmake3d/make3d_original/Make3dSingleImageStanford_version0.1/third_party/opt/yalmip/@sdpvar/norm.m @ 37

Last change on this file since 37 was 37, checked in by (none), 14 years ago

Added original make3d
File size: 11.4 KB
Line 
1function varargout = norm(varargin)
2%NORM (overloaded)
3%
4% t = NORM(x,P)
5%
6% The variable t can only be used in convexity preserving
7% operations such as t<0, max(t,y)<1, minimize t etc.
8%
9%    For matrices...
10%      NORM(X) models the largest singular value of X, max(svd(X)).
11%      NORM(X,2) is the same as NORM(X).
12%      NORM(X,1) models the 1-norm of X, the largest column sum, max(sum(abs(X))).
13%      NORM(X,inf) models the infinity norm of X, the largest row sum, max(sum(abs(X'))).
14%      NORM(X,'fro') models the Frobenius norm, sqrt(sum(diag(X'*X))).
15%    For vectors...
16%      NORM(V) = norm(V,2) = standard Euclidean norm.
17%      NORM(V,inf) = max(abs(V)).
18%      NORM(V,1) = sum(abs(V))
19%
20% SEE ALSO SUMK, SUMABSK
21
22% Author Johan Löfberg
23% $Id: norm.m,v 1.30 2006/07/26 20:17:58 joloef Exp $
24
25
26%% ***************************************************
27% This file defines a nonlinear operator for YALMIP
28%
29% It can take three different inputs
30% For DOUBLE inputs, it returns standard double values
31% For SDPVAR inputs, it generates an internal variable
32%
33% When first input is 'model' it returns the graph
34% in the first output and structure describing some
35% properties of the operator.
36
37%% ***************************************************
38switch class(varargin{1})
39
40    case 'double' % What is the numerical value of this argument (needed for displays etc)
41        % SHOULD NEVER HAPPEN, THIS SHOULD BE CAUGHT BY BUILT-IN
42        error('Overloaded SDPVAR/NORM CALLED WITH DOUBLE. Report error')
43
44    case 'sdpvar' % Overloaded operator for SDPVAR objects. Pass on args and save them.
45        if nargin == 1
46            varargout{1} = yalmip('addextendedvariable',mfilename,varargin{1},2);
47        else
48            switch varargin{2}
49                case {1,2,inf,'inf','fro'}
50                    varargout{1} = yalmip('addextendedvariable',mfilename,varargin{:});
51                otherwise
52                    error('norm(x,P) only supported for P = 1, 2, inf and ''fro''');
53            end
54        end
55
56    case 'char' % YALMIP sends 'model' when it wants the epigraph or hypograph
57        switch varargin{1}
58            case 'graph'
59                t = varargin{2};
60                X = varargin{3};
61                p = varargin{4};
62
63                % Code below complicated by two things
64                % 1: Absolute value for complex data -> cone constraints on
65                %    elements
66                % 2: SUBSREF does not call SDPVAR subsref -> use extsubsref.m
67
68                % FIX : Exploit symmetry to create smaller problem
69                switch p
70                    case 1
71                        z = sdpvar(size(X,1),size(X,2),'full');
72                        if min(size(X))>1
73                            if isreal(X)
74                                F = set(-z < X < z);
75                            else
76                                F = set([]);
77                                for i = 1:size(X,1)
78                                    for j = 1:size(X,2)
79                                        xi = extsubsref(X,i,j);
80                                        zi = extsubsref(z,i,j);
81                                        F = F + set(cone([real(xi);imag(xi)],zi));
82                                    end
83                                end
84                            end
85                            F = F + set(sum(z,1) < t);
86                        else
87                            if isreal(X)
88                                F = set(-z < X < z) + set(sum(z) < t);
89                                [M,m] = derivebounds(X);
90                                bounds(z,0,max(abs([M -m]),[],2));
91                                bounds(t,0,sum(max(abs([M -m]),[],2)));
92                            else
93                                F = set([]);
94                                for i = 1:length(X)
95                                    xi = extsubsref(X,i);
96                                    zi = extsubsref(z,i);
97                                    F = F + set(cone([real(xi);imag(xi)],zi));
98                                end
99                                F = F + set(sum(z) < t);
100                            end
101                        end
102                    case 2
103                        z = sdpvar(size(X,1),size(X,2));
104                        if min(size(X))>1
105                            F = set([t*eye(size(X,1)) X;X' t*eye(size(X,2))]);
106                        else
107                            F = set(cone(X(:),t));
108                        end
109                    case {inf,'inf'}
110                        if min(size(X))>1
111                            z = sdpvar(size(X,1),size(X,2),'full');
112                            if isreal(X)
113                                F = set(-z < X < z);
114                            else
115                                F = set([]);
116                                for i = 1:size(X,1)
117                                    for j = 1:size(X,2)
118                                        xi = extsubsref(X,i,j);
119                                        zi = extsubsref(z,i,j);
120                                        F = F + set(cone([real(xi);imag(xi)],zi));
121                                    end
122                                end
123                            end
124                            F = F + set(sum(z,2) < t);
125                        else
126                            if isreal(X)
127                                F = set(-t < X < t);
128                                [M,m,infbound] = derivebounds(X);
129                                if ~infbound
130                                    F = F + set(0<t<max(M));
131                                end
132                            else
133                                F = set([]);
134                                for i = 1:length(X)
135                                    xi = extsubsref(X,i);
136                                    F = F + set(cone([real(xi);imag(xi)],t));
137                                end
138                            end
139                        end
140                    case 'fro'
141                        X.dim(1)=X.dim(1)*X.dim(2);
142                        X.dim(2)=1;
143                        F = set(cone(X,t));
144                    otherwise
145                end
146                varargout{1} = F;
147                varargout{2} = struct('convexity','convex','monotonicity','none','definiteness','positive');
148                varargout{3} = X;
149            case 'milp'
150
151                t = varargin{2};
152                X = varargin{3};
153                p = varargin{4};
154                if ~isreal(X) | isequal(p,2) | isequal(p,'fro') | min(size(X))>1 % Complex valued data, matrices and 2-norm not supported
155                    varargout{1} = [];
156                    varargout{2} = [];
157                    varargout{3} = [];
158                else
159                    if p==1
160                        X     = reshape(X,length(X),1);
161                        absX  = sdpvar(length(X),1);
162                        d     = binvar(length(X),1);
163                        [M,m] = derivebounds(X);
164                         F = set([]);
165                         positive = find(m >= 0);
166                         negative = find(M <= 0);
167                         
168                         % d(find(positive)) = 1;
169                         % d(find(negative)) = 0;                         
170                         if ~isempty(positive)                             
171                             d = subsasgn(d,struct('type','()','subs',{{positive}}),1);
172                         end
173                         if ~isempty(negative)                             
174                             d = subsasgn(d,struct('type','()','subs',{{negative}}),0);
175                         end
176                         
177                         F = F + set(X <= M.*d)     + set(2*m.*d     <= absX+X <= 2*M.*d);
178                         F = F + set(X >= m.*(1-d)) + set(2*m.*(1-d) <= absX-X <= 2*M.*(1-d));
179                         F = F + set(t - sum(absX) == 0);
180                         
181                    else
182
183                        if 0
184
185                            %2^n cases
186                            %e.g in 2d,
187                            %norm([x;y],inf) = y, y>0, y>x.y>-x
188                            %                = x, x>0, x>y.x>-y
189
190                            n = length(X);
191                            X     = reshape(X,n,1);
192                            absX  = sdpvar(n,1);
193                            d     = binvar(n,1);
194                            [M,m] = derivebounds(X);
195
196                            F = set(sum(d)==0);
197
198                            top = 1;
199                            for i = 1:n
200                                xi = extsubsref(X,i);
201                                y = extsubsref(X,setdiff(1:n,i));
202                                for sign_abs_largest_variable = -1:2:1
203                                    di = extsubsref(d,top);
204                                    for j = setdiff(1:n,i)
205                                        y = extsubsref(X,j);
206                                        for sign_other = -1:2:1
207                                            F = F + set(xi*sign_abs_largest_variable >= sign_other*y);
208                                            F = F + set(-M*100*(1-di) <= xi*sign_abs_largest_variable-t <= t+M*100*(1-di));
209                                        end
210                                    end
211                                    top = top + 1;
212                                end
213                            end
214
215
216
217
218                        else
219                            % OLD
220                            n = length(X);
221                            X     = reshape(X,n,1);
222                            absX  = sdpvar(n,1);
223                            d     = binvar(n,1);
224                            [M,m] = derivebounds(X);
225                            F = set([]);
226                            F = F + set(X <= M.*d)     + set(2*m.*d     <= absX+X <= 2*M.*d);
227                            F = F + set(X >= m.*(1-d)) + set(2*m.*(1-d) <= absX-X <= 2*M.*(1-d));
228                            M = max(M,-m);
229                            d = binvar(n,1);
230                            F = F + set(sum(d)==1);
231                            F = F + set(absX <= t <= absX + M.*(1-d));
232
233                            kk = [];
234                            ii = [];
235                            for i = 1:n
236                                k = [1:1:i-1 i+1:1:n]';
237                                ii = [ii;repmat(i,n-1,1)];
238                                kk = [kk;k];
239                                Mm = M(k);
240                            end
241                            xii = extsubsref(absX,ii);
242                            dii = extsubsref(d,ii);
243                            xkk = extsubsref(absX,kk);
244                            F = F + set(xkk <= xii+(M(kk)-m(ii)).*(1-dii));
245                        end
246
247                        %   for i = 1:n
248                        %       xi = extsubsref(absX,i);
249                        %       di = extsubsref(d,i);
250                        %       for k = [1:1:i-1 i+1:1:n]
251                        %           xk = extsubsref(absX,k);
252                        %           F = F + set(xk <= xi+M(k)*(1-di));
253                        %       end
254                        %   end
255
256                    end
257                    varargout{1} = F;
258                    varargout{2} = struct('convexity','milp','monotonicity','milp','definiteness','positive');
259                    varargout{3} = X;
260                end
261            otherwise
262                error('SDPVAR/NORM called with CHAR argument?');
263        end
264    otherwise
265        error('Strange type on first argument in SDPVAR/NORM');
266end
Note: See TracBrowser for help on using the repository browser.