Mercurial > octave
annotate src/DLD-FUNCTIONS/bsxfun.cc @ 8920:eb63fbe60fab
update copyright notices
author | John W. Eaton <jwe@octave.org> |
---|---|
date | Sat, 07 Mar 2009 10:41:27 -0500 |
parents | 954b6f69f51d |
children | 853f96e8008f |
rev | line source |
---|---|
6869 | 1 /* |
2 | |
8920 | 3 Copyright (C) 2007, 2008, 2009 David Bateman |
6869 | 4 |
5 This file is part of Octave. | |
6 | |
7 Octave is free software; you can redistribute it and/or modify it | |
8 under the terms of the GNU General Public License as published by the | |
7016 | 9 Free Software Foundation; either version 3 of the License, or (at your |
10 option) any later version. | |
6869 | 11 |
12 Octave is distributed in the hope that it will be useful, but WITHOUT | |
13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
15 for more details. | |
16 | |
17 You should have received a copy of the GNU General Public License | |
7016 | 18 along with Octave; see the file COPYING. If not, see |
19 <http://www.gnu.org/licenses/>. | |
6869 | 20 |
21 */ | |
22 | |
23 #ifdef HAVE_CONFIG_H | |
24 #include <config.h> | |
25 #endif | |
26 | |
27 #include <string> | |
28 #include <vector> | |
29 #include <list> | |
30 | |
31 #include "lo-mappers.h" | |
32 | |
33 #include "oct-map.h" | |
34 #include "defun-dld.h" | |
35 #include "parse.h" | |
36 #include "variables.h" | |
37 #include "ov-colon.h" | |
38 #include "unwind-prot.h" | |
39 | |
40 static bool | |
41 maybe_update_column (octave_value& Ac, const octave_value& A, | |
42 const dim_vector& dva, const dim_vector& dvc, | |
43 octave_idx_type i, octave_value_list &idx) | |
44 { | |
45 octave_idx_type nd = dva.length (); | |
46 | |
47 if (i == 0) | |
48 { | |
49 idx(0) = octave_value (':'); | |
50 for (octave_idx_type j = 1; j < nd; j++) | |
51 { | |
52 if (dva (j) == 1) | |
53 idx (j) = octave_value (1); | |
54 else | |
55 idx (j) = octave_value ((i % dvc(j)) + 1); | |
56 | |
57 i = i / dvc (j); | |
58 } | |
59 | |
60 Ac = A; | |
61 Ac = Ac.single_subsref ("(", idx); | |
62 return true; | |
63 } | |
64 else | |
65 { | |
66 bool is_changed = false; | |
67 octave_idx_type k = i; | |
68 octave_idx_type k1 = i - 1; | |
69 for (octave_idx_type j = 1; j < nd; j++) | |
70 { | |
71 if (dva(j) != 1 && k % dvc (j) != k1 % dvc (j)) | |
72 { | |
73 idx (j) = octave_value ((k % dvc(j)) + 1); | |
74 is_changed = true; | |
75 } | |
76 | |
77 k = k / dvc (j); | |
78 k1 = k1 / dvc (j); | |
79 } | |
80 | |
81 if (is_changed) | |
82 { | |
83 Ac = A; | |
84 Ac = Ac.single_subsref ("(", idx); | |
85 return true; | |
86 } | |
87 else | |
88 return false; | |
89 } | |
90 } | |
91 | |
6959 | 92 #if 0 |
93 // FIXME -- this function is not used; is it OK to delete it? | |
6869 | 94 static void |
95 update_index (octave_value_list& idx, const dim_vector& dv, octave_idx_type i) | |
96 { | |
97 octave_idx_type nd = dv.length (); | |
98 | |
99 if (i == 0) | |
100 { | |
101 for (octave_idx_type j = nd - 1; j > 0; j--) | |
102 idx(j) = octave_value (static_cast<double>(1)); | |
103 idx(0) = octave_value (':'); | |
104 } | |
105 else | |
106 { | |
107 for (octave_idx_type j = 1; j < nd; j++) | |
108 { | |
109 idx (j) = octave_value (i % dv (j) + 1); | |
110 i = i / dv (j); | |
111 } | |
112 } | |
113 } | |
6959 | 114 #endif |
6869 | 115 |
116 static void | |
117 update_index (Array<int>& idx, const dim_vector& dv, octave_idx_type i) | |
118 { | |
119 octave_idx_type nd = dv.length (); | |
120 | |
121 idx(0) = 0; | |
122 for (octave_idx_type j = 1; j < nd; j++) | |
123 { | |
124 idx (j) = i % dv (j); | |
125 i = i / dv (j); | |
126 } | |
127 } | |
128 | |
6959 | 129 DEFUN_DLD (bsxfun, args, , |
8715 | 130 "-*- texinfo -*-\n\ |
7001 | 131 @deftypefn {Loadable Function} {} bsxfun (@var{f}, @var{a}, @var{b})\n\ |
6869 | 132 Applies a binary function @var{f} element-wise to two matrix arguments\n\ |
133 @var{a} and @var{b}. The function @var{f} must be capable of accepting\n\ | |
134 two column vector arguments of equal length, or one column vector\n\ | |
135 argument and a scalar.\n\ | |
136 \n\ | |
137 The dimensions of @var{a} and @var{b} must be equal or singleton. The\n\ | |
7001 | 138 singleton dimensions of the matrices will be expanded to the same\n\ |
6881 | 139 dimensionality as the other matrix.\n\ |
6869 | 140 \n\ |
141 @seealso{arrayfun, cellfun}\n\ | |
142 @end deftypefn") | |
143 { | |
144 int nargin = args.length (); | |
145 octave_value_list retval; | |
146 | |
147 if (nargin != 3) | |
148 print_usage (); | |
149 else | |
150 { | |
151 octave_function *func = 0; | |
152 std::string name; | |
153 std::string fcn_name; | |
154 | |
155 if (args(0).is_function_handle () || args(0).is_inline_function ()) | |
156 func = args(0).function_value (); | |
157 else if (args(0).is_string ()) | |
158 { | |
159 name = args(0).string_value (); | |
160 fcn_name = unique_symbol_name ("__bsxfun_fcn_"); | |
161 std::string fname = "function y = "; | |
162 fname.append (fcn_name); | |
163 fname.append ("(x) y = "); | |
164 func = extract_function (args(0), "bsxfun", fcn_name, fname, | |
165 "; endfunction"); | |
166 } | |
167 else | |
168 error ("bsxfun: first argument must be a string or function handle"); | |
169 | |
170 if (! error_state) | |
171 { | |
172 const octave_value A = args (1); | |
173 dim_vector dva = A.dims (); | |
174 octave_idx_type nda = dva.length (); | |
175 const octave_value B = args (2); | |
176 dim_vector dvb = B.dims (); | |
177 octave_idx_type ndb = dvb.length (); | |
178 octave_idx_type nd = nda; | |
179 | |
180 if (nda > ndb) | |
181 dvb.resize (nda, 1); | |
182 else if (nda < ndb) | |
183 { | |
184 dva.resize (ndb, 1); | |
185 nd = ndb; | |
186 } | |
187 | |
188 for (octave_idx_type i = 0; i < nd; i++) | |
189 if (dva (i) != dvb (i) && dva (i) != 1 && dvb (i) != 1) | |
190 { | |
191 error ("bsxfun: dimensions don't match"); | |
192 break; | |
193 } | |
194 | |
195 if (!error_state) | |
196 { | |
197 // Find the size of the output | |
198 dim_vector dvc; | |
199 dvc.resize (nd); | |
200 | |
201 for (octave_idx_type i = 0; i < nd; i++) | |
202 dvc (i) = (dva (i) < 1 ? dva (i) : (dvb (i) < 1 ? dvb (i) : | |
203 (dva (i) > dvb (i) ? dva (i) : dvb (i)))); | |
204 | |
205 if (dva == dvb || dva.numel () == 1 || dvb.numel () == 1) | |
206 { | |
207 octave_value_list inputs; | |
208 inputs (0) = A; | |
209 inputs (1) = B; | |
210 retval = feval (func, inputs, 1); | |
211 } | |
212 else if (dvc.numel () < 1) | |
213 { | |
214 octave_value_list inputs; | |
215 inputs (0) = A.resize (dvc); | |
216 inputs (1) = B.resize (dvc); | |
217 retval = feval (func, inputs, 1); | |
218 } | |
219 else | |
220 { | |
221 octave_idx_type ncount = 1; | |
222 for (octave_idx_type i = 1; i < nd; i++) | |
223 ncount *= dvc (i); | |
224 | |
225 #define BSXDEF(T) \ | |
226 T result_ ## T; \ | |
227 bool have_ ## T = false; | |
228 | |
229 BSXDEF(NDArray); | |
230 BSXDEF(ComplexNDArray); | |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
231 BSXDEF(FloatNDArray); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
232 BSXDEF(FloatComplexNDArray); |
6869 | 233 BSXDEF(boolNDArray); |
234 BSXDEF(int8NDArray); | |
235 BSXDEF(int16NDArray); | |
236 BSXDEF(int32NDArray); | |
237 BSXDEF(int64NDArray); | |
238 BSXDEF(uint8NDArray); | |
239 BSXDEF(uint16NDArray); | |
240 BSXDEF(uint32NDArray); | |
241 BSXDEF(uint64NDArray); | |
242 | |
243 octave_value Ac ; | |
244 octave_value_list idxA; | |
245 octave_value Bc; | |
246 octave_value_list idxB; | |
247 octave_value C; | |
248 octave_value_list inputs; | |
249 Array<int> ra_idx (dvc.length(), 0); | |
250 | |
251 | |
252 for (octave_idx_type i = 0; i < ncount; i++) | |
253 { | |
254 if (maybe_update_column (Ac, A, dva, dvc, i, idxA)) | |
255 inputs (0) = Ac; | |
256 | |
257 if (maybe_update_column (Bc, B, dvb, dvc, i, idxB)) | |
258 inputs (1) = Bc; | |
259 | |
260 octave_value_list tmp = feval (func, inputs, 1); | |
261 | |
262 if (error_state) | |
263 break; | |
264 | |
265 #define BSXINIT(T, CLS, EXTRACTOR) \ | |
266 (result_type == CLS) \ | |
267 { \ | |
268 have_ ## T = true; \ | |
269 result_ ## T = \ | |
270 tmp (0). EXTRACTOR ## _array_value (); \ | |
271 result_ ## T .resize (dvc); \ | |
272 } | |
273 | |
274 if (i == 0) | |
275 { | |
276 if (! tmp(0).is_sparse_type ()) | |
277 { | |
278 std::string result_type = tmp(0).class_name (); | |
279 if (result_type == "double") | |
280 { | |
281 if (tmp(0).is_real_type ()) | |
282 { | |
283 have_NDArray = true; | |
284 result_NDArray = tmp(0).array_value (); | |
285 result_NDArray.resize (dvc); | |
286 } | |
287 else | |
288 { | |
289 have_ComplexNDArray = true; | |
290 result_ComplexNDArray = | |
291 tmp(0).complex_array_value (); | |
292 result_ComplexNDArray.resize (dvc); | |
293 } | |
294 } | |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
295 else if (result_type == "single") |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
296 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
297 if (tmp(0).is_real_type ()) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
298 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
299 have_FloatNDArray = true; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
300 result_FloatNDArray = tmp(0).float_array_value (); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
301 result_FloatNDArray.resize (dvc); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
302 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
303 else |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
304 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
305 have_ComplexNDArray = true; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
306 result_ComplexNDArray = |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
307 tmp(0).complex_array_value (); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
308 result_ComplexNDArray.resize (dvc); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
309 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
310 } |
6869 | 311 else if BSXINIT(boolNDArray, "logical", bool) |
312 else if BSXINIT(int8NDArray, "int8", int8) | |
313 else if BSXINIT(int16NDArray, "int16", int16) | |
314 else if BSXINIT(int32NDArray, "int32", int32) | |
315 else if BSXINIT(int64NDArray, "int64", int64) | |
316 else if BSXINIT(uint8NDArray, "uint8", uint8) | |
317 else if BSXINIT(uint16NDArray, "uint16", uint16) | |
318 else if BSXINIT(uint32NDArray, "uint32", uint32) | |
319 else if BSXINIT(uint64NDArray, "uint64", uint64) | |
320 else | |
321 { | |
322 C = tmp (0); | |
323 C = C.resize (dvc); | |
324 } | |
325 } | |
326 } | |
327 else | |
328 { | |
329 update_index (ra_idx, dvc, i); | |
330 | |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
331 if (have_FloatNDArray || |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
332 have_FloatComplexNDArray) |
6869 | 333 { |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
334 if (! tmp(0).is_float_type ()) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
335 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
336 if (have_FloatNDArray) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
337 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
338 have_FloatNDArray = false; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
339 C = result_FloatNDArray; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
340 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
341 else |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
342 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
343 have_FloatComplexNDArray = false; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
344 C = result_FloatComplexNDArray; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
345 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
346 C = do_cat_op (C, tmp(0), ra_idx); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
347 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
348 else if (tmp(0).is_double_type ()) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
349 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
350 if (tmp(0).is_complex_type () && |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
351 have_FloatNDArray) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
352 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
353 result_ComplexNDArray = |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
354 ComplexNDArray (result_FloatNDArray); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
355 result_ComplexNDArray.insert |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
356 (tmp(0).complex_array_value(), ra_idx); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
357 have_FloatComplexNDArray = false; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
358 have_ComplexNDArray = true; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
359 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
360 else |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
361 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
362 result_NDArray = |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
363 NDArray (result_FloatNDArray); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
364 result_NDArray.insert |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
365 (tmp(0).array_value(), ra_idx); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
366 have_FloatNDArray = false; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
367 have_NDArray = true; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
368 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
369 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
370 else if (tmp(0).is_real_type ()) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
371 result_FloatNDArray.insert |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
372 (tmp(0).float_array_value(), ra_idx); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
373 else |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
374 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
375 result_FloatComplexNDArray = |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
376 FloatComplexNDArray (result_FloatNDArray); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
377 result_FloatComplexNDArray.insert |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
378 (tmp(0).float_complex_array_value(), ra_idx); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
379 have_FloatNDArray = false; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
380 have_FloatComplexNDArray = true; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
381 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
382 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
383 else if (have_NDArray) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
384 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
385 if (! tmp(0).is_float_type ()) |
6869 | 386 { |
387 have_NDArray = false; | |
388 C = result_NDArray; | |
389 C = do_cat_op (C, tmp(0), ra_idx); | |
390 } | |
391 else if (tmp(0).is_real_type ()) | |
392 result_NDArray.insert (tmp(0).array_value(), | |
393 ra_idx); | |
394 else | |
395 { | |
396 result_ComplexNDArray = | |
397 ComplexNDArray (result_NDArray); | |
398 result_ComplexNDArray.insert | |
399 (tmp(0).complex_array_value(), ra_idx); | |
400 have_NDArray = false; | |
401 have_ComplexNDArray = true; | |
402 } | |
403 } | |
404 | |
405 #define BSXLOOP(T, CLS, EXTRACTOR) \ | |
406 (have_ ## T) \ | |
407 { \ | |
408 if (tmp (0).class_name () != CLS) \ | |
409 { \ | |
410 have_ ## T = false; \ | |
411 C = result_ ## T; \ | |
412 C = do_cat_op (C, tmp (0), ra_idx); \ | |
413 } \ | |
414 else \ | |
415 result_ ## T .insert \ | |
416 (tmp(0). EXTRACTOR ## _array_value (), \ | |
417 ra_idx); \ | |
418 } | |
419 | |
420 else if BSXLOOP(ComplexNDArray, "double", complex) | |
421 else if BSXLOOP(boolNDArray, "logical", bool) | |
422 else if BSXLOOP(int8NDArray, "int8", int8) | |
423 else if BSXLOOP(int16NDArray, "int16", int16) | |
424 else if BSXLOOP(int32NDArray, "int32", int32) | |
425 else if BSXLOOP(int64NDArray, "int64", int64) | |
426 else if BSXLOOP(uint8NDArray, "uint8", uint8) | |
427 else if BSXLOOP(uint16NDArray, "uint16", uint16) | |
428 else if BSXLOOP(uint32NDArray, "uint32", uint32) | |
429 else if BSXLOOP(uint64NDArray, "uint64", uint64) | |
430 else | |
431 C = do_cat_op (C, tmp(0), ra_idx); | |
432 } | |
433 } | |
434 | |
435 #define BSXEND(T) \ | |
436 (have_ ## T) \ | |
437 retval (0) = result_ ## T; | |
438 | |
439 if BSXEND(NDArray) | |
440 else if BSXEND(ComplexNDArray) | |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
441 else if BSXEND(FloatNDArray) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7016
diff
changeset
|
442 else if BSXEND(FloatComplexNDArray) |
6869 | 443 else if BSXEND(boolNDArray) |
444 else if BSXEND(int8NDArray) | |
445 else if BSXEND(int16NDArray) | |
446 else if BSXEND(int32NDArray) | |
447 else if BSXEND(int64NDArray) | |
448 else if BSXEND(uint8NDArray) | |
449 else if BSXEND(uint16NDArray) | |
450 else if BSXEND(uint32NDArray) | |
451 else if BSXEND(uint64NDArray) | |
452 else | |
453 retval(0) = C; | |
454 } | |
455 } | |
456 } | |
457 | |
458 if (! fcn_name.empty ()) | |
459 clear_function (fcn_name); | |
460 } | |
461 | |
462 return retval; | |
463 } | |
464 | |
465 /* | |
466 | |
467 %!shared a, b, c, f | |
468 %! a = randn (4, 4); | |
469 %! b = mean (a, 1); | |
470 %! c = mean (a, 2); | |
471 %! f = @minus; | |
472 %!error(bsxfun (f)); | |
473 %!error(bsxfun (f, a)); | |
474 %!error(bsxfun (a, b)); | |
475 %!error(bsxfun (a, b, c)); | |
476 %!error(bsxfun (f, a, b, c)); | |
477 %!error(bsxfun (f, ones(4, 0), ones(4, 4))) | |
478 %!assert(bsxfun (f, ones(4, 0), ones(4, 1)), zeros(4, 0)); | |
479 %!assert(bsxfun (f, ones(1, 4), ones(4, 1)), zeros(4, 4)); | |
480 %!assert(bsxfun (f, a, b), a - repmat(b, 4, 1)); | |
481 %!assert(bsxfun (f, a, c), a - repmat(c, 1, 4)); | |
482 %!assert(bsxfun ("minus", ones(1, 4), ones(4, 1)), zeros(4, 4)); | |
483 | |
484 %!shared a, b, c, f | |
485 %! a = randn (4, 4); | |
486 %! a(1) *= 1i; | |
487 %! b = mean (a, 1); | |
488 %! c = mean (a, 2); | |
489 %! f = @minus; | |
490 %!error(bsxfun (f)); | |
491 %!error(bsxfun (f, a)); | |
492 %!error(bsxfun (a, b)); | |
493 %!error(bsxfun (a, b, c)); | |
494 %!error(bsxfun (f, a, b, c)); | |
495 %!error(bsxfun (f, ones(4, 0), ones(4, 4))) | |
496 %!assert(bsxfun (f, ones(4, 0), ones(4, 1)), zeros(4, 0)); | |
497 %!assert(bsxfun (f, ones(1, 4), ones(4, 1)), zeros(4, 4)); | |
498 %!assert(bsxfun (f, a, b), a - repmat(b, 4, 1)); | |
499 %!assert(bsxfun (f, a, c), a - repmat(c, 1, 4)); | |
500 %!assert(bsxfun ("minus", ones(1, 4), ones(4, 1)), zeros(4, 4)); | |
501 | |
502 %!shared a, b, c, f | |
503 %! a = randn (4, 4); | |
504 %! a(end) *= 1i; | |
505 %! b = mean (a, 1); | |
506 %! c = mean (a, 2); | |
507 %! f = @minus; | |
508 %!error(bsxfun (f)); | |
509 %!error(bsxfun (f, a)); | |
510 %!error(bsxfun (a, b)); | |
511 %!error(bsxfun (a, b, c)); | |
512 %!error(bsxfun (f, a, b, c)); | |
513 %!error(bsxfun (f, ones(4, 0), ones(4, 4))) | |
514 %!assert(bsxfun (f, ones(4, 0), ones(4, 1)), zeros(4, 0)); | |
515 %!assert(bsxfun (f, ones(1, 4), ones(4, 1)), zeros(4, 4)); | |
516 %!assert(bsxfun (f, a, b), a - repmat(b, 4, 1)); | |
517 %!assert(bsxfun (f, a, c), a - repmat(c, 1, 4)); | |
518 %!assert(bsxfun ("minus", ones(1, 4), ones(4, 1)), zeros(4, 4)); | |
519 | |
520 %!shared a, b, c, f | |
521 %! a = randn (4, 4); | |
522 %! b = a (1, :); | |
523 %! c = a (:, 1); | |
524 %! f = @(x, y) x == y; | |
525 %!error(bsxfun (f)); | |
526 %!error(bsxfun (f, a)); | |
527 %!error(bsxfun (a, b)); | |
528 %!error(bsxfun (a, b, c)); | |
529 %!error(bsxfun (f, a, b, c)); | |
530 %!error(bsxfun (f, ones(4, 0), ones(4, 4))) | |
531 %!assert(bsxfun (f, ones(4, 0), ones(4, 1)), zeros(4, 0, "logical")); | |
532 %!assert(bsxfun (f, ones(1, 4), ones(4, 1)), ones(4, 4, "logical")); | |
533 %!assert(bsxfun (f, a, b), a == repmat(b, 4, 1)); | |
534 %!assert(bsxfun (f, a, c), a == repmat(c, 1, 4)); | |
535 | |
536 %!shared a, b, c, d, f | |
537 %! a = randn (4, 4, 4); | |
538 %! b = mean (a, 1); | |
539 %! c = mean (a, 2); | |
540 %! d = mean (a, 3); | |
541 %! f = @minus; | |
542 %!error(bsxfun (f, ones([4, 0, 4]), ones([4, 4, 4]))); | |
543 %!assert(bsxfun (f, ones([4, 0, 4]), ones([4, 1, 4])), zeros([4, 0, 4])); | |
544 %!assert(bsxfun (f, ones([4, 4, 0]), ones([4, 1, 1])), zeros([4, 4, 0])); | |
545 %!assert(bsxfun (f, ones([1, 4, 4]), ones([4, 1, 4])), zeros([4, 4, 4])); | |
546 %!assert(bsxfun (f, ones([4, 4, 1]), ones([4, 1, 4])), zeros([4, 4, 4])); | |
547 %!assert(bsxfun (f, ones([4, 1, 4]), ones([1, 4, 4])), zeros([4, 4, 4])); | |
548 %!assert(bsxfun (f, ones([4, 1, 4]), ones([1, 4, 1])), zeros([4, 4, 4])); | |
549 %!assert(bsxfun (f, a, b), a - repmat(b, [4, 1, 1])); | |
550 %!assert(bsxfun (f, a, c), a - repmat(c, [1, 4, 1])); | |
551 %!assert(bsxfun (f, a, d), a - repmat(d, [1, 1, 4])); | |
552 %!assert(bsxfun ("minus", ones([4, 0, 4]), ones([4, 1, 4])), zeros([4, 0, 4])); | |
553 | |
554 %% The below is a very hard case to treat | |
555 %!assert(bsxfun (f, ones([4, 1, 4, 1]), ones([1, 4, 1, 4])), zeros([4, 4, 4, 4])); | |
556 | |
557 */ |