Mercurial > octave
annotate libinterp/corefcn/bsxfun.cc @ 19075:14bb81940528 stable
doc: Update docstring for datenum to describe format argument (bug #43181)
* datenum.m: Update docstring to describe the format argument exactly like
the docstring for datevec. Add test using format argument.
author | Mike Miller <mtmiller@ieee.org> |
---|---|
date | Wed, 10 Sep 2014 08:19:43 -0400 |
parents | 175b392e91fe |
children | 6a71e5030df5 |
rev | line source |
---|---|
6869 | 1 /* |
2 | |
17744
d63878346099
maint: Update copyright notices for release.
John W. Eaton <jwe@octave.org>
parents:
17245
diff
changeset
|
3 Copyright (C) 2007-2013 David Bateman |
9783
119d97db51f0
avoid repeated table init in bsxfun
Jaroslav Hajek <highegg@gmail.com>
parents:
9743
diff
changeset
|
4 Copyright (C) 2009 VZLU Prague |
6869 | 5 |
6 This file is part of Octave. | |
7 | |
8 Octave is free software; you can redistribute it and/or modify it | |
9 under the terms of the GNU General Public License as published by the | |
7016 | 10 Free Software Foundation; either version 3 of the License, or (at your |
11 option) any later version. | |
6869 | 12 |
13 Octave is distributed in the hope that it will be useful, but WITHOUT | |
14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
16 for more details. | |
17 | |
18 You should have received a copy of the GNU General Public License | |
7016 | 19 along with Octave; see the file COPYING. If not, see |
20 <http://www.gnu.org/licenses/>. | |
6869 | 21 |
22 */ | |
23 | |
24 #ifdef HAVE_CONFIG_H | |
25 #include <config.h> | |
26 #endif | |
27 | |
28 #include <string> | |
29 #include <vector> | |
30 #include <list> | |
31 | |
32 #include "lo-mappers.h" | |
33 | |
34 #include "oct-map.h" | |
15039
e753177cde93
maint: Move non-dynamically linked functions from DLD-FUNCTIONS/ to corefcn/ directory
Rik <rik@octave.org>
parents:
14854
diff
changeset
|
35 #include "defun.h" |
6869 | 36 #include "parse.h" |
37 #include "variables.h" | |
38 #include "ov-colon.h" | |
39 #include "unwind-prot.h" | |
9743
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
40 #include "ov-fcn-handle.h" |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
41 |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
42 // Optimized bsxfun operations |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
43 enum bsxfun_builtin_op |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
44 { |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
45 bsxfun_builtin_plus = 0, |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
46 bsxfun_builtin_minus, |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
47 bsxfun_builtin_times, |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
48 bsxfun_builtin_divide, |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
49 bsxfun_builtin_max, |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
50 bsxfun_builtin_min, |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
51 bsxfun_builtin_eq, |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
52 bsxfun_builtin_ne, |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
53 bsxfun_builtin_lt, |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
54 bsxfun_builtin_le, |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
55 bsxfun_builtin_gt, |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
56 bsxfun_builtin_ge, |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
57 bsxfun_builtin_and, |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
58 bsxfun_builtin_or, |
9827
c15a5ed0da58
optimize bsxfun (@power, ...)
Jaroslav Hajek <highegg@gmail.com>
parents:
9783
diff
changeset
|
59 bsxfun_builtin_power, |
9743
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
60 bsxfun_builtin_unknown, |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
61 bsxfun_num_builtin_ops = bsxfun_builtin_unknown |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
62 }; |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
63 |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
64 const char *bsxfun_builtin_names[] = |
9743
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
65 { |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
66 "plus", |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
67 "minus", |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
68 "times", |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
69 "rdivide", |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
70 "max", |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
71 "min", |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
72 "eq", |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
73 "ne", |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
74 "lt", |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
75 "le", |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
76 "gt", |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
77 "ge", |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
78 "and", |
9827
c15a5ed0da58
optimize bsxfun (@power, ...)
Jaroslav Hajek <highegg@gmail.com>
parents:
9783
diff
changeset
|
79 "or", |
c15a5ed0da58
optimize bsxfun (@power, ...)
Jaroslav Hajek <highegg@gmail.com>
parents:
9783
diff
changeset
|
80 "power" |
9743
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
81 }; |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
82 |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
83 static bsxfun_builtin_op |
9743
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
84 bsxfun_builtin_lookup (const std::string& name) |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
85 { |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
86 for (int i = 0; i < bsxfun_num_builtin_ops; i++) |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
87 if (name == bsxfun_builtin_names[i]) |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
88 return static_cast<bsxfun_builtin_op> (i); |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
89 return bsxfun_builtin_unknown; |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
90 } |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
91 |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
92 typedef octave_value (*bsxfun_handler) (const octave_value&, |
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
93 const octave_value&); |
9743
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
94 |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
95 // Static table of handlers. |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
96 bsxfun_handler bsxfun_handler_table[bsxfun_num_builtin_ops][btyp_num_types]; |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
97 |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
98 template <class NDA, NDA (bsxfun_op) (const NDA&, const NDA&)> |
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
99 static octave_value |
9743
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
100 bsxfun_forward_op (const octave_value& x, const octave_value& y) |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
101 { |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
102 NDA xa = octave_value_extract<NDA> (x); |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
103 NDA ya = octave_value_extract<NDA> (y); |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
104 return octave_value (bsxfun_op (xa, ya)); |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
105 } |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
106 |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
107 template <class NDA, boolNDArray (bsxfun_rel) (const NDA&, const NDA&)> |
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
108 static octave_value |
9743
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
109 bsxfun_forward_rel (const octave_value& x, const octave_value& y) |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
110 { |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
111 NDA xa = octave_value_extract<NDA> (x); |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
112 NDA ya = octave_value_extract<NDA> (y); |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
113 return octave_value (bsxfun_rel (xa, ya)); |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
114 } |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
115 |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
116 // pow() needs a special handler for reals |
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
117 // because of the potentially complex result. |
9827
c15a5ed0da58
optimize bsxfun (@power, ...)
Jaroslav Hajek <highegg@gmail.com>
parents:
9783
diff
changeset
|
118 template <class NDA, class CNDA> |
c15a5ed0da58
optimize bsxfun (@power, ...)
Jaroslav Hajek <highegg@gmail.com>
parents:
9783
diff
changeset
|
119 static octave_value |
c15a5ed0da58
optimize bsxfun (@power, ...)
Jaroslav Hajek <highegg@gmail.com>
parents:
9783
diff
changeset
|
120 do_bsxfun_real_pow (const octave_value& x, const octave_value& y) |
c15a5ed0da58
optimize bsxfun (@power, ...)
Jaroslav Hajek <highegg@gmail.com>
parents:
9783
diff
changeset
|
121 { |
c15a5ed0da58
optimize bsxfun (@power, ...)
Jaroslav Hajek <highegg@gmail.com>
parents:
9783
diff
changeset
|
122 NDA xa = octave_value_extract<NDA> (x); |
c15a5ed0da58
optimize bsxfun (@power, ...)
Jaroslav Hajek <highegg@gmail.com>
parents:
9783
diff
changeset
|
123 NDA ya = octave_value_extract<NDA> (y); |
c15a5ed0da58
optimize bsxfun (@power, ...)
Jaroslav Hajek <highegg@gmail.com>
parents:
9783
diff
changeset
|
124 if (! ya.all_integers () && xa.any_element_is_negative ()) |
c15a5ed0da58
optimize bsxfun (@power, ...)
Jaroslav Hajek <highegg@gmail.com>
parents:
9783
diff
changeset
|
125 return octave_value (bsxfun_pow (CNDA (xa), ya)); |
c15a5ed0da58
optimize bsxfun (@power, ...)
Jaroslav Hajek <highegg@gmail.com>
parents:
9783
diff
changeset
|
126 else |
c15a5ed0da58
optimize bsxfun (@power, ...)
Jaroslav Hajek <highegg@gmail.com>
parents:
9783
diff
changeset
|
127 return octave_value (bsxfun_pow (xa, ya)); |
c15a5ed0da58
optimize bsxfun (@power, ...)
Jaroslav Hajek <highegg@gmail.com>
parents:
9783
diff
changeset
|
128 } |
c15a5ed0da58
optimize bsxfun (@power, ...)
Jaroslav Hajek <highegg@gmail.com>
parents:
9783
diff
changeset
|
129 |
9743
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
130 static void maybe_fill_table (void) |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
131 { |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
132 static bool filled = false; |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
133 if (filled) |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
134 return; |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
135 |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
136 #define REGISTER_OP_HANDLER(OP, BTYP, NDA, FUNOP) \ |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
137 bsxfun_handler_table[OP][BTYP] = bsxfun_forward_op<NDA, FUNOP> |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
138 #define REGISTER_REL_HANDLER(REL, BTYP, NDA, FUNREL) \ |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
139 bsxfun_handler_table[REL][BTYP] = bsxfun_forward_rel<NDA, FUNREL> |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
140 #define REGISTER_STD_HANDLERS(BTYP, NDA) \ |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
141 REGISTER_OP_HANDLER (bsxfun_builtin_plus, BTYP, NDA, bsxfun_add); \ |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
142 REGISTER_OP_HANDLER (bsxfun_builtin_minus, BTYP, NDA, bsxfun_sub); \ |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
143 REGISTER_OP_HANDLER (bsxfun_builtin_times, BTYP, NDA, bsxfun_mul); \ |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
144 REGISTER_OP_HANDLER (bsxfun_builtin_divide, BTYP, NDA, bsxfun_div); \ |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
145 REGISTER_OP_HANDLER (bsxfun_builtin_max, BTYP, NDA, bsxfun_max); \ |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
146 REGISTER_OP_HANDLER (bsxfun_builtin_min, BTYP, NDA, bsxfun_min); \ |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
147 REGISTER_REL_HANDLER (bsxfun_builtin_eq, BTYP, NDA, bsxfun_eq); \ |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
148 REGISTER_REL_HANDLER (bsxfun_builtin_ne, BTYP, NDA, bsxfun_ne); \ |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
149 REGISTER_REL_HANDLER (bsxfun_builtin_lt, BTYP, NDA, bsxfun_lt); \ |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
150 REGISTER_REL_HANDLER (bsxfun_builtin_le, BTYP, NDA, bsxfun_le); \ |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
151 REGISTER_REL_HANDLER (bsxfun_builtin_gt, BTYP, NDA, bsxfun_gt); \ |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
152 REGISTER_REL_HANDLER (bsxfun_builtin_ge, BTYP, NDA, bsxfun_ge) |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
153 |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
154 REGISTER_STD_HANDLERS (btyp_double, NDArray); |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
155 REGISTER_STD_HANDLERS (btyp_float, FloatNDArray); |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
156 REGISTER_STD_HANDLERS (btyp_complex, ComplexNDArray); |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
157 REGISTER_STD_HANDLERS (btyp_float_complex, FloatComplexNDArray); |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
158 REGISTER_STD_HANDLERS (btyp_int8, int8NDArray); |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
159 REGISTER_STD_HANDLERS (btyp_int16, int16NDArray); |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
160 REGISTER_STD_HANDLERS (btyp_int32, int32NDArray); |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
161 REGISTER_STD_HANDLERS (btyp_int64, int64NDArray); |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
162 REGISTER_STD_HANDLERS (btyp_uint8, uint8NDArray); |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
163 REGISTER_STD_HANDLERS (btyp_uint16, uint16NDArray); |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
164 REGISTER_STD_HANDLERS (btyp_uint32, uint32NDArray); |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
165 REGISTER_STD_HANDLERS (btyp_uint64, uint64NDArray); |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
166 |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
167 // For bools, we register and/or. |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
168 REGISTER_OP_HANDLER (bsxfun_builtin_and, btyp_bool, boolNDArray, bsxfun_and); |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
169 REGISTER_OP_HANDLER (bsxfun_builtin_or, btyp_bool, boolNDArray, bsxfun_or); |
9783
119d97db51f0
avoid repeated table init in bsxfun
Jaroslav Hajek <highegg@gmail.com>
parents:
9743
diff
changeset
|
170 |
9827
c15a5ed0da58
optimize bsxfun (@power, ...)
Jaroslav Hajek <highegg@gmail.com>
parents:
9783
diff
changeset
|
171 // Register power handlers. |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
172 bsxfun_handler_table[bsxfun_builtin_power][btyp_double] = |
9827
c15a5ed0da58
optimize bsxfun (@power, ...)
Jaroslav Hajek <highegg@gmail.com>
parents:
9783
diff
changeset
|
173 do_bsxfun_real_pow<NDArray, ComplexNDArray>; |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
174 bsxfun_handler_table[bsxfun_builtin_power][btyp_float] = |
9827
c15a5ed0da58
optimize bsxfun (@power, ...)
Jaroslav Hajek <highegg@gmail.com>
parents:
9783
diff
changeset
|
175 do_bsxfun_real_pow<FloatNDArray, FloatComplexNDArray>; |
c15a5ed0da58
optimize bsxfun (@power, ...)
Jaroslav Hajek <highegg@gmail.com>
parents:
9783
diff
changeset
|
176 |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
177 REGISTER_OP_HANDLER (bsxfun_builtin_power, btyp_complex, ComplexNDArray, |
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
178 bsxfun_pow); |
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
179 REGISTER_OP_HANDLER (bsxfun_builtin_power, btyp_float_complex, |
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
180 FloatComplexNDArray, bsxfun_pow); |
9827
c15a5ed0da58
optimize bsxfun (@power, ...)
Jaroslav Hajek <highegg@gmail.com>
parents:
9783
diff
changeset
|
181 |
10107
fd262afea1d1
optimize bsxfun for chars
Jaroslav Hajek <highegg@gmail.com>
parents:
9827
diff
changeset
|
182 // For chars, we want just relational handlers. |
fd262afea1d1
optimize bsxfun for chars
Jaroslav Hajek <highegg@gmail.com>
parents:
9827
diff
changeset
|
183 REGISTER_REL_HANDLER (bsxfun_builtin_eq, btyp_char, charNDArray, bsxfun_eq); |
fd262afea1d1
optimize bsxfun for chars
Jaroslav Hajek <highegg@gmail.com>
parents:
9827
diff
changeset
|
184 REGISTER_REL_HANDLER (bsxfun_builtin_ne, btyp_char, charNDArray, bsxfun_ne); |
fd262afea1d1
optimize bsxfun for chars
Jaroslav Hajek <highegg@gmail.com>
parents:
9827
diff
changeset
|
185 REGISTER_REL_HANDLER (bsxfun_builtin_lt, btyp_char, charNDArray, bsxfun_lt); |
fd262afea1d1
optimize bsxfun for chars
Jaroslav Hajek <highegg@gmail.com>
parents:
9827
diff
changeset
|
186 REGISTER_REL_HANDLER (bsxfun_builtin_le, btyp_char, charNDArray, bsxfun_le); |
fd262afea1d1
optimize bsxfun for chars
Jaroslav Hajek <highegg@gmail.com>
parents:
9827
diff
changeset
|
187 REGISTER_REL_HANDLER (bsxfun_builtin_gt, btyp_char, charNDArray, bsxfun_gt); |
fd262afea1d1
optimize bsxfun for chars
Jaroslav Hajek <highegg@gmail.com>
parents:
9827
diff
changeset
|
188 REGISTER_REL_HANDLER (bsxfun_builtin_ge, btyp_char, charNDArray, bsxfun_ge); |
fd262afea1d1
optimize bsxfun for chars
Jaroslav Hajek <highegg@gmail.com>
parents:
9827
diff
changeset
|
189 |
9783
119d97db51f0
avoid repeated table init in bsxfun
Jaroslav Hajek <highegg@gmail.com>
parents:
9743
diff
changeset
|
190 filled = true; |
9743
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
191 } |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
192 |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
193 static octave_value |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
194 maybe_optimized_builtin (const std::string& name, |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
195 const octave_value& a, const octave_value& b) |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
196 { |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
197 octave_value retval; |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
198 |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
199 maybe_fill_table (); |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
200 |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
201 bsxfun_builtin_op op = bsxfun_builtin_lookup (name); |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
202 if (op != bsxfun_builtin_unknown) |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
203 { |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
204 builtin_type_t btyp_a = a.builtin_type (), btyp_b = b.builtin_type (); |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
205 |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
206 // Simplify single/double combinations. |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
207 if (btyp_a == btyp_float && btyp_b == btyp_double) |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
208 btyp_b = btyp_float; |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
209 else if (btyp_a == btyp_double && btyp_b == btyp_float) |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
210 btyp_a = btyp_float; |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
211 else if (btyp_a == btyp_float_complex && btyp_b == btyp_complex) |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
212 btyp_b = btyp_float_complex; |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
213 else if (btyp_a == btyp_complex && btyp_b == btyp_float_complex) |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
214 btyp_a = btyp_float_complex; |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
215 |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
216 if (btyp_a == btyp_b && btyp_a != btyp_unknown) |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
217 { |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
218 bsxfun_handler handler = bsxfun_handler_table[op][btyp_a]; |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
219 if (handler) |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
220 retval = handler (a, b); |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
221 } |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
222 } |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
223 |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
224 return retval; |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
225 } |
6869 | 226 |
227 static bool | |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
228 maybe_update_column (octave_value& Ac, const octave_value& A, |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
229 const dim_vector& dva, const dim_vector& dvc, |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
230 octave_idx_type i, octave_value_list &idx) |
6869 | 231 { |
232 octave_idx_type nd = dva.length (); | |
233 | |
234 if (i == 0) | |
235 { | |
236 idx(0) = octave_value (':'); | |
237 for (octave_idx_type j = 1; j < nd; j++) | |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
238 { |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
239 if (dva (j) == 1) |
14854
5ae9f0f77635
maint: Use Octave coding conventions for coddling parenthis is DLD-FUNCTIONS directory
Rik <octave@nomad.inbox5.com>
parents:
14846
diff
changeset
|
240 idx(j) = octave_value (1); |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
241 else |
14854
5ae9f0f77635
maint: Use Octave coding conventions for coddling parenthis is DLD-FUNCTIONS directory
Rik <octave@nomad.inbox5.com>
parents:
14846
diff
changeset
|
242 idx(j) = octave_value ((i % dvc(j)) + 1); |
6869 | 243 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
244 i = i / dvc (j); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
245 } |
6869 | 246 |
247 Ac = A; | |
248 Ac = Ac.single_subsref ("(", idx); | |
249 return true; | |
250 } | |
251 else | |
252 { | |
253 bool is_changed = false; | |
254 octave_idx_type k = i; | |
255 octave_idx_type k1 = i - 1; | |
256 for (octave_idx_type j = 1; j < nd; j++) | |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
257 { |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
258 if (dva(j) != 1 && k % dvc (j) != k1 % dvc (j)) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
259 { |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
260 idx (j) = octave_value ((k % dvc(j)) + 1); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
261 is_changed = true; |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
262 } |
6869 | 263 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
264 k = k / dvc (j); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
265 k1 = k1 / dvc (j); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
266 } |
6869 | 267 |
268 if (is_changed) | |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
269 { |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
270 Ac = A; |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
271 Ac = Ac.single_subsref ("(", idx); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
272 return true; |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
273 } |
6869 | 274 else |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
275 return false; |
6869 | 276 } |
277 } | |
278 | |
6959 | 279 #if 0 |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
280 // FIXME: this function is not used; is it OK to delete it? |
6869 | 281 static void |
282 update_index (octave_value_list& idx, const dim_vector& dv, octave_idx_type i) | |
283 { | |
284 octave_idx_type nd = dv.length (); | |
285 | |
286 if (i == 0) | |
287 { | |
288 for (octave_idx_type j = nd - 1; j > 0; j--) | |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
289 idx(j) = octave_value (static_cast<double>(1)); |
6869 | 290 idx(0) = octave_value (':'); |
291 } | |
292 else | |
293 { | |
294 for (octave_idx_type j = 1; j < nd; j++) | |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
295 { |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
296 idx (j) = octave_value (i % dv (j) + 1); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
297 i = i / dv (j); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
298 } |
6869 | 299 } |
300 } | |
6959 | 301 #endif |
6869 | 302 |
303 static void | |
304 update_index (Array<int>& idx, const dim_vector& dv, octave_idx_type i) | |
305 { | |
306 octave_idx_type nd = dv.length (); | |
307 | |
308 idx(0) = 0; | |
309 for (octave_idx_type j = 1; j < nd; j++) | |
310 { | |
311 idx (j) = i % dv (j); | |
312 i = i / dv (j); | |
313 } | |
314 } | |
315 | |
15039
e753177cde93
maint: Move non-dynamically linked functions from DLD-FUNCTIONS/ to corefcn/ directory
Rik <rik@octave.org>
parents:
14854
diff
changeset
|
316 DEFUN (bsxfun, args, , |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
317 "-*- texinfo -*-\n\ |
15039
e753177cde93
maint: Move non-dynamically linked functions from DLD-FUNCTIONS/ to corefcn/ directory
Rik <rik@octave.org>
parents:
14854
diff
changeset
|
318 @deftypefn {Built-in Function} {} bsxfun (@var{f}, @var{A}, @var{B})\n\ |
14116
951eacaf9381
Initial documentation for broadcasting and general vectorization guidelines
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents:
13929
diff
changeset
|
319 The binary singleton expansion function applier performs broadcasting,\n\ |
951eacaf9381
Initial documentation for broadcasting and general vectorization guidelines
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents:
13929
diff
changeset
|
320 that is, applies a binary function @var{f} element-by-element to two\n\ |
12972
e4f82a337d66
bsxfun.cc: Expand cryptic bsxfun acronym in docstring and explain it a bit more
Jordi Gutiérrez Hermoso <jordigh@gmail.com>
parents:
12639
diff
changeset
|
321 array arguments @var{A} and @var{B}, and expands as necessary\n\ |
13929
9cae456085c2
Grammarcheck of documentation before 3.6.0 release.
Rik <octave@nomad.inbox5.com>
parents:
13013
diff
changeset
|
322 singleton dimensions in either input argument. @var{f} is a function\n\ |
12972
e4f82a337d66
bsxfun.cc: Expand cryptic bsxfun acronym in docstring and explain it a bit more
Jordi Gutiérrez Hermoso <jordigh@gmail.com>
parents:
12639
diff
changeset
|
323 handle, inline function, or string containing the name of the function\n\ |
13929
9cae456085c2
Grammarcheck of documentation before 3.6.0 release.
Rik <octave@nomad.inbox5.com>
parents:
13013
diff
changeset
|
324 to evaluate. The function @var{f} must be capable of accepting two\n\ |
12972
e4f82a337d66
bsxfun.cc: Expand cryptic bsxfun acronym in docstring and explain it a bit more
Jordi Gutiérrez Hermoso <jordigh@gmail.com>
parents:
12639
diff
changeset
|
325 column-vector arguments of equal length, or one column vector argument\n\ |
e4f82a337d66
bsxfun.cc: Expand cryptic bsxfun acronym in docstring and explain it a bit more
Jordi Gutiérrez Hermoso <jordigh@gmail.com>
parents:
12639
diff
changeset
|
326 and a scalar.\n\ |
6869 | 327 \n\ |
13929
9cae456085c2
Grammarcheck of documentation before 3.6.0 release.
Rik <octave@nomad.inbox5.com>
parents:
13013
diff
changeset
|
328 The dimensions of @var{A} and @var{B} must be equal or singleton. The\n\ |
12972
e4f82a337d66
bsxfun.cc: Expand cryptic bsxfun acronym in docstring and explain it a bit more
Jordi Gutiérrez Hermoso <jordigh@gmail.com>
parents:
12639
diff
changeset
|
329 singleton dimensions of the arrays will be expanded to the same\n\ |
e4f82a337d66
bsxfun.cc: Expand cryptic bsxfun acronym in docstring and explain it a bit more
Jordi Gutiérrez Hermoso <jordigh@gmail.com>
parents:
12639
diff
changeset
|
330 dimensionality as the other array.\n\ |
6869 | 331 @seealso{arrayfun, cellfun}\n\ |
332 @end deftypefn") | |
333 { | |
334 int nargin = args.length (); | |
335 octave_value_list retval; | |
336 | |
337 if (nargin != 3) | |
338 print_usage (); | |
339 else | |
340 { | |
9450
cf714e75c656
implement overloaded function handles
Jaroslav Hajek <highegg@gmail.com>
parents:
9041
diff
changeset
|
341 octave_value func = args(0); |
6869 | 342 |
9450
cf714e75c656
implement overloaded function handles
Jaroslav Hajek <highegg@gmail.com>
parents:
9041
diff
changeset
|
343 if (func.is_string ()) |
cf714e75c656
implement overloaded function handles
Jaroslav Hajek <highegg@gmail.com>
parents:
9041
diff
changeset
|
344 { |
cf714e75c656
implement overloaded function handles
Jaroslav Hajek <highegg@gmail.com>
parents:
9041
diff
changeset
|
345 std::string name = func.string_value (); |
cf714e75c656
implement overloaded function handles
Jaroslav Hajek <highegg@gmail.com>
parents:
9041
diff
changeset
|
346 func = symbol_table::find_function (name); |
cf714e75c656
implement overloaded function handles
Jaroslav Hajek <highegg@gmail.com>
parents:
9041
diff
changeset
|
347 if (func.is_undefined ()) |
cf714e75c656
implement overloaded function handles
Jaroslav Hajek <highegg@gmail.com>
parents:
9041
diff
changeset
|
348 error ("bsxfun: invalid function name: %s", name.c_str ()); |
cf714e75c656
implement overloaded function handles
Jaroslav Hajek <highegg@gmail.com>
parents:
9041
diff
changeset
|
349 } |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
350 else if (! (args(0).is_function_handle () |
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
351 || args(0).is_inline_function ())) |
11553
01f703952eff
Improve docstrings for functions in DLD-FUNCTIONS directory.
Rik <octave@nomad.inbox5.com>
parents:
11523
diff
changeset
|
352 error ("bsxfun: F must be a string or function handle"); |
6869 | 353 |
9743
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
354 const octave_value A = args (1); |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
355 const octave_value B = args (2); |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
356 |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
357 if (func.is_builtin_function () |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
358 || (func.is_function_handle () |
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
359 && ! A.is_object () && ! B.is_object ())) |
9743
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
360 { |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
361 // This may break if the default behavior is overriden. But if you |
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
362 // override arithmetic operators for builtin classes, you should |
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
363 // expect mayhem anyway (constant folding etc). Querying |
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
364 // is_overloaded() may not be exactly what we need here. |
9743
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
365 octave_function *fcn_val = func.function_value (); |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
366 if (fcn_val) |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
367 { |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
368 octave_value tmp = maybe_optimized_builtin (fcn_val->name (), |
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
369 A, B); |
9743
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
370 if (tmp.is_defined ()) |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
371 retval(0) = tmp; |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
372 } |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
373 } |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
374 |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
375 if (! error_state && retval.empty ()) |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
376 { |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
377 dim_vector dva = A.dims (); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
378 octave_idx_type nda = dva.length (); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
379 dim_vector dvb = B.dims (); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
380 octave_idx_type ndb = dvb.length (); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
381 octave_idx_type nd = nda; |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
382 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
383 if (nda > ndb) |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
384 dvb.resize (nda, 1); |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
385 else if (nda < ndb) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
386 { |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
387 dva.resize (ndb, 1); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
388 nd = ndb; |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
389 } |
6869 | 390 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
391 for (octave_idx_type i = 0; i < nd; i++) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
392 if (dva (i) != dvb (i) && dva (i) != 1 && dvb (i) != 1) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
393 { |
11553
01f703952eff
Improve docstrings for functions in DLD-FUNCTIONS directory.
Rik <octave@nomad.inbox5.com>
parents:
11523
diff
changeset
|
394 error ("bsxfun: dimensions of A and B must match"); |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
395 break; |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
396 } |
6869 | 397 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
398 if (!error_state) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
399 { |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
400 // Find the size of the output |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
401 dim_vector dvc; |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
402 dvc.resize (nd); |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
403 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
404 for (octave_idx_type i = 0; i < nd; i++) |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
405 dvc (i) = (dva (i) < 1 ? dva (i) |
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
406 : (dvb (i) < 1 ? dvb (i) |
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
407 : (dva (i) > dvb (i) |
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
408 ? dva (i) : dvb (i)))); |
6869 | 409 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
410 if (dva == dvb || dva.numel () == 1 || dvb.numel () == 1) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
411 { |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
412 octave_value_list inputs; |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
413 inputs (0) = A; |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
414 inputs (1) = B; |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
415 retval = func.do_multi_index_op (1, inputs); |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
416 } |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
417 else if (dvc.numel () < 1) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
418 { |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
419 octave_value_list inputs; |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
420 inputs (0) = A.resize (dvc); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
421 inputs (1) = B.resize (dvc); |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
422 retval = func.do_multi_index_op (1, inputs); |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
423 } |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
424 else |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
425 { |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
426 octave_idx_type ncount = 1; |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
427 for (octave_idx_type i = 1; i < nd; i++) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
428 ncount *= dvc (i); |
6869 | 429 |
430 #define BSXDEF(T) \ | |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
431 T result_ ## T; \ |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
432 bool have_ ## T = false; |
6869 | 433 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
434 BSXDEF(NDArray); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
435 BSXDEF(ComplexNDArray); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
436 BSXDEF(FloatNDArray); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
437 BSXDEF(FloatComplexNDArray); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
438 BSXDEF(boolNDArray); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
439 BSXDEF(int8NDArray); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
440 BSXDEF(int16NDArray); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
441 BSXDEF(int32NDArray); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
442 BSXDEF(int64NDArray); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
443 BSXDEF(uint8NDArray); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
444 BSXDEF(uint16NDArray); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
445 BSXDEF(uint32NDArray); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
446 BSXDEF(uint64NDArray); |
6869 | 447 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
448 octave_value Ac ; |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
449 octave_value_list idxA; |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
450 octave_value Bc; |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
451 octave_value_list idxB; |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
452 octave_value C; |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
453 octave_value_list inputs; |
14846
460a3c6d8bf1
maint: Use Octave coding convention for cuddled parenthis in function calls with empty argument lists.
Rik <octave@nomad.inbox5.com>
parents:
14844
diff
changeset
|
454 Array<int> ra_idx (dim_vector (dvc.length (), 1), 0); |
6869 | 455 |
456 | |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
457 for (octave_idx_type i = 0; i < ncount; i++) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
458 { |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
459 if (maybe_update_column (Ac, A, dva, dvc, i, idxA)) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
460 inputs (0) = Ac; |
6869 | 461 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
462 if (maybe_update_column (Bc, B, dvb, dvc, i, idxB)) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
463 inputs (1) = Bc; |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
464 |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
465 octave_value_list tmp = func.do_multi_index_op (1, |
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
466 inputs); |
6869 | 467 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
468 if (error_state) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
469 break; |
6869 | 470 |
471 #define BSXINIT(T, CLS, EXTRACTOR) \ | |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
472 (result_type == CLS) \ |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
473 { \ |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
474 have_ ## T = true; \ |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
475 result_ ## T = \ |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
476 tmp (0). EXTRACTOR ## _array_value (); \ |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
477 result_ ## T .resize (dvc); \ |
6869 | 478 } |
479 | |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
480 if (i == 0) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
481 { |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
482 if (! tmp(0).is_sparse_type ()) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
483 { |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
484 std::string result_type = tmp(0).class_name (); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
485 if (result_type == "double") |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
486 { |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
487 if (tmp(0).is_real_type ()) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
488 { |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
489 have_NDArray = true; |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
490 result_NDArray = tmp(0).array_value (); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
491 result_NDArray.resize (dvc); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
492 } |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
493 else |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
494 { |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
495 have_ComplexNDArray = true; |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
496 result_ComplexNDArray = |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
497 tmp(0).complex_array_value (); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
498 result_ComplexNDArray.resize (dvc); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
499 } |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
500 } |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
501 else if (result_type == "single") |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
502 { |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
503 if (tmp(0).is_real_type ()) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
504 { |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
505 have_FloatNDArray = true; |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
506 result_FloatNDArray |
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
507 = tmp(0).float_array_value (); |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
508 result_FloatNDArray.resize (dvc); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
509 } |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
510 else |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
511 { |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
512 have_ComplexNDArray = true; |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
513 result_ComplexNDArray = |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
514 tmp(0).complex_array_value (); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
515 result_ComplexNDArray.resize (dvc); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
516 } |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
517 } |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
518 else if BSXINIT(boolNDArray, "logical", bool) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
519 else if BSXINIT(int8NDArray, "int8", int8) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
520 else if BSXINIT(int16NDArray, "int16", int16) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
521 else if BSXINIT(int32NDArray, "int32", int32) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
522 else if BSXINIT(int64NDArray, "int64", int64) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
523 else if BSXINIT(uint8NDArray, "uint8", uint8) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
524 else if BSXINIT(uint16NDArray, "uint16", uint16) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
525 else if BSXINIT(uint32NDArray, "uint32", uint32) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
526 else if BSXINIT(uint64NDArray, "uint64", uint64) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
527 else |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
528 { |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
529 C = tmp (0); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
530 C = C.resize (dvc); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
531 } |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
532 } |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
533 } |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
534 else |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
535 { |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
536 update_index (ra_idx, dvc, i); |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
537 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
538 if (have_FloatNDArray || |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
539 have_FloatComplexNDArray) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
540 { |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
541 if (! tmp(0).is_float_type ()) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
542 { |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
543 if (have_FloatNDArray) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
544 { |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
545 have_FloatNDArray = false; |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
546 C = result_FloatNDArray; |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
547 } |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
548 else |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
549 { |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
550 have_FloatComplexNDArray = false; |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
551 C = result_FloatComplexNDArray; |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
552 } |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
553 C = do_cat_op (C, tmp(0), ra_idx); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
554 } |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
555 else if (tmp(0).is_double_type ()) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
556 { |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
557 if (tmp(0).is_complex_type () && |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
558 have_FloatNDArray) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
559 { |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
560 result_ComplexNDArray = |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
561 ComplexNDArray (result_FloatNDArray); |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
562 result_ComplexNDArray.insert |
14846
460a3c6d8bf1
maint: Use Octave coding convention for cuddled parenthis in function calls with empty argument lists.
Rik <octave@nomad.inbox5.com>
parents:
14844
diff
changeset
|
563 (tmp(0).complex_array_value (), ra_idx); |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
564 have_FloatComplexNDArray = false; |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
565 have_ComplexNDArray = true; |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
566 } |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
567 else |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
568 { |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
569 result_NDArray = |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
570 NDArray (result_FloatNDArray); |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
571 result_NDArray.insert |
14846
460a3c6d8bf1
maint: Use Octave coding convention for cuddled parenthis in function calls with empty argument lists.
Rik <octave@nomad.inbox5.com>
parents:
14844
diff
changeset
|
572 (tmp(0).array_value (), ra_idx); |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
573 have_FloatNDArray = false; |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
574 have_NDArray = true; |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
575 } |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
576 } |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
577 else if (tmp(0).is_real_type ()) |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
578 result_FloatNDArray.insert |
14846
460a3c6d8bf1
maint: Use Octave coding convention for cuddled parenthis in function calls with empty argument lists.
Rik <octave@nomad.inbox5.com>
parents:
14844
diff
changeset
|
579 (tmp(0).float_array_value (), ra_idx); |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
580 else |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
581 { |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
582 result_FloatComplexNDArray = |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
583 FloatComplexNDArray (result_FloatNDArray); |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
584 result_FloatComplexNDArray.insert |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
585 (tmp(0).float_complex_array_value (), |
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
586 ra_idx); |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
587 have_FloatNDArray = false; |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
588 have_FloatComplexNDArray = true; |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
589 } |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
590 } |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
591 else if (have_NDArray) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
592 { |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
593 if (! tmp(0).is_float_type ()) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
594 { |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
595 have_NDArray = false; |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
596 C = result_NDArray; |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
597 C = do_cat_op (C, tmp(0), ra_idx); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
598 } |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
599 else if (tmp(0).is_real_type ()) |
14846
460a3c6d8bf1
maint: Use Octave coding convention for cuddled parenthis in function calls with empty argument lists.
Rik <octave@nomad.inbox5.com>
parents:
14844
diff
changeset
|
600 result_NDArray.insert (tmp(0).array_value (), |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
601 ra_idx); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
602 else |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
603 { |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
604 result_ComplexNDArray = |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
605 ComplexNDArray (result_NDArray); |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
606 result_ComplexNDArray.insert |
14846
460a3c6d8bf1
maint: Use Octave coding convention for cuddled parenthis in function calls with empty argument lists.
Rik <octave@nomad.inbox5.com>
parents:
14844
diff
changeset
|
607 (tmp(0).complex_array_value (), ra_idx); |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
608 have_NDArray = false; |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
609 have_ComplexNDArray = true; |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
610 } |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
611 } |
6869 | 612 |
613 #define BSXLOOP(T, CLS, EXTRACTOR) \ | |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
614 (have_ ## T) \ |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
615 { \ |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
616 if (tmp (0).class_name () != CLS) \ |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
617 { \ |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
618 have_ ## T = false; \ |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
619 C = result_ ## T; \ |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
620 C = do_cat_op (C, tmp (0), ra_idx); \ |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
621 } \ |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
622 else \ |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
623 result_ ## T .insert \ |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
624 (tmp(0). EXTRACTOR ## _array_value (), \ |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
625 ra_idx); \ |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
626 } |
6869 | 627 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
628 else if BSXLOOP(ComplexNDArray, "double", complex) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
629 else if BSXLOOP(boolNDArray, "logical", bool) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
630 else if BSXLOOP(int8NDArray, "int8", int8) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
631 else if BSXLOOP(int16NDArray, "int16", int16) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
632 else if BSXLOOP(int32NDArray, "int32", int32) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
633 else if BSXLOOP(int64NDArray, "int64", int64) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
634 else if BSXLOOP(uint8NDArray, "uint8", uint8) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
635 else if BSXLOOP(uint16NDArray, "uint16", uint16) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
636 else if BSXLOOP(uint32NDArray, "uint32", uint32) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
637 else if BSXLOOP(uint64NDArray, "uint64", uint64) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
638 else |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
639 C = do_cat_op (C, tmp(0), ra_idx); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
640 } |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
641 } |
6869 | 642 |
643 #define BSXEND(T) \ | |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
644 (have_ ## T) \ |
14844
5bc9b9cb4362
maint: Use Octave coding conventions for cuddled parenthesis in retval assignments.
Rik <octave@nomad.inbox5.com>
parents:
14501
diff
changeset
|
645 retval(0) = result_ ## T; |
6869 | 646 |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
647 if BSXEND(NDArray) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
648 else if BSXEND(ComplexNDArray) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
649 else if BSXEND(FloatNDArray) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
650 else if BSXEND(FloatComplexNDArray) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
651 else if BSXEND(boolNDArray) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
652 else if BSXEND(int8NDArray) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
653 else if BSXEND(int16NDArray) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
654 else if BSXEND(int32NDArray) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
655 else if BSXEND(int64NDArray) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
656 else if BSXEND(uint8NDArray) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
657 else if BSXEND(uint16NDArray) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
658 else if BSXEND(uint32NDArray) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
659 else if BSXEND(uint64NDArray) |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
660 else |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
661 retval(0) = C; |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
662 } |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
663 } |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
664 } |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
665 } |
6869 | 666 |
667 return retval; | |
668 } | |
669 | |
670 /* | |
671 | |
672 %!shared a, b, c, f | |
673 %! a = randn (4, 4); | |
674 %! b = mean (a, 1); | |
675 %! c = mean (a, 2); | |
676 %! f = @minus; | |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
677 %!error (bsxfun (f)) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
678 %!error (bsxfun (f, a)) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
679 %!error (bsxfun (a, b)) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
680 %!error (bsxfun (a, b, c)) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
681 %!error (bsxfun (f, a, b, c)) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
682 %!error (bsxfun (f, ones (4, 0), ones (4, 4))) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
683 %!assert (bsxfun (f, ones (4, 0), ones (4, 1)), zeros (4, 0)) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
684 %!assert (bsxfun (f, ones (1, 4), ones (4, 1)), zeros (4, 4)) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
685 %!assert (bsxfun (f, a, b), a - repmat (b, 4, 1)) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
686 %!assert (bsxfun (f, a, c), a - repmat (c, 1, 4)) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
687 %!assert (bsxfun ("minus", ones (1, 4), ones (4, 1)), zeros (4, 4)) |
6869 | 688 |
689 %!shared a, b, c, f | |
690 %! a = randn (4, 4); | |
691 %! a(1) *= 1i; | |
692 %! b = mean (a, 1); | |
693 %! c = mean (a, 2); | |
694 %! f = @minus; | |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
695 %!error (bsxfun (f)) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
696 %!error (bsxfun (f, a)) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
697 %!error (bsxfun (a, b)) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
698 %!error (bsxfun (a, b, c)) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
699 %!error (bsxfun (f, a, b, c)) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
700 %!error (bsxfun (f, ones (4, 0), ones (4, 4))) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
701 %!assert (bsxfun (f, ones (4, 0), ones (4, 1)), zeros (4, 0)) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
702 %!assert (bsxfun (f, ones (1, 4), ones (4, 1)), zeros (4, 4)) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
703 %!assert (bsxfun (f, a, b), a - repmat (b, 4, 1)) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
704 %!assert (bsxfun (f, a, c), a - repmat (c, 1, 4)) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
705 %!assert (bsxfun ("minus", ones (1, 4), ones (4, 1)), zeros (4, 4)) |
6869 | 706 |
707 %!shared a, b, c, f | |
708 %! a = randn (4, 4); | |
709 %! a(end) *= 1i; | |
710 %! b = mean (a, 1); | |
711 %! c = mean (a, 2); | |
712 %! f = @minus; | |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
713 %!error (bsxfun (f)) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
714 %!error (bsxfun (f, a)) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
715 %!error (bsxfun (a, b)) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
716 %!error (bsxfun (a, b, c)) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
717 %!error (bsxfun (f, a, b, c)) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
718 %!error (bsxfun (f, ones (4, 0), ones (4, 4))) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
719 %!assert (bsxfun (f, ones (4, 0), ones (4, 1)), zeros (4, 0)) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
720 %!assert (bsxfun (f, ones (1, 4), ones (4, 1)), zeros (4, 4)) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
721 %!assert (bsxfun (f, a, b), a - repmat (b, 4, 1)) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
722 %!assert (bsxfun (f, a, c), a - repmat (c, 1, 4)) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
723 %!assert (bsxfun ("minus", ones (1, 4), ones (4, 1)), zeros (4, 4)) |
6869 | 724 |
725 %!shared a, b, c, f | |
726 %! a = randn (4, 4); | |
727 %! b = a (1, :); | |
728 %! c = a (:, 1); | |
729 %! f = @(x, y) x == y; | |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
730 %!error (bsxfun (f)) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
731 %!error (bsxfun (f, a)) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
732 %!error (bsxfun (a, b)) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
733 %!error (bsxfun (a, b, c)) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
734 %!error (bsxfun (f, a, b, c)) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
735 %!error (bsxfun (f, ones (4, 0), ones (4, 4))) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
736 %!assert (bsxfun (f, ones (4, 0), ones (4, 1)), zeros (4, 0, "logical")) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
737 %!assert (bsxfun (f, ones (1, 4), ones (4, 1)), ones (4, 4, "logical")) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
738 %!assert (bsxfun (f, a, b), a == repmat (b, 4, 1)) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
739 %!assert (bsxfun (f, a, c), a == repmat (c, 1, 4)) |
6869 | 740 |
741 %!shared a, b, c, d, f | |
742 %! a = randn (4, 4, 4); | |
743 %! b = mean (a, 1); | |
744 %! c = mean (a, 2); | |
745 %! d = mean (a, 3); | |
746 %! f = @minus; | |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
747 %!error (bsxfun (f, ones ([4, 0, 4]), ones ([4, 4, 4]))) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
748 %!assert (bsxfun (f, ones ([4, 0, 4]), ones ([4, 1, 4])), zeros ([4, 0, 4])) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
749 %!assert (bsxfun (f, ones ([4, 4, 0]), ones ([4, 1, 1])), zeros ([4, 4, 0])) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
750 %!assert (bsxfun (f, ones ([1, 4, 4]), ones ([4, 1, 4])), zeros ([4, 4, 4])) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
751 %!assert (bsxfun (f, ones ([4, 4, 1]), ones ([4, 1, 4])), zeros ([4, 4, 4])) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
752 %!assert (bsxfun (f, ones ([4, 1, 4]), ones ([1, 4, 4])), zeros ([4, 4, 4])) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
753 %!assert (bsxfun (f, ones ([4, 1, 4]), ones ([1, 4, 1])), zeros ([4, 4, 4])) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
754 %!assert (bsxfun (f, a, b), a - repmat (b, [4, 1, 1])) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
755 %!assert (bsxfun (f, a, c), a - repmat (c, [1, 4, 1])) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
756 %!assert (bsxfun (f, a, d), a - repmat (d, [1, 1, 4])) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
757 %!assert (bsxfun ("minus", ones ([4, 0, 4]), ones ([4, 1, 4])), zeros ([4, 0, 4])) |
6869 | 758 |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
759 %% The test below is a very hard case to treat |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
760 %!assert (bsxfun (f, ones ([4, 1, 4, 1]), ones ([1, 4, 1, 4])), zeros ([4, 4, 4, 4])); |
6869 | 761 |
10141 | 762 %!shared a, b, aa, bb |
763 %! a = randn (3, 1, 3); | |
764 %! aa = a(:, ones (1, 3), :, ones (1, 3)); | |
765 %! b = randn (1, 3, 3, 3); | |
766 %! bb = b(ones (1, 3), :, :, :); | |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
767 %!assert (bsxfun (@plus, a, b), aa + bb) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
768 %!assert (bsxfun (@minus, a, b), aa - bb) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
769 %!assert (bsxfun (@times, a, b), aa .* bb) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
770 %!assert (bsxfun (@rdivide, a, b), aa ./ bb) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
771 %!assert (bsxfun (@ldivide, a, b), aa .\ bb) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
772 %!assert (bsxfun (@power, a, b), aa .^ bb) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
773 %!assert (bsxfun (@power, abs (a), b), abs (aa) .^ bb) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
774 %!assert (bsxfun (@eq, round (a), round (b)), round (aa) == round (bb)) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
775 %!assert (bsxfun (@ne, round (a), round (b)), round (aa) != round (bb)) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
776 %!assert (bsxfun (@lt, a, b), aa < bb) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
777 %!assert (bsxfun (@le, a, b), aa <= bb) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
778 %!assert (bsxfun (@gt, a, b), aa > bb) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
779 %!assert (bsxfun (@ge, a, b), aa >= bb) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
780 %!assert (bsxfun (@min, a, b), min (aa, bb)) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
781 %!assert (bsxfun (@max, a, b), max (aa, bb)) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
782 %!assert (bsxfun (@and, a > 0, b > 0), (aa > 0) & (bb > 0)) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
783 %!assert (bsxfun (@or, a > 0, b > 0), (aa > 0) | (bb > 0)) |
13013
5307bf69cd88
Add tests for automatic bsxfun
Jordi Gutiérrez Hermoso <jordigh@gmail.com>
parents:
12972
diff
changeset
|
784 |
5307bf69cd88
Add tests for automatic bsxfun
Jordi Gutiérrez Hermoso <jordigh@gmail.com>
parents:
12972
diff
changeset
|
785 %% Test automatic bsxfun |
5307bf69cd88
Add tests for automatic bsxfun
Jordi Gutiérrez Hermoso <jordigh@gmail.com>
parents:
12972
diff
changeset
|
786 % |
5307bf69cd88
Add tests for automatic bsxfun
Jordi Gutiérrez Hermoso <jordigh@gmail.com>
parents:
12972
diff
changeset
|
787 %!test |
17245
7babcdb9bc13
Use ... instead of \ for line continuation marker.
Stefan Mahr <dac922@gmx.de>
parents:
15195
diff
changeset
|
788 %! funs = {@plus, @minus, @times, @rdivide, @ldivide, @power, @max, @min, ... |
7babcdb9bc13
Use ... instead of \ for line continuation marker.
Stefan Mahr <dac922@gmx.de>
parents:
15195
diff
changeset
|
789 %! @rem, @mod, @atan2, @hypot, @eq, @ne, @lt, @le, @gt, @ge, ... |
13013
5307bf69cd88
Add tests for automatic bsxfun
Jordi Gutiérrez Hermoso <jordigh@gmail.com>
parents:
12972
diff
changeset
|
790 %! @and, @or, @xor }; |
5307bf69cd88
Add tests for automatic bsxfun
Jordi Gutiérrez Hermoso <jordigh@gmail.com>
parents:
12972
diff
changeset
|
791 %! |
5307bf69cd88
Add tests for automatic bsxfun
Jordi Gutiérrez Hermoso <jordigh@gmail.com>
parents:
12972
diff
changeset
|
792 %! float_types = {@single, @double}; |
17245
7babcdb9bc13
Use ... instead of \ for line continuation marker.
Stefan Mahr <dac922@gmx.de>
parents:
15195
diff
changeset
|
793 %! int_types = {@int8, @int16, @int32, @int64, ... |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
794 %! @uint8, @uint16, @uint32, @uint64}; |
13013
5307bf69cd88
Add tests for automatic bsxfun
Jordi Gutiérrez Hermoso <jordigh@gmail.com>
parents:
12972
diff
changeset
|
795 %! |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
796 %! x = rand (3) * 10-5; |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
797 %! y = rand (3,1) * 10-5; |
13013
5307bf69cd88
Add tests for automatic bsxfun
Jordi Gutiérrez Hermoso <jordigh@gmail.com>
parents:
12972
diff
changeset
|
798 %! |
5307bf69cd88
Add tests for automatic bsxfun
Jordi Gutiérrez Hermoso <jordigh@gmail.com>
parents:
12972
diff
changeset
|
799 %! for i=1:length (funs) |
14854
5ae9f0f77635
maint: Use Octave coding conventions for coddling parenthis is DLD-FUNCTIONS directory
Rik <octave@nomad.inbox5.com>
parents:
14846
diff
changeset
|
800 %! for j = 1:length (float_types) |
5ae9f0f77635
maint: Use Octave coding conventions for coddling parenthis is DLD-FUNCTIONS directory
Rik <octave@nomad.inbox5.com>
parents:
14846
diff
changeset
|
801 %! for k = 1:length (int_types) |
13013
5307bf69cd88
Add tests for automatic bsxfun
Jordi Gutiérrez Hermoso <jordigh@gmail.com>
parents:
12972
diff
changeset
|
802 %! |
5307bf69cd88
Add tests for automatic bsxfun
Jordi Gutiérrez Hermoso <jordigh@gmail.com>
parents:
12972
diff
changeset
|
803 %! fun = funs{i}; |
5307bf69cd88
Add tests for automatic bsxfun
Jordi Gutiérrez Hermoso <jordigh@gmail.com>
parents:
12972
diff
changeset
|
804 %! f_type = float_types{j}; |
5307bf69cd88
Add tests for automatic bsxfun
Jordi Gutiérrez Hermoso <jordigh@gmail.com>
parents:
12972
diff
changeset
|
805 %! i_type = int_types{k}; |
5307bf69cd88
Add tests for automatic bsxfun
Jordi Gutiérrez Hermoso <jordigh@gmail.com>
parents:
12972
diff
changeset
|
806 %! |
17245
7babcdb9bc13
Use ... instead of \ for line continuation marker.
Stefan Mahr <dac922@gmx.de>
parents:
15195
diff
changeset
|
807 %! assert (bsxfun (fun, f_type (x), i_type (y)), ... |
13013
5307bf69cd88
Add tests for automatic bsxfun
Jordi Gutiérrez Hermoso <jordigh@gmail.com>
parents:
12972
diff
changeset
|
808 %! fun (f_type(x), i_type (y))); |
17245
7babcdb9bc13
Use ... instead of \ for line continuation marker.
Stefan Mahr <dac922@gmx.de>
parents:
15195
diff
changeset
|
809 %! assert (bsxfun (fun, f_type (y), i_type (x)), ... |
13013
5307bf69cd88
Add tests for automatic bsxfun
Jordi Gutiérrez Hermoso <jordigh@gmail.com>
parents:
12972
diff
changeset
|
810 %! fun (f_type(y), i_type (x))); |
5307bf69cd88
Add tests for automatic bsxfun
Jordi Gutiérrez Hermoso <jordigh@gmail.com>
parents:
12972
diff
changeset
|
811 %! |
17245
7babcdb9bc13
Use ... instead of \ for line continuation marker.
Stefan Mahr <dac922@gmx.de>
parents:
15195
diff
changeset
|
812 %! assert (bsxfun (fun, i_type (x), i_type (y)), ... |
13013
5307bf69cd88
Add tests for automatic bsxfun
Jordi Gutiérrez Hermoso <jordigh@gmail.com>
parents:
12972
diff
changeset
|
813 %! fun (i_type (x), i_type (y))); |
17245
7babcdb9bc13
Use ... instead of \ for line continuation marker.
Stefan Mahr <dac922@gmx.de>
parents:
15195
diff
changeset
|
814 %! assert (bsxfun (fun, i_type (y), i_type (x)), ... |
13013
5307bf69cd88
Add tests for automatic bsxfun
Jordi Gutiérrez Hermoso <jordigh@gmail.com>
parents:
12972
diff
changeset
|
815 %! fun (i_type (y), i_type (x))); |
5307bf69cd88
Add tests for automatic bsxfun
Jordi Gutiérrez Hermoso <jordigh@gmail.com>
parents:
12972
diff
changeset
|
816 %! |
17245
7babcdb9bc13
Use ... instead of \ for line continuation marker.
Stefan Mahr <dac922@gmx.de>
parents:
15195
diff
changeset
|
817 %! assert (bsxfun (fun, f_type (x), f_type (y)), ... |
13013
5307bf69cd88
Add tests for automatic bsxfun
Jordi Gutiérrez Hermoso <jordigh@gmail.com>
parents:
12972
diff
changeset
|
818 %! fun (f_type (x), f_type (y))); |
17245
7babcdb9bc13
Use ... instead of \ for line continuation marker.
Stefan Mahr <dac922@gmx.de>
parents:
15195
diff
changeset
|
819 %! assert (bsxfun (fun, f_type(y), f_type(x)), ... |
13013
5307bf69cd88
Add tests for automatic bsxfun
Jordi Gutiérrez Hermoso <jordigh@gmail.com>
parents:
12972
diff
changeset
|
820 %! fun (f_type (y), f_type (x))); |
5307bf69cd88
Add tests for automatic bsxfun
Jordi Gutiérrez Hermoso <jordigh@gmail.com>
parents:
12972
diff
changeset
|
821 %! endfor |
5307bf69cd88
Add tests for automatic bsxfun
Jordi Gutiérrez Hermoso <jordigh@gmail.com>
parents:
12972
diff
changeset
|
822 %! endfor |
5307bf69cd88
Add tests for automatic bsxfun
Jordi Gutiérrez Hermoso <jordigh@gmail.com>
parents:
12972
diff
changeset
|
823 %! endfor |
5307bf69cd88
Add tests for automatic bsxfun
Jordi Gutiérrez Hermoso <jordigh@gmail.com>
parents:
12972
diff
changeset
|
824 %! |
6869 | 825 */ |