Mercurial > octave-nkf
annotate src/DLD-FUNCTIONS/max.cc @ 9065:8207b833557f
Cleanup documentation for arith.texi, linalg.texi, nonlin.texi
Grammarcheck input .txi files
Spellcheck .texi files
author | Rik <rdrider0-list@yahoo.com> |
---|---|
date | Sat, 28 Mar 2009 17:43:22 -0700 |
parents | 7c02ec148a3c |
children | 4218f9515258 |
rev | line source |
---|---|
2928 | 1 /* |
2 | |
7017 | 3 Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, |
8920 | 4 2005, 2006, 2007, 2008 John W. Eaton |
8777
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
5 Copyright (C) 2009 VZLU Prague |
2928 | 6 |
7 This file is part of Octave. | |
8 | |
9 Octave is free software; you can redistribute it and/or modify it | |
10 under the terms of the GNU General Public License as published by the | |
7016 | 11 Free Software Foundation; either version 3 of the License, or (at your |
12 option) any later version. | |
2928 | 13 |
14 Octave is distributed in the hope that it will be useful, but WITHOUT | |
15 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
17 for more details. | |
18 | |
19 You should have received a copy of the GNU General Public License | |
7016 | 20 along with Octave; see the file COPYING. If not, see |
21 <http://www.gnu.org/licenses/>. | |
2928 | 22 |
23 */ | |
24 | |
25 #ifdef HAVE_CONFIG_H | |
26 #include <config.h> | |
27 #endif | |
28 | |
29 #include "lo-ieee.h" | |
3248 | 30 #include "lo-mappers.h" |
7231 | 31 #include "lo-math.h" |
4844 | 32 #include "dNDArray.h" |
33 #include "CNDArray.h" | |
4153 | 34 #include "quit.h" |
2928 | 35 |
36 #include "defun-dld.h" | |
37 #include "error.h" | |
38 #include "gripes.h" | |
39 #include "oct-obj.h" | |
40 | |
4844 | 41 #include "ov-cx-mat.h" |
7505
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
42 #include "ov-re-sparse.h" |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
43 #include "ov-cx-sparse.h" |
4844 | 44 |
8777
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
45 #define MINMAX_DOUBLE_SBODY(FCN) \ |
7189 | 46 { \ |
8777
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
47 if (nargout == 1 || nargout == 0) \ |
3747 | 48 { \ |
49 if (arg1.is_real_type ()) \ | |
50 { \ | |
4844 | 51 NDArray m = arg1.array_value (); \ |
3747 | 52 \ |
53 if (! error_state) \ | |
54 { \ | |
4844 | 55 NDArray n = m. FCN (dim); \ |
56 retval(0) = n; \ | |
3747 | 57 } \ |
58 } \ | |
59 else if (arg1.is_complex_type ()) \ | |
60 { \ | |
4844 | 61 ComplexNDArray m = arg1.complex_array_value (); \ |
3747 | 62 \ |
63 if (! error_state) \ | |
64 { \ | |
4844 | 65 ComplexNDArray n = m. FCN (dim); \ |
66 retval(0) = n; \ | |
3747 | 67 } \ |
68 } \ | |
69 else \ | |
70 gripe_wrong_type_arg (#FCN, arg1); \ | |
71 } \ | |
8777
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
72 else if (nargout == 2) \ |
3747 | 73 { \ |
5275 | 74 ArrayN<octave_idx_type> index; \ |
3747 | 75 \ |
76 if (arg1.is_real_type ()) \ | |
77 { \ | |
4844 | 78 NDArray m = arg1.array_value (); \ |
3747 | 79 \ |
80 if (! error_state) \ | |
81 { \ | |
4844 | 82 NDArray n = m. FCN (index, dim); \ |
83 retval(0) = n; \ | |
3747 | 84 } \ |
85 } \ | |
86 else if (arg1.is_complex_type ()) \ | |
87 { \ | |
4844 | 88 ComplexNDArray m = arg1.complex_array_value (); \ |
3747 | 89 \ |
90 if (! error_state) \ | |
91 { \ | |
4844 | 92 ComplexNDArray n = m. FCN (index, dim); \ |
93 retval(0) = n; \ | |
3747 | 94 } \ |
95 } \ | |
96 else \ | |
97 gripe_wrong_type_arg (#FCN, arg1); \ | |
98 \ | |
5275 | 99 octave_idx_type len = index.numel (); \ |
3747 | 100 \ |
101 if (len > 0) \ | |
7919
9d080df0c843
new NDArray constructor for ArrayN<octave_idx_type>
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
102 retval(1) = NDArray (index, true, true); \ |
3747 | 103 else \ |
4844 | 104 retval(1) = NDArray (); \ |
3747 | 105 } \ |
8777
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
106 } |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
107 |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
108 #define MINMAX_DOUBLE_BODY(FCN) \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
109 { \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
110 bool single_arg = (nargin == 1) || (arg2.is_empty() && nargin == 3); \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
111 if (single_arg) \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
112 MINMAX_DOUBLE_SBODY (FCN) \ |
4844 | 113 else \ |
3747 | 114 { \ |
115 int arg1_is_scalar = arg1.is_scalar_type (); \ | |
116 int arg2_is_scalar = arg2.is_scalar_type (); \ | |
117 \ | |
118 int arg1_is_complex = arg1.is_complex_type (); \ | |
119 int arg2_is_complex = arg2.is_complex_type (); \ | |
120 \ | |
121 if (arg1_is_scalar) \ | |
122 { \ | |
123 if (arg1_is_complex || arg2_is_complex) \ | |
124 { \ | |
125 Complex c1 = arg1.complex_value (); \ | |
4844 | 126 ComplexNDArray m2 = arg2.complex_array_value (); \ |
3747 | 127 if (! error_state) \ |
128 { \ | |
4844 | 129 ComplexNDArray result = FCN (c1, m2); \ |
3747 | 130 if (! error_state) \ |
131 retval(0) = result; \ | |
132 } \ | |
133 } \ | |
134 else \ | |
135 { \ | |
136 double d1 = arg1.double_value (); \ | |
4844 | 137 NDArray m2 = arg2.array_value (); \ |
3747 | 138 \ |
139 if (! error_state) \ | |
140 { \ | |
4844 | 141 NDArray result = FCN (d1, m2); \ |
3747 | 142 if (! error_state) \ |
143 retval(0) = result; \ | |
144 } \ | |
145 } \ | |
146 } \ | |
147 else if (arg2_is_scalar) \ | |
148 { \ | |
149 if (arg1_is_complex || arg2_is_complex) \ | |
150 { \ | |
4844 | 151 ComplexNDArray m1 = arg1.complex_array_value (); \ |
3747 | 152 \ |
153 if (! error_state) \ | |
154 { \ | |
155 Complex c2 = arg2.complex_value (); \ | |
4844 | 156 ComplexNDArray result = FCN (m1, c2); \ |
3747 | 157 if (! error_state) \ |
158 retval(0) = result; \ | |
159 } \ | |
160 } \ | |
161 else \ | |
162 { \ | |
4844 | 163 NDArray m1 = arg1.array_value (); \ |
3747 | 164 \ |
165 if (! error_state) \ | |
166 { \ | |
167 double d2 = arg2.double_value (); \ | |
4844 | 168 NDArray result = FCN (m1, d2); \ |
3747 | 169 if (! error_state) \ |
170 retval(0) = result; \ | |
171 } \ | |
172 } \ | |
173 } \ | |
174 else \ | |
175 { \ | |
176 if (arg1_is_complex || arg2_is_complex) \ | |
177 { \ | |
4844 | 178 ComplexNDArray m1 = arg1.complex_array_value (); \ |
3747 | 179 \ |
180 if (! error_state) \ | |
181 { \ | |
4844 | 182 ComplexNDArray m2 = arg2.complex_array_value (); \ |
3747 | 183 \ |
184 if (! error_state) \ | |
185 { \ | |
4844 | 186 ComplexNDArray result = FCN (m1, m2); \ |
3747 | 187 if (! error_state) \ |
188 retval(0) = result; \ | |
189 } \ | |
190 } \ | |
191 } \ | |
192 else \ | |
193 { \ | |
4844 | 194 NDArray m1 = arg1.array_value (); \ |
3747 | 195 \ |
196 if (! error_state) \ | |
197 { \ | |
4844 | 198 NDArray m2 = arg2.array_value (); \ |
3747 | 199 \ |
200 if (! error_state) \ | |
201 { \ | |
4844 | 202 NDArray result = FCN (m1, m2); \ |
3747 | 203 if (! error_state) \ |
204 retval(0) = result; \ | |
205 } \ | |
206 } \ | |
207 } \ | |
208 } \ | |
209 } \ | |
7189 | 210 } |
211 | |
8777
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
212 #define MINMAX_SINGLE_SBODY(FCN) \ |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
213 { \ |
8777
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
214 if (nargout == 1 || nargout == 0) \ |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
215 { \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
216 if (arg1.is_real_type ()) \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
217 { \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
218 FloatNDArray m = arg1.float_array_value (); \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
219 \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
220 if (! error_state) \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
221 { \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
222 FloatNDArray n = m. FCN (dim); \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
223 retval(0) = n; \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
224 } \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
225 } \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
226 else if (arg1.is_complex_type ()) \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
227 { \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
228 FloatComplexNDArray m = arg1.float_complex_array_value (); \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
229 \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
230 if (! error_state) \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
231 { \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
232 FloatComplexNDArray n = m. FCN (dim); \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
233 retval(0) = n; \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
234 } \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
235 } \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
236 else \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
237 gripe_wrong_type_arg (#FCN, arg1); \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
238 } \ |
8777
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
239 else if (nargout == 2) \ |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
240 { \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
241 ArrayN<octave_idx_type> index; \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
242 \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
243 if (arg1.is_real_type ()) \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
244 { \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
245 FloatNDArray m = arg1.float_array_value (); \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
246 \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
247 if (! error_state) \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
248 { \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
249 FloatNDArray n = m. FCN (index, dim); \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
250 retval(0) = n; \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
251 } \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
252 } \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
253 else if (arg1.is_complex_type ()) \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
254 { \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
255 FloatComplexNDArray m = arg1.float_complex_array_value (); \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
256 \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
257 if (! error_state) \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
258 { \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
259 FloatComplexNDArray n = m. FCN (index, dim); \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
260 retval(0) = n; \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
261 } \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
262 } \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
263 else \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
264 gripe_wrong_type_arg (#FCN, arg1); \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
265 \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
266 octave_idx_type len = index.numel (); \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
267 \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
268 if (len > 0) \ |
7919
9d080df0c843
new NDArray constructor for ArrayN<octave_idx_type>
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
269 retval(1) = NDArray (index, true, true); \ |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
270 else \ |
7919
9d080df0c843
new NDArray constructor for ArrayN<octave_idx_type>
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
271 retval(1) = NDArray (); \ |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
272 } \ |
8777
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
273 } |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
274 |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
275 #define MINMAX_SINGLE_BODY(FCN) \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
276 { \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
277 bool single_arg = (nargin == 1) || (arg2.is_empty() && nargin == 3); \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
278 if (single_arg) \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
279 MINMAX_SINGLE_SBODY(FCN) \ |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
280 else \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
281 { \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
282 int arg1_is_scalar = arg1.is_scalar_type (); \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
283 int arg2_is_scalar = arg2.is_scalar_type (); \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
284 \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
285 int arg1_is_complex = arg1.is_complex_type (); \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
286 int arg2_is_complex = arg2.is_complex_type (); \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
287 \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
288 if (arg1_is_scalar) \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
289 { \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
290 if (arg1_is_complex || arg2_is_complex) \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
291 { \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
292 FloatComplex c1 = arg1.float_complex_value (); \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
293 FloatComplexNDArray m2 = arg2.float_complex_array_value (); \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
294 if (! error_state) \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
295 { \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
296 FloatComplexNDArray result = FCN (c1, m2); \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
297 if (! error_state) \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
298 retval(0) = result; \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
299 } \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
300 } \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
301 else \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
302 { \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
303 float d1 = arg1.float_value (); \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
304 FloatNDArray m2 = arg2.float_array_value (); \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
305 \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
306 if (! error_state) \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
307 { \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
308 FloatNDArray result = FCN (d1, m2); \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
309 if (! error_state) \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
310 retval(0) = result; \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
311 } \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
312 } \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
313 } \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
314 else if (arg2_is_scalar) \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
315 { \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
316 if (arg1_is_complex || arg2_is_complex) \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
317 { \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
318 FloatComplexNDArray m1 = arg1.float_complex_array_value (); \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
319 \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
320 if (! error_state) \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
321 { \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
322 FloatComplex c2 = arg2.float_complex_value (); \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
323 FloatComplexNDArray result = FCN (m1, c2); \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
324 if (! error_state) \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
325 retval(0) = result; \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
326 } \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
327 } \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
328 else \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
329 { \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
330 FloatNDArray m1 = arg1.float_array_value (); \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
331 \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
332 if (! error_state) \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
333 { \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
334 float d2 = arg2.float_value (); \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
335 FloatNDArray result = FCN (m1, d2); \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
336 if (! error_state) \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
337 retval(0) = result; \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
338 } \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
339 } \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
340 } \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
341 else \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
342 { \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
343 if (arg1_is_complex || arg2_is_complex) \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
344 { \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
345 FloatComplexNDArray m1 = arg1.float_complex_array_value (); \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
346 \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
347 if (! error_state) \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
348 { \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
349 FloatComplexNDArray m2 = arg2.float_complex_array_value (); \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
350 \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
351 if (! error_state) \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
352 { \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
353 FloatComplexNDArray result = FCN (m1, m2); \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
354 if (! error_state) \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
355 retval(0) = result; \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
356 } \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
357 } \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
358 } \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
359 else \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
360 { \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
361 FloatNDArray m1 = arg1.float_array_value (); \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
362 \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
363 if (! error_state) \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
364 { \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
365 FloatNDArray m2 = arg2.float_array_value (); \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
366 \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
367 if (! error_state) \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
368 { \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
369 FloatNDArray result = FCN (m1, m2); \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
370 if (! error_state) \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
371 retval(0) = result; \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
372 } \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
373 } \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
374 } \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
375 } \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
376 } \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
377 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
378 |
8777
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
379 #define MINMAX_INT_SBODY(FCN, TYP) \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
380 { \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
381 if (nargout == 1 || nargout == 0) \ |
7189 | 382 { \ |
383 TYP ## NDArray m = arg1. TYP ## _array_value (); \ | |
384 \ | |
385 if (! error_state) \ | |
386 { \ | |
387 TYP ## NDArray n = m. FCN (dim); \ | |
388 retval(0) = n; \ | |
389 } \ | |
390 } \ | |
8777
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
391 else if (nargout == 2) \ |
7189 | 392 { \ |
393 ArrayN<octave_idx_type> index; \ | |
394 \ | |
395 TYP ## NDArray m = arg1. TYP ## _array_value (); \ | |
396 \ | |
397 if (! error_state) \ | |
398 { \ | |
399 TYP ## NDArray n = m. FCN (index, dim); \ | |
400 retval(0) = n; \ | |
401 } \ | |
402 \ | |
403 octave_idx_type len = index.numel (); \ | |
404 \ | |
405 if (len > 0) \ | |
7919
9d080df0c843
new NDArray constructor for ArrayN<octave_idx_type>
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
406 retval(1) = NDArray (index, true, true); \ |
7189 | 407 else \ |
408 retval(1) = NDArray (); \ | |
409 } \ | |
8777
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
410 } |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
411 |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
412 #define MINMAX_INT_BODY(FCN, TYP) \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
413 { \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
414 bool single_arg = (nargin == 1) || (arg2.is_empty() && nargin == 3); \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
415 if (single_arg) \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
416 MINMAX_INT_SBODY (FCN, TYP) \ |
7189 | 417 else \ |
418 { \ | |
419 int arg1_is_scalar = arg1.is_scalar_type (); \ | |
420 int arg2_is_scalar = arg2.is_scalar_type (); \ | |
421 \ | |
422 if (arg1_is_scalar) \ | |
423 { \ | |
424 octave_ ## TYP d1 = arg1. TYP ## _scalar_value (); \ | |
425 TYP ## NDArray m2 = arg2. TYP ## _array_value (); \ | |
426 \ | |
427 if (! error_state) \ | |
428 { \ | |
429 TYP ## NDArray result = FCN (d1, m2); \ | |
430 if (! error_state) \ | |
431 retval(0) = result; \ | |
432 } \ | |
433 } \ | |
434 else if (arg2_is_scalar) \ | |
435 { \ | |
436 TYP ## NDArray m1 = arg1. TYP ## _array_value (); \ | |
437 \ | |
438 if (! error_state) \ | |
439 { \ | |
440 octave_ ## TYP d2 = arg2. TYP ## _scalar_value (); \ | |
441 TYP ## NDArray result = FCN (m1, d2); \ | |
442 if (! error_state) \ | |
443 retval(0) = result; \ | |
444 } \ | |
445 } \ | |
446 else \ | |
447 { \ | |
448 TYP ## NDArray m1 = arg1. TYP ## _array_value (); \ | |
449 \ | |
450 if (! error_state) \ | |
451 { \ | |
452 TYP ## NDArray m2 = arg2. TYP ## _array_value (); \ | |
453 \ | |
454 if (! error_state) \ | |
455 { \ | |
456 TYP ## NDArray result = FCN (m1, m2); \ | |
457 if (! error_state) \ | |
458 retval(0) = result; \ | |
459 } \ | |
460 } \ | |
461 } \ | |
462 } \ | |
463 } | |
464 | |
7505
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
465 #define MINMAX_SPARSE_BODY(FCN) \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
466 { \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
467 bool single_arg = (nargin == 1) || arg2.is_empty(); \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
468 \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
469 if (single_arg && (nargout == 1 || nargout == 0)) \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
470 { \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
471 if (arg1.type_id () == octave_sparse_matrix::static_type_id ()) \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
472 retval(0) = arg1.sparse_matrix_value () .FCN (dim); \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
473 else if (arg1.type_id () == \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
474 octave_sparse_complex_matrix::static_type_id ()) \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
475 retval(0) = arg1.sparse_complex_matrix_value () .FCN (dim); \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
476 else \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
477 gripe_wrong_type_arg (#FCN, arg1); \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
478 } \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
479 else if (single_arg && nargout == 2) \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
480 { \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
481 Array2<octave_idx_type> index; \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
482 \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
483 if (arg1.type_id () == octave_sparse_matrix::static_type_id ()) \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
484 retval(0) = arg1.sparse_matrix_value () .FCN (index, dim); \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
485 else if (arg1.type_id () == \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
486 octave_sparse_complex_matrix::static_type_id ()) \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
487 retval(0) = arg1.sparse_complex_matrix_value () .FCN (index, dim); \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
488 else \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
489 gripe_wrong_type_arg (#FCN, arg1); \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
490 \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
491 octave_idx_type len = index.numel (); \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
492 \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
493 if (len > 0) \ |
7919
9d080df0c843
new NDArray constructor for ArrayN<octave_idx_type>
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
494 retval(1) = NDArray (index, true, true); \ |
7505
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
495 else \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
496 retval(1) = NDArray (); \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
497 } \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
498 else \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
499 { \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
500 int arg1_is_scalar = arg1.is_scalar_type (); \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
501 int arg2_is_scalar = arg2.is_scalar_type (); \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
502 \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
503 int arg1_is_complex = arg1.is_complex_type (); \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
504 int arg2_is_complex = arg2.is_complex_type (); \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
505 \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
506 if (arg1_is_scalar) \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
507 { \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
508 if (arg1_is_complex || arg2_is_complex) \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
509 { \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
510 Complex c1 = arg1.complex_value (); \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
511 \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
512 SparseComplexMatrix m2 = arg2.sparse_complex_matrix_value (); \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
513 \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
514 if (! error_state) \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
515 { \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
516 SparseComplexMatrix result = FCN (c1, m2); \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
517 if (! error_state) \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
518 retval(0) = result; \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
519 } \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
520 } \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
521 else \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
522 { \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
523 double d1 = arg1.double_value (); \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
524 SparseMatrix m2 = arg2.sparse_matrix_value (); \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
525 \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
526 if (! error_state) \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
527 { \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
528 SparseMatrix result = FCN (d1, m2); \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
529 if (! error_state) \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
530 retval(0) = result; \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
531 } \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
532 } \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
533 } \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
534 else if (arg2_is_scalar) \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
535 { \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
536 if (arg1_is_complex || arg2_is_complex) \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
537 { \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
538 SparseComplexMatrix m1 = arg1.sparse_complex_matrix_value (); \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
539 \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
540 if (! error_state) \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
541 { \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
542 Complex c2 = arg2.complex_value (); \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
543 SparseComplexMatrix result = FCN (m1, c2); \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
544 if (! error_state) \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
545 retval(0) = result; \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
546 } \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
547 } \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
548 else \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
549 { \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
550 SparseMatrix m1 = arg1.sparse_matrix_value (); \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
551 \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
552 if (! error_state) \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
553 { \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
554 double d2 = arg2.double_value (); \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
555 SparseMatrix result = FCN (m1, d2); \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
556 if (! error_state) \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
557 retval(0) = result; \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
558 } \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
559 } \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
560 } \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
561 else \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
562 { \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
563 if (arg1_is_complex || arg2_is_complex) \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
564 { \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
565 SparseComplexMatrix m1 = arg1.sparse_complex_matrix_value (); \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
566 \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
567 if (! error_state) \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
568 { \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
569 SparseComplexMatrix m2 = arg2.sparse_complex_matrix_value (); \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
570 \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
571 if (! error_state) \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
572 { \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
573 SparseComplexMatrix result = FCN (m1, m2); \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
574 if (! error_state) \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
575 retval(0) = result; \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
576 } \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
577 } \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
578 } \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
579 else \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
580 { \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
581 SparseMatrix m1 = arg1.sparse_matrix_value (); \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
582 \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
583 if (! error_state) \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
584 { \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
585 SparseMatrix m2 = arg2.sparse_matrix_value (); \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
586 \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
587 if (! error_state) \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
588 { \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
589 SparseMatrix result = FCN (m1, m2); \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
590 if (! error_state) \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
591 retval(0) = result; \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
592 } \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
593 } \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
594 } \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
595 } \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
596 } \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
597 } |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
598 |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
599 |
7189 | 600 #define MINMAX_BODY(FCN) \ |
601 \ | |
602 octave_value_list retval; \ | |
603 \ | |
604 int nargin = args.length (); \ | |
605 \ | |
606 if (nargin < 1 || nargin > 3 || nargout > 2) \ | |
607 { \ | |
608 print_usage (); \ | |
609 return retval; \ | |
610 } \ | |
611 \ | |
612 octave_value arg1; \ | |
613 octave_value arg2; \ | |
614 octave_value arg3; \ | |
615 \ | |
616 switch (nargin) \ | |
617 { \ | |
618 case 3: \ | |
619 arg3 = args(2); \ | |
620 \ | |
621 case 2: \ | |
622 arg2 = args(1); \ | |
623 \ | |
624 case 1: \ | |
625 arg1 = args(0); \ | |
626 break; \ | |
627 \ | |
628 default: \ | |
629 panic_impossible (); \ | |
630 break; \ | |
631 } \ | |
632 \ | |
633 int dim; \ | |
634 dim_vector dv = arg1.dims (); \ | |
635 if (error_state) \ | |
636 { \ | |
637 gripe_wrong_type_arg (#FCN, arg1); \ | |
638 return retval; \ | |
639 } \ | |
640 \ | |
641 if (nargin == 3) \ | |
642 { \ | |
643 dim = arg3.nint_value () - 1; \ | |
644 if (dim < 0 || dim >= dv.length ()) \ | |
645 { \ | |
646 error ("%s: invalid dimension", #FCN); \ | |
647 return retval; \ | |
648 } \ | |
649 } \ | |
650 else \ | |
651 { \ | |
652 dim = 0; \ | |
653 while ((dim < dv.length ()) && (dv (dim) <= 1)) \ | |
654 dim++; \ | |
655 if (dim == dv.length ()) \ | |
656 dim = 0; \ | |
657 } \ | |
658 \ | |
659 if (arg1.is_integer_type ()) \ | |
660 { \ | |
661 if (arg1.is_uint8_type ()) \ | |
662 MINMAX_INT_BODY (FCN, uint8) \ | |
663 else if (arg1.is_uint16_type ()) \ | |
664 MINMAX_INT_BODY (FCN, uint16) \ | |
665 else if (arg1.is_uint32_type ()) \ | |
666 MINMAX_INT_BODY (FCN, uint32) \ | |
667 else if (arg1.is_uint64_type ()) \ | |
668 MINMAX_INT_BODY (FCN, uint64) \ | |
669 else if (arg1.is_int8_type ()) \ | |
670 MINMAX_INT_BODY (FCN, int8) \ | |
671 else if (arg1.is_int16_type ()) \ | |
672 MINMAX_INT_BODY (FCN, int16) \ | |
673 else if (arg1.is_int32_type ()) \ | |
674 MINMAX_INT_BODY (FCN, int32) \ | |
675 else if (arg1.is_int64_type ()) \ | |
676 MINMAX_INT_BODY (FCN, int64) \ | |
677 } \ | |
7505
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
678 else if (arg1.is_sparse_type ()) \ |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
679 MINMAX_SPARSE_BODY (FCN) \ |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
680 else if (arg1.is_single_type ()) \ |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
681 MINMAX_SINGLE_BODY (FCN) \ |
7189 | 682 else \ |
683 MINMAX_DOUBLE_BODY (FCN) \ | |
684 \ | |
685 return retval; | |
3747 | 686 |
2928 | 687 DEFUN_DLD (min, args, nargout, |
3443 | 688 "-*- texinfo -*-\n\ |
8780
ea76466605ba
support native cumsum, gripe on overflow in sum/cumsum
Jaroslav Hajek <highegg@gmail.com>
parents:
8778
diff
changeset
|
689 @deftypefn {Loadable Function} {} min (@var{x}, @var{y}, @var{dim})\n\ |
ea76466605ba
support native cumsum, gripe on overflow in sum/cumsum
Jaroslav Hajek <highegg@gmail.com>
parents:
8778
diff
changeset
|
690 @deftypefnx {Loadable Function} {[@var{w}, @var{iw}] =} min (@var{x})\n\ |
4522 | 691 @cindex Utility Functions\n\ |
3443 | 692 For a vector argument, return the minimum value. For a matrix\n\ |
693 argument, return the minimum value from each column, as a row\n\ | |
9064
7c02ec148a3c
Check grammar on all .cc files
Rik <rdrider0-list@yahoo.com>
parents:
8949
diff
changeset
|
694 vector, or over the dimension @var{dim} if defined. For two matrices\n\ |
4844 | 695 (or a matrix and scalar), return the pair-wise minimum.\n\ |
4522 | 696 Thus,\n\ |
3443 | 697 \n\ |
698 @example\n\ | |
699 min (min (@var{x}))\n\ | |
700 @end example\n\ | |
701 \n\ | |
702 @noindent\n\ | |
4522 | 703 returns the smallest element of @var{x}, and\n\ |
704 \n\ | |
705 @example\n\ | |
706 @group\n\ | |
707 min (2:5, pi)\n\ | |
708 @result{} 2.0000 3.0000 3.1416 3.1416\n\ | |
709 @end group\n\ | |
710 @end example\n\ | |
711 @noindent\n\ | |
712 compares each element of the range @code{2:5} with @code{pi}, and\n\ | |
713 returns a row vector of the minimum values.\n\ | |
3443 | 714 \n\ |
715 For complex arguments, the magnitude of the elements are used for\n\ | |
3657 | 716 comparison.\n\ |
717 \n\ | |
4522 | 718 If called with one input and two output arguments,\n\ |
719 @code{min} also returns the first index of the\n\ | |
9064
7c02ec148a3c
Check grammar on all .cc files
Rik <rdrider0-list@yahoo.com>
parents:
8949
diff
changeset
|
720 minimum value(s). Thus,\n\ |
4522 | 721 \n\ |
3775 | 722 @example\n\ |
4522 | 723 @group\n\ |
3657 | 724 [x, ix] = min ([1, 3, 0, 2, 5])\n\ |
4522 | 725 @result{} x = 0\n\ |
726 ix = 3\n\ | |
727 @end group\n\ | |
3657 | 728 @end example\n\ |
4522 | 729 @end deftypefn") |
2928 | 730 { |
3747 | 731 MINMAX_BODY (min); |
2928 | 732 } |
733 | |
7600
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
734 /* |
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
735 |
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
736 %% test/octave.test/arith/min-1.m |
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
737 %!assert (min ([1, 4, 2, 3]) == 1); |
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
738 %!assert (min ([1; -10; 5; -2]) == -10); |
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
739 |
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
740 %% test/octave.test/arith/min-2.m |
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
741 %!assert(all (min ([4, i; -2, 2]) == [-2, i])); |
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
742 |
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
743 %% test/octave.test/arith/min-3.m |
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
744 %!error <Invalid call to min.*> min (); |
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
745 |
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
746 %% test/octave.test/arith/min-4.m |
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
747 %!error <Invalid call to min.*> min (1, 2, 3, 4); |
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
748 |
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
749 %!test |
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
750 %! x = reshape (1:8,[2,2,2]); |
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
751 %! assert (max (x,[],1), reshape ([2, 4, 6, 8], [1,2,2])); |
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
752 %! assert (max (x,[],2), reshape ([3, 4, 7, 8], [2,1,2])); |
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
753 %! [y, i ] = max (x, [], 3); |
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
754 %! assert (y, [5, 7; 6, 8]); |
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
755 %! assert (ndims(y), 2); |
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
756 %! assert (i, [2, 2; 2, 2]); |
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
757 %! assert (ndims(i), 2); |
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
758 |
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
759 */ |
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
760 |
2928 | 761 DEFUN_DLD (max, args, nargout, |
3443 | 762 "-*- texinfo -*-\n\ |
8780
ea76466605ba
support native cumsum, gripe on overflow in sum/cumsum
Jaroslav Hajek <highegg@gmail.com>
parents:
8778
diff
changeset
|
763 @deftypefn {Loadable Function} {} max (@var{x}, @var{y}, @var{dim})\n\ |
ea76466605ba
support native cumsum, gripe on overflow in sum/cumsum
Jaroslav Hajek <highegg@gmail.com>
parents:
8778
diff
changeset
|
764 @deftypefnx {Loadable Function} {[@var{w}, @var{iw}] =} max (@var{x})\n\ |
4522 | 765 @cindex Utility Functions\n\ |
3443 | 766 For a vector argument, return the maximum value. For a matrix\n\ |
767 argument, return the maximum value from each column, as a row\n\ | |
9064
7c02ec148a3c
Check grammar on all .cc files
Rik <rdrider0-list@yahoo.com>
parents:
8949
diff
changeset
|
768 vector, or over the dimension @var{dim} if defined. For two matrices\n\ |
4844 | 769 (or a matrix and scalar), return the pair-wise maximum.\n\ |
4522 | 770 Thus,\n\ |
3443 | 771 \n\ |
772 @example\n\ | |
773 max (max (@var{x}))\n\ | |
774 @end example\n\ | |
775 \n\ | |
776 @noindent\n\ | |
4522 | 777 returns the largest element of @var{x}, and\n\ |
778 \n\ | |
779 @example\n\ | |
780 @group\n\ | |
781 max (2:5, pi)\n\ | |
782 @result{} 3.1416 3.1416 4.0000 5.0000\n\ | |
783 @end group\n\ | |
784 @end example\n\ | |
785 @noindent\n\ | |
786 compares each element of the range @code{2:5} with @code{pi}, and\n\ | |
787 returns a row vector of the maximum values.\n\ | |
3443 | 788 \n\ |
789 For complex arguments, the magnitude of the elements are used for\n\ | |
3775 | 790 comparison.\n\ |
3657 | 791 \n\ |
4522 | 792 If called with one input and two output arguments,\n\ |
793 @code{max} also returns the first index of the\n\ | |
9064
7c02ec148a3c
Check grammar on all .cc files
Rik <rdrider0-list@yahoo.com>
parents:
8949
diff
changeset
|
794 maximum value(s). Thus,\n\ |
4522 | 795 \n\ |
3775 | 796 @example\n\ |
4522 | 797 @group\n\ |
798 [x, ix] = max ([1, 3, 5, 2, 5])\n\ | |
799 @result{} x = 5\n\ | |
800 ix = 3\n\ | |
801 @end group\n\ | |
3657 | 802 @end example\n\ |
4522 | 803 @end deftypefn") |
2928 | 804 { |
3747 | 805 MINMAX_BODY (max); |
2928 | 806 } |
807 | |
7600
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
808 /* |
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
809 |
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
810 %% test/octave.test/arith/max-1.m |
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
811 %!assert (max ([1, 4, 2, 3]) == 4); |
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
812 %!assert (max ([1; -10; 5; -2]) == 5); |
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
813 |
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
814 %% test/octave.test/arith/max-2.m |
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
815 %!assert(all (max ([4, i 4.999; -2, 2, 3+4i]) == [4, 2, 3+4i])); |
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
816 |
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
817 %% test/octave.test/arith/max-3.m |
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
818 %!error <Invalid call to max.*> max (); |
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
819 |
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
820 %% test/octave.test/arith/max-4.m |
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
821 %!error <Invalid call to max.*> max (1, 2, 3, 4); |
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
822 |
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
823 %!test |
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
824 %! x = reshape (1:8,[2,2,2]); |
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
825 %! assert (min (x,[],1), reshape ([1, 3, 5, 7], [1,2,2])); |
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
826 %! assert (min (x,[],2), reshape ([1, 2, 5, 6], [2,1,2])); |
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
827 %! [y, i ] = min (x, [], 3); |
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
828 %! assert (y, [1, 3; 2, 4]); |
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
829 %! assert (ndims(y), 2); |
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
830 %! assert (i, [1, 1; 1, 1]); |
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
831 %! assert (ndims(i), 2); |
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
832 |
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
833 |
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
834 */ |
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
835 |
8777
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
836 #define CUMMINMAX_BODY(FCN) \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
837 \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
838 octave_value_list retval; \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
839 \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
840 int nargin = args.length (); \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
841 \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
842 if (nargin < 1 || nargin > 2 || nargout > 2) \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
843 { \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
844 print_usage (); \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
845 return retval; \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
846 } \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
847 \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
848 octave_value arg1; \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
849 octave_value arg2; \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
850 \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
851 switch (nargin) \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
852 { \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
853 case 2: \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
854 arg2 = args(1); \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
855 \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
856 case 1: \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
857 arg1 = args(0); \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
858 break; \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
859 \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
860 default: \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
861 panic_impossible (); \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
862 break; \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
863 } \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
864 \ |
8949
e31d47f2c9bb
fixes to row-reducing cummin/cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
8948
diff
changeset
|
865 int dim; \ |
8777
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
866 dim_vector dv = arg1.dims (); \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
867 if (error_state) \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
868 { \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
869 gripe_wrong_type_arg (#FCN, arg1); \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
870 return retval; \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
871 } \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
872 \ |
8949
e31d47f2c9bb
fixes to row-reducing cummin/cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
8948
diff
changeset
|
873 if (nargin == 2) \ |
e31d47f2c9bb
fixes to row-reducing cummin/cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
8948
diff
changeset
|
874 { \ |
e31d47f2c9bb
fixes to row-reducing cummin/cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
8948
diff
changeset
|
875 dim = arg2.nint_value () - 1; \ |
e31d47f2c9bb
fixes to row-reducing cummin/cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
8948
diff
changeset
|
876 if (dim < 0 || dim >= dv.length ()) \ |
e31d47f2c9bb
fixes to row-reducing cummin/cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
8948
diff
changeset
|
877 { \ |
e31d47f2c9bb
fixes to row-reducing cummin/cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
8948
diff
changeset
|
878 error ("%s: invalid dimension", #FCN); \ |
e31d47f2c9bb
fixes to row-reducing cummin/cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
8948
diff
changeset
|
879 return retval; \ |
e31d47f2c9bb
fixes to row-reducing cummin/cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
8948
diff
changeset
|
880 } \ |
e31d47f2c9bb
fixes to row-reducing cummin/cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
8948
diff
changeset
|
881 } \ |
e31d47f2c9bb
fixes to row-reducing cummin/cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
8948
diff
changeset
|
882 else \ |
e31d47f2c9bb
fixes to row-reducing cummin/cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
8948
diff
changeset
|
883 { \ |
e31d47f2c9bb
fixes to row-reducing cummin/cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
8948
diff
changeset
|
884 dim = 0; \ |
e31d47f2c9bb
fixes to row-reducing cummin/cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
8948
diff
changeset
|
885 while ((dim < dv.length ()) && (dv (dim) <= 1)) \ |
e31d47f2c9bb
fixes to row-reducing cummin/cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
8948
diff
changeset
|
886 dim++; \ |
e31d47f2c9bb
fixes to row-reducing cummin/cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
8948
diff
changeset
|
887 if (dim == dv.length ()) \ |
e31d47f2c9bb
fixes to row-reducing cummin/cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
8948
diff
changeset
|
888 dim = 0; \ |
e31d47f2c9bb
fixes to row-reducing cummin/cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
8948
diff
changeset
|
889 } \ |
8777
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
890 \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
891 if (arg1.is_integer_type ()) \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
892 { \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
893 if (arg1.is_uint8_type ()) \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
894 MINMAX_INT_SBODY (FCN, uint8) \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
895 else if (arg1.is_uint16_type ()) \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
896 MINMAX_INT_SBODY (FCN, uint16) \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
897 else if (arg1.is_uint32_type ()) \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
898 MINMAX_INT_SBODY (FCN, uint32) \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
899 else if (arg1.is_uint64_type ()) \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
900 MINMAX_INT_SBODY (FCN, uint64) \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
901 else if (arg1.is_int8_type ()) \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
902 MINMAX_INT_SBODY (FCN, int8) \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
903 else if (arg1.is_int16_type ()) \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
904 MINMAX_INT_SBODY (FCN, int16) \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
905 else if (arg1.is_int32_type ()) \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
906 MINMAX_INT_SBODY (FCN, int32) \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
907 else if (arg1.is_int64_type ()) \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
908 MINMAX_INT_SBODY (FCN, int64) \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
909 } \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
910 else if (arg1.is_single_type ()) \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
911 MINMAX_SINGLE_SBODY (FCN) \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
912 else \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
913 MINMAX_DOUBLE_SBODY (FCN) \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
914 \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
915 return retval; |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
916 |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
917 DEFUN_DLD (cummin, args, nargout, |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
918 "-*- texinfo -*-\n\ |
8780
ea76466605ba
support native cumsum, gripe on overflow in sum/cumsum
Jaroslav Hajek <highegg@gmail.com>
parents:
8778
diff
changeset
|
919 @deftypefn {Loadable Function} {} cummin (@var{x}, @var{dim})\n\ |
ea76466605ba
support native cumsum, gripe on overflow in sum/cumsum
Jaroslav Hajek <highegg@gmail.com>
parents:
8778
diff
changeset
|
920 @deftypefnx {Loadable Function} {[@var{w}, @var{iw}] =} cummin (@var{x})\n\ |
8777
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
921 @cindex Utility Functions\n\ |
9064
7c02ec148a3c
Check grammar on all .cc files
Rik <rdrider0-list@yahoo.com>
parents:
8949
diff
changeset
|
922 Return the cumulative minimum values. That means, the call\n\ |
8777
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
923 @example\n\ |
8948
3e161cae0bc6
update cummin, cummax docs
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
924 [w, iw] = cummin (x, dim)\n\ |
8777
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
925 @end example\n\ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
926 \n\ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
927 @noindent\n\ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
928 is equivalent to the following code:\n\ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
929 @example\n\ |
9064
7c02ec148a3c
Check grammar on all .cc files
Rik <rdrider0-list@yahoo.com>
parents:
8949
diff
changeset
|
930 @group\n\ |
8949
e31d47f2c9bb
fixes to row-reducing cummin/cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
8948
diff
changeset
|
931 w = iw = zeros (size (x));\n\ |
e31d47f2c9bb
fixes to row-reducing cummin/cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
8948
diff
changeset
|
932 idxw = idxx = repmat (@{':'@}, 1, ndims (x));\n\ |
8777
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
933 for i = 1:size (x, dim)\n\ |
8949
e31d47f2c9bb
fixes to row-reducing cummin/cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
8948
diff
changeset
|
934 idxw@{dim@} = i; idxx@{dim@} = 1:i;\n\ |
9064
7c02ec148a3c
Check grammar on all .cc files
Rik <rdrider0-list@yahoo.com>
parents:
8949
diff
changeset
|
935 [w(idxw@{:@}), iw(idxw@{:@})] =\\n\ |
8949
e31d47f2c9bb
fixes to row-reducing cummin/cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
8948
diff
changeset
|
936 min(x(idxx@{:@}), [], dim);\n\ |
8777
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
937 endfor\n\ |
9064
7c02ec148a3c
Check grammar on all .cc files
Rik <rdrider0-list@yahoo.com>
parents:
8949
diff
changeset
|
938 @end group\n\ |
8777
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
939 @end example\n\ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
940 \n\ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
941 @noindent\n\ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
942 but computed in a much faster manner.\n\ |
9065
8207b833557f
Cleanup documentation for arith.texi, linalg.texi, nonlin.texi
Rik <rdrider0-list@yahoo.com>
parents:
9064
diff
changeset
|
943 The behavior if @var{dim} or @var{iw} is unspecified is analogous\n\ |
8777
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
944 to @code{min}.\n\ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
945 @end deftypefn") |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
946 { |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
947 CUMMINMAX_BODY (cummin); |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
948 } |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
949 |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
950 DEFUN_DLD (cummax, args, nargout, |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
951 "-*- texinfo -*-\n\ |
8780
ea76466605ba
support native cumsum, gripe on overflow in sum/cumsum
Jaroslav Hajek <highegg@gmail.com>
parents:
8778
diff
changeset
|
952 @deftypefn {Loadable Function} {} cummax (@var{x}, @var{dim})\n\ |
ea76466605ba
support native cumsum, gripe on overflow in sum/cumsum
Jaroslav Hajek <highegg@gmail.com>
parents:
8778
diff
changeset
|
953 @deftypefnx {Loadable Function} {[@var{w}, @var{iw}] =} cummax (@var{x})\n\ |
8777
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
954 @cindex Utility Functions\n\ |
9064
7c02ec148a3c
Check grammar on all .cc files
Rik <rdrider0-list@yahoo.com>
parents:
8949
diff
changeset
|
955 Return the cumulative maximum values. That means, the call\n\ |
8777
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
956 @example\n\ |
8948
3e161cae0bc6
update cummin, cummax docs
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
957 [w, iw] = cummax (x, dim)\n\ |
8777
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
958 @end example\n\ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
959 \n\ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
960 @noindent\n\ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
961 is equivalent to the following code:\n\ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
962 @example\n\ |
9064
7c02ec148a3c
Check grammar on all .cc files
Rik <rdrider0-list@yahoo.com>
parents:
8949
diff
changeset
|
963 @group\n\ |
8949
e31d47f2c9bb
fixes to row-reducing cummin/cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
8948
diff
changeset
|
964 w = iw = zeros (size (x));\n\ |
e31d47f2c9bb
fixes to row-reducing cummin/cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
8948
diff
changeset
|
965 idxw = idxx = repmat (@{':'@}, 1, ndims (x));\n\ |
8777
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
966 for i = 1:size (x, dim)\n\ |
8949
e31d47f2c9bb
fixes to row-reducing cummin/cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
8948
diff
changeset
|
967 idxw@{dim@} = i; idxx@{dim@} = 1:i;\n\ |
9064
7c02ec148a3c
Check grammar on all .cc files
Rik <rdrider0-list@yahoo.com>
parents:
8949
diff
changeset
|
968 [w(idxw@{:@}), iw(idxw@{:@})] =\\n\ |
8949
e31d47f2c9bb
fixes to row-reducing cummin/cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
8948
diff
changeset
|
969 max(x(idxx@{:@}), [], dim);\n\ |
8777
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
970 endfor\n\ |
9064
7c02ec148a3c
Check grammar on all .cc files
Rik <rdrider0-list@yahoo.com>
parents:
8949
diff
changeset
|
971 @end group\n\ |
8777
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
972 @end example\n\ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
973 \n\ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
974 @noindent\n\ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
975 but computed in a much faster manner.\n\ |
9065
8207b833557f
Cleanup documentation for arith.texi, linalg.texi, nonlin.texi
Rik <rdrider0-list@yahoo.com>
parents:
9064
diff
changeset
|
976 The behavior if @var{dim} or @var{iw} is unspecified is analogous\n\ |
8777
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
977 to @code{max}.\n\ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
978 @end deftypefn") |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
979 { |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
980 CUMMINMAX_BODY (cummax); |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
981 } |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
982 |
2928 | 983 /* |
984 ;;; Local Variables: *** | |
985 ;;; mode: C++ *** | |
986 ;;; End: *** | |
987 */ |