Mercurial > octave-nkf

comparison src/DLD-FUNCTIONS/minmax.cc @ 4844:9f7ef92b50b0

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[project @ 2004-04-02 17:26:53 by jwe]
author jwe
date Fri, 02 Apr 2004 17:26:54 +0000
parents abdcb14e598d
children b92d59213e63
comparison
equal deleted inserted replaced
4843:7b4e76100964 4844:9f7ef92b50b0
26 26
27 #include <cmath> 27 #include <cmath>
28 28
29 #include "lo-ieee.h" 29 #include "lo-ieee.h"
30 #include "lo-mappers.h" 30 #include "lo-mappers.h"
31 #include "dMatrix.h" 31 #include "dNDArray.h"
32 #include "CMatrix.h" 32 #include "CNDArray.h"
33 #include "quit.h" 33 #include "quit.h"
34 34
35 #include "defun-dld.h" 35 #include "defun-dld.h"
36 #include "error.h" 36 #include "error.h"
37 #include "gripes.h" 37 #include "gripes.h"
38 #include "oct-obj.h" 38 #include "oct-obj.h"
39 39
40 #include "ov-cx-mat.h"
41
40 #define MINMAX_BODY(FCN) \ 42 #define MINMAX_BODY(FCN) \
41 \ 43 \
42 octave_value_list retval; \ 44 octave_value_list retval; \
43 \ 45 \
44 int nargin = args.length (); \ 46 int nargin = args.length (); \
45 \ 47 \
46 if (nargin < 1 || nargin > 2 || nargout > 2) \ 48 if (nargin < 1 || nargin > 3 || nargout > 2) \
47 { \ 49 { \
48 print_usage (#FCN); \ 50 print_usage (#FCN); \
49 return retval; \ 51 return retval; \
50 } \ 52 } \
51 \ 53 \
52 octave_value arg1; \ 54 octave_value arg1; \
53 octave_value arg2; \ 55 octave_value arg2; \
56 octave_value arg3; \
54 \ 57 \
55 switch (nargin) \ 58 switch (nargin) \
56 { \ 59 { \
60 case 3: \
61 arg3 = args(2); \
62 \
57 case 2: \ 63 case 2: \
58 arg2 = args(1); \ 64 arg2 = args(1); \
59 \ 65 \
60 case 1: \ 66 case 1: \
61 arg1 = args(0); \ 67 arg1 = args(0); \
64 default: \ 70 default: \
65 panic_impossible (); \ 71 panic_impossible (); \
66 break; \ 72 break; \
67 } \ 73 } \
68 \ 74 \
69 if (nargin == 1 && (nargout == 1 || nargout == 0)) \ 75 int dim; \
76 dim_vector dv = ((const octave_complex_matrix&) arg1) .dims (); \
77 if (error_state) \
78 { \
79 gripe_wrong_type_arg (#FCN, arg1); \
80 return retval; \
81 } \
82 \
83 if (nargin == 3) \
84 { \
85 dim = arg3.nint_value () - 1; \
86 if (dim < 0 || dim >= dv.length ()) \
87 { \
88 error ("%s: invalid dimension", #FCN); \
89 return retval; \
90 } \
91 } \
92 else \
93 { \
94 dim = 0; \
95 while ((dim < dv.length ()) && (dv (dim) <= 1)) \
96 dim++; \
97 if (dim == dv.length ()) \
98 dim = 0; \
99 } \
100 \
101 bool single_arg = (nargin == 1) || arg2.is_empty(); \
102 \
103 if (single_arg) \
104 { \
105 dv(dim) = 1; \
106 int n_dims = dv.length (); \
107 for (int i = n_dims; i > 1; i--) \
108 { \
109 if (dv(i-1) == 1) \
110 n_dims--; \
111 else \
112 break; \
113 } \
114 dv.resize (n_dims); \
115 } \
116 \
117 if (single_arg && (nargout == 1 || nargout == 0)) \
70 { \ 118 { \
71 if (arg1.is_real_type ()) \ 119 if (arg1.is_real_type ()) \
72 { \ 120 { \
73 Matrix m = arg1.matrix_value (); \ 121 NDArray m = arg1.array_value (); \
74 \ 122 \
75 if (! error_state) \ 123 if (! error_state) \
76 { \ 124 { \
77 if (m.rows () == 1) \ 125 NDArray n = m. FCN (dim); \
78 retval(0) = m.row_ ## FCN (); \ 126 n.resize (dv); \
79 else \ 127 retval(0) = n; \
80 { \
81 if (m.rows () == 0 || m.columns () == 0) \
82 retval(0) = Matrix (); \
83 else \
84 retval(0) = m.column_ ## FCN (); \
85 } \
86 } \ 128 } \
87 } \ 129 } \
88 else if (arg1.is_complex_type ()) \ 130 else if (arg1.is_complex_type ()) \
89 { \ 131 { \
90 ComplexMatrix m = arg1.complex_matrix_value (); \ 132 ComplexNDArray m = arg1.complex_array_value (); \
91 \ 133 \
92 if (! error_state) \ 134 if (! error_state) \
93 { \ 135 { \
94 if (m.rows () == 1) \ 136 ComplexNDArray n = m. FCN (dim); \
95 retval(0) = m.row_ ## FCN (); \ 137 n.resize (dv); \
96 else \ 138 retval(0) = n; \
97 { \
98 if (m.rows () == 0 || m.columns () == 0) \
99 retval(0) = Matrix (); \
100 else \
101 retval(0) = m.column_ ## FCN (); \
102 } \
103 } \ 139 } \
104 } \ 140 } \
105 else \ 141 else \
106 gripe_wrong_type_arg (#FCN, arg1); \ 142 gripe_wrong_type_arg (#FCN, arg1); \
107 } \ 143 } \
108 else if (nargin == 1 && nargout == 2) \ 144 else if (single_arg && nargout == 2) \
109 { \ 145 { \
110 Array<int> index; \ 146 ArrayN<int> index; \
111 \ 147 \
112 if (arg1.is_real_type ()) \ 148 if (arg1.is_real_type ()) \
113 { \ 149 { \
114 Matrix m = arg1.matrix_value (); \ 150 NDArray m = arg1.array_value (); \
115 \ 151 \
116 if (! error_state) \ 152 if (! error_state) \
117 { \ 153 { \
118 retval.resize (2); \ 154 NDArray n = m. FCN (index, dim); \
119 \ 155 n.resize (dv); \
120 if (m.rows () == 1) \ 156 retval(0) = n; \
121 retval(0) = m.row_ ## FCN (index); \
122 else \
123 { \
124 if (m.rows () == 0 || m.columns () == 0) \
125 retval(0) = Matrix (); \
126 else \
127 retval(0) = m.column_ ## FCN (index); \
128 } \
129 } \ 157 } \
130 } \ 158 } \
131 else if (arg1.is_complex_type ()) \ 159 else if (arg1.is_complex_type ()) \
132 { \ 160 { \
133 ComplexMatrix m = arg1.complex_matrix_value (); \ 161 ComplexNDArray m = arg1.complex_array_value (); \
134 \ 162 \
135 if (! error_state) \ 163 if (! error_state) \
136 { \ 164 { \
137 retval.resize (2); \ 165 ComplexNDArray n = m. FCN (index, dim); \
138 \ 166 n.resize (dv); \
139 if (m.rows () == 1) \ 167 retval(0) = n; \
140 retval(0) = m.row_ ## FCN (index); \
141 else \
142 { \
143 if (m.rows () == 0 || m.columns () == 0) \
144 retval(0) = Matrix (); \
145 else \
146 retval(0) = m.column_ ## FCN (index); \
147 } \
148 } \ 168 } \
149 } \ 169 } \
150 else \ 170 else \
151 gripe_wrong_type_arg (#FCN, arg1); \ 171 gripe_wrong_type_arg (#FCN, arg1); \
152 \ 172 \
153 int len = index.length (); \ 173 int len = index.numel (); \
154 \ 174 \
155 if (len > 0) \ 175 if (len > 0) \
156 { \ 176 { \
157 double nan_val = lo_ieee_nan_value (); \ 177 double nan_val = lo_ieee_nan_value (); \
158 \ 178 \
159 RowVector idx (len); \ 179 NDArray idx (index.dims ()); \
160 \ 180 \
161 for (int i = 0; i < len; i++) \ 181 for (int i = 0; i < len; i++) \
162 { \ 182 { \
163 OCTAVE_QUIT; \ 183 OCTAVE_QUIT; \
164 int tmp = index.elem (i) + 1; \ 184 int tmp = index.elem (i) + 1; \
167 } \ 187 } \
168 \ 188 \
169 retval(1) = idx; \ 189 retval(1) = idx; \
170 } \ 190 } \
171 else \ 191 else \
172 retval(1) = Matrix (); \ 192 retval(1) = NDArray (); \
173 } \ 193 } \
174 else if (nargin == 2) \ 194 else \
175 { \ 195 { \
176 int arg1_is_scalar = arg1.is_scalar_type (); \ 196 int arg1_is_scalar = arg1.is_scalar_type (); \
177 int arg2_is_scalar = arg2.is_scalar_type (); \ 197 int arg2_is_scalar = arg2.is_scalar_type (); \
178 \ 198 \
179 int arg1_is_complex = arg1.is_complex_type (); \ 199 int arg1_is_complex = arg1.is_complex_type (); \
182 if (arg1_is_scalar) \ 202 if (arg1_is_scalar) \
183 { \ 203 { \
184 if (arg1_is_complex || arg2_is_complex) \ 204 if (arg1_is_complex || arg2_is_complex) \
185 { \ 205 { \
186 Complex c1 = arg1.complex_value (); \ 206 Complex c1 = arg1.complex_value (); \
187 ComplexMatrix m2 = arg2.complex_matrix_value (); \ 207 ComplexNDArray m2 = arg2.complex_array_value (); \
188 if (! error_state) \ 208 if (! error_state) \
189 { \ 209 { \
190 ComplexMatrix result = FCN (c1, m2); \ 210 ComplexNDArray result = FCN (c1, m2); \
191 if (! error_state) \ 211 if (! error_state) \
192 retval(0) = result; \ 212 retval(0) = result; \
193 } \ 213 } \
194 } \ 214 } \
195 else \ 215 else \
196 { \ 216 { \
197 double d1 = arg1.double_value (); \ 217 double d1 = arg1.double_value (); \
198 Matrix m2 = arg2.matrix_value (); \ 218 NDArray m2 = arg2.array_value (); \
199 \ 219 \
200 if (! error_state) \ 220 if (! error_state) \
201 { \ 221 { \
202 Matrix result = FCN (d1, m2); \ 222 NDArray result = FCN (d1, m2); \
203 if (! error_state) \ 223 if (! error_state) \
204 retval(0) = result; \ 224 retval(0) = result; \
205 } \ 225 } \
206 } \ 226 } \
207 } \ 227 } \
208 else if (arg2_is_scalar) \ 228 else if (arg2_is_scalar) \
209 { \ 229 { \
210 if (arg1_is_complex || arg2_is_complex) \ 230 if (arg1_is_complex || arg2_is_complex) \
211 { \ 231 { \
212 ComplexMatrix m1 = arg1.complex_matrix_value (); \ 232 ComplexNDArray m1 = arg1.complex_array_value (); \
213 \ 233 \
214 if (! error_state) \ 234 if (! error_state) \
215 { \ 235 { \
216 Complex c2 = arg2.complex_value (); \ 236 Complex c2 = arg2.complex_value (); \
217 ComplexMatrix result = FCN (m1, c2); \ 237 ComplexNDArray result = FCN (m1, c2); \
218 if (! error_state) \ 238 if (! error_state) \
219 retval(0) = result; \ 239 retval(0) = result; \
220 } \ 240 } \
221 } \ 241 } \
222 else \ 242 else \
223 { \ 243 { \
224 Matrix m1 = arg1.matrix_value (); \ 244 NDArray m1 = arg1.array_value (); \
225 \ 245 \
226 if (! error_state) \ 246 if (! error_state) \
227 { \ 247 { \
228 double d2 = arg2.double_value (); \ 248 double d2 = arg2.double_value (); \
229 Matrix result = FCN (m1, d2); \ 249 NDArray result = FCN (m1, d2); \
230 if (! error_state) \ 250 if (! error_state) \
231 retval(0) = result; \ 251 retval(0) = result; \
232 } \ 252 } \
233 } \ 253 } \
234 } \ 254 } \
235 else \ 255 else \
236 { \ 256 { \
237 if (arg1_is_complex || arg2_is_complex) \ 257 if (arg1_is_complex || arg2_is_complex) \
238 { \ 258 { \
239 ComplexMatrix m1 = arg1.complex_matrix_value (); \ 259 ComplexNDArray m1 = arg1.complex_array_value (); \
240 \ 260 \
241 if (! error_state) \ 261 if (! error_state) \
242 { \ 262 { \
243 ComplexMatrix m2 = arg2.complex_matrix_value (); \ 263 ComplexNDArray m2 = arg2.complex_array_value (); \
244 \ 264 \
245 if (! error_state) \ 265 if (! error_state) \
246 { \ 266 { \
247 ComplexMatrix result = FCN (m1, m2); \ 267 ComplexNDArray result = FCN (m1, m2); \
248 if (! error_state) \ 268 if (! error_state) \
249 retval(0) = result; \ 269 retval(0) = result; \
250 } \ 270 } \
251 } \ 271 } \
252 } \ 272 } \
253 else \ 273 else \
254 { \ 274 { \
255 Matrix m1 = arg1.matrix_value (); \ 275 NDArray m1 = arg1.array_value (); \
256 \ 276 \
257 if (! error_state) \ 277 if (! error_state) \
258 { \ 278 { \
259 Matrix m2 = arg2.matrix_value (); \ 279 NDArray m2 = arg2.array_value (); \
260 \ 280 \
261 if (! error_state) \ 281 if (! error_state) \
262 { \ 282 { \
263 Matrix result = FCN (m1, m2); \ 283 NDArray result = FCN (m1, m2); \
264 if (! error_state) \ 284 if (! error_state) \
265 retval(0) = result; \ 285 retval(0) = result; \
266 } \ 286 } \
267 } \ 287 } \
268 } \ 288 } \
269 } \ 289 } \
270 } \ 290 } \
271 else \
272 panic_impossible (); \
273 \ 291 \
274 return retval 292 return retval
275 293
276 DEFUN_DLD (min, args, nargout, 294 DEFUN_DLD (min, args, nargout,
277 "-*- texinfo -*-\n\ 295 "-*- texinfo -*-\n\
278 @deftypefn {Mapping Function} {} min (@var{x}, @var{y})\n\ 296 @deftypefn {Mapping Function} {} min (@var{x}, @var{y}, @var{dim})\n\
279 @deftypefnx {Mapping Function} {[@var{w}, @var{iw}] =} min (@var{x})\n\ 297 @deftypefnx {Mapping Function} {[@var{w}, @var{iw}] =} min (@var{x})\n\
280 @cindex Utility Functions\n\ 298 @cindex Utility Functions\n\
281 For a vector argument, return the minimum value. For a matrix\n\ 299 For a vector argument, return the minimum value. For a matrix\n\
282 argument, return the minimum value from each column, as a row\n\ 300 argument, return the minimum value from each column, as a row\n\
283 vector.\n\ 301 vector, or over the dimension @var{dim} if defined. For two matrices\n\
284 For two matrices (or a matrix and scalar),\n\ 302 (or a matrix and scalar), return the pair-wise minimum.\n\
285 return the pair-wise minimum.\n\
286 Thus,\n\ 303 Thus,\n\
287 \n\ 304 \n\
288 @example\n\ 305 @example\n\
289 min (min (@var{x}))\n\ 306 min (min (@var{x}))\n\
290 @end example\n\ 307 @end example\n\
321 MINMAX_BODY (min); 338 MINMAX_BODY (min);
322 } 339 }
323 340
324 DEFUN_DLD (max, args, nargout, 341 DEFUN_DLD (max, args, nargout,
325 "-*- texinfo -*-\n\ 342 "-*- texinfo -*-\n\
326 @deftypefn {Mapping Function} {} max (@var{x}, @var{y})\n\ 343 @deftypefn {Mapping Function} {} max (@var{x}, @var{y}, @var{dim})\n\
327 @deftypefnx {Mapping Function} {[@var{w}, @var{iw}] =} max (@var{x})\n\ 344 @deftypefnx {Mapping Function} {[@var{w}, @var{iw}] =} max (@var{x})\n\
328 @cindex Utility Functions\n\ 345 @cindex Utility Functions\n\
329 For a vector argument, return the maximum value. For a matrix\n\ 346 For a vector argument, return the maximum value. For a matrix\n\
330 argument, return the maximum value from each column, as a row\n\ 347 argument, return the maximum value from each column, as a row\n\
331 vector.\n\ 348 vector, or over the dimension @var{dim} if defined. For two matrices\n\
332 For two matrices (or a matrix and scalar),\n\ 349 (or a matrix and scalar), return the pair-wise maximum.\n\
333 return the pair-wise maximum.\n\
334 Thus,\n\ 350 Thus,\n\
335 \n\ 351 \n\
336 @example\n\ 352 @example\n\
337 max (max (@var{x}))\n\ 353 max (max (@var{x}))\n\
338 @end example\n\ 354 @end example\n\