Mercurial > octave
annotate libinterp/corefcn/bsxfun.cc @ 30913:a4ed2fed7dfa
Add tests for automatic broadcasting with inplace times operator ".*=" (bug #38466).
* libinterp/corefcn/bsxfun.cc: Add tests for automatic broadcasting with inplace
times operator ".*=" with rhs of different shapes.
author | Markus Mützel <markus.muetzel@gmx.de> |
---|---|
date | Fri, 08 Apr 2022 17:50:00 +0200 |
parents | c9788d7f6e65 |
children | b86b86ad4b23 |
rev | line source |
---|---|
27923
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
1 //////////////////////////////////////////////////////////////////////// |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
2 // |
30564
796f54d4ddbf
update Octave Project Developers copyright for the new year
John W. Eaton <jwe@octave.org>
parents:
30390
diff
changeset
|
3 // Copyright (C) 2007-2022 The Octave Project Developers |
27923
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
4 // |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
5 // See the file COPYRIGHT.md in the top-level directory of this |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
6 // distribution or <https://octave.org/copyright/>. |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
7 // |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
8 // This file is part of Octave. |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
9 // |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
10 // Octave is free software: you can redistribute it and/or modify it |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
11 // under the terms of the GNU General Public License as published by |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
12 // the Free Software Foundation, either version 3 of the License, or |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
13 // (at your option) any later version. |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
14 // |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
15 // Octave is distributed in the hope that it will be useful, but |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
16 // WITHOUT ANY WARRANTY; without even the implied warranty of |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
17 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
18 // GNU General Public License for more details. |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
19 // |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
20 // You should have received a copy of the GNU General Public License |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
21 // along with Octave; see the file COPYING. If not, see |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
22 // <https://www.gnu.org/licenses/>. |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
23 // |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
24 //////////////////////////////////////////////////////////////////////// |
6869 | 25 |
21724
aba2e6293dd8
use "#if ..." consistently instead of "#ifdef" and "#ifndef"
John W. Eaton <jwe@octave.org>
parents:
21660
diff
changeset
|
26 #if defined (HAVE_CONFIG_H) |
21301
40de9f8f23a6
Use '#include "config.h"' rather than <config.h>.
Rik <rik@octave.org>
parents:
21200
diff
changeset
|
27 # include "config.h" |
6869 | 28 #endif |
29 | |
24947
bff4a7c7bc39
Fix bsxfun when operating with float complex values (bug #53179).
Rik <rik@octave.org>
parents:
24534
diff
changeset
|
30 #include <list> |
6869 | 31 #include <string> |
32 #include <vector> | |
33 | |
34 #include "lo-mappers.h" | |
35 | |
15039
e753177cde93
maint: Move non-dynamically linked functions from DLD-FUNCTIONS/ to corefcn/ directory
Rik <rik@octave.org>
parents:
14854
diff
changeset
|
36 #include "defun.h" |
23599
5cb3a2bb5e1e
don't use singleton for symbol_table
John W. Eaton <jwe@octave.org>
parents:
23587
diff
changeset
|
37 #include "interpreter.h" |
24947
bff4a7c7bc39
Fix bsxfun when operating with float complex values (bug #53179).
Rik <rik@octave.org>
parents:
24534
diff
changeset
|
38 #include "oct-map.h" |
6869 | 39 #include "ov-colon.h" |
24947
bff4a7c7bc39
Fix bsxfun when operating with float complex values (bug #53179).
Rik <rik@octave.org>
parents:
24534
diff
changeset
|
40 #include "ov-fcn-handle.h" |
bff4a7c7bc39
Fix bsxfun when operating with float complex values (bug #53179).
Rik <rik@octave.org>
parents:
24534
diff
changeset
|
41 #include "parse.h" |
6869 | 42 #include "unwind-prot.h" |
24947
bff4a7c7bc39
Fix bsxfun when operating with float complex values (bug #53179).
Rik <rik@octave.org>
parents:
24534
diff
changeset
|
43 #include "variables.h" |
9743
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 // Optimized bsxfun operations |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
46 enum bsxfun_builtin_op |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
47 { |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
48 bsxfun_builtin_plus = 0, |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
49 bsxfun_builtin_minus, |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
50 bsxfun_builtin_times, |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
51 bsxfun_builtin_divide, |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
52 bsxfun_builtin_max, |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
53 bsxfun_builtin_min, |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
54 bsxfun_builtin_eq, |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
55 bsxfun_builtin_ne, |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
56 bsxfun_builtin_lt, |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
57 bsxfun_builtin_le, |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
58 bsxfun_builtin_gt, |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
59 bsxfun_builtin_ge, |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
60 bsxfun_builtin_and, |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
61 bsxfun_builtin_or, |
9827
c15a5ed0da58
optimize bsxfun (@power, ...)
Jaroslav Hajek <highegg@gmail.com>
parents:
9783
diff
changeset
|
62 bsxfun_builtin_power, |
9743
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
63 bsxfun_builtin_unknown, |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
64 bsxfun_num_builtin_ops = bsxfun_builtin_unknown |
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 |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
67 const char *bsxfun_builtin_names[] = |
9743
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
68 { |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
69 "plus", |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
70 "minus", |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
71 "times", |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
72 "rdivide", |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
73 "max", |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
74 "min", |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
75 "eq", |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
76 "ne", |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
77 "lt", |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
78 "le", |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
79 "gt", |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
80 "ge", |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
81 "and", |
9827
c15a5ed0da58
optimize bsxfun (@power, ...)
Jaroslav Hajek <highegg@gmail.com>
parents:
9783
diff
changeset
|
82 "or", |
c15a5ed0da58
optimize bsxfun (@power, ...)
Jaroslav Hajek <highegg@gmail.com>
parents:
9783
diff
changeset
|
83 "power" |
9743
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
84 }; |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
85 |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
86 static bsxfun_builtin_op |
9743
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
87 bsxfun_builtin_lookup (const std::string& name) |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
88 { |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
89 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
|
90 if (name == bsxfun_builtin_names[i]) |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
91 return static_cast<bsxfun_builtin_op> (i); |
24947
bff4a7c7bc39
Fix bsxfun when operating with float complex values (bug #53179).
Rik <rik@octave.org>
parents:
24534
diff
changeset
|
92 |
9743
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
93 return bsxfun_builtin_unknown; |
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 |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
96 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
|
97 const octave_value&); |
9743
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
98 |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
99 // Static table of handlers. |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
100 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
|
101 |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
21080
diff
changeset
|
102 template <typename NDA, NDA (bsxfun_op) (const NDA&, const NDA&)> |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
103 static octave_value |
9743
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
104 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
|
105 { |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
106 NDA xa = octave_value_extract<NDA> (x); |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
107 NDA ya = octave_value_extract<NDA> (y); |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
108 return octave_value (bsxfun_op (xa, ya)); |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
109 } |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
110 |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
21080
diff
changeset
|
111 template <typename NDA, boolNDArray (bsxfun_rel) (const NDA&, const NDA&)> |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
112 static octave_value |
9743
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
113 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
|
114 { |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
115 NDA xa = octave_value_extract<NDA> (x); |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
116 NDA ya = octave_value_extract<NDA> (y); |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
117 return octave_value (bsxfun_rel (xa, ya)); |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
118 } |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
119 |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
120 // 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
|
121 // because of the potentially complex result. |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
21080
diff
changeset
|
122 template <typename NDA, typename CNDA> |
9827
c15a5ed0da58
optimize bsxfun (@power, ...)
Jaroslav Hajek <highegg@gmail.com>
parents:
9783
diff
changeset
|
123 static octave_value |
c15a5ed0da58
optimize bsxfun (@power, ...)
Jaroslav Hajek <highegg@gmail.com>
parents:
9783
diff
changeset
|
124 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
|
125 { |
c15a5ed0da58
optimize bsxfun (@power, ...)
Jaroslav Hajek <highegg@gmail.com>
parents:
9783
diff
changeset
|
126 NDA xa = octave_value_extract<NDA> (x); |
c15a5ed0da58
optimize bsxfun (@power, ...)
Jaroslav Hajek <highegg@gmail.com>
parents:
9783
diff
changeset
|
127 NDA ya = octave_value_extract<NDA> (y); |
c15a5ed0da58
optimize bsxfun (@power, ...)
Jaroslav Hajek <highegg@gmail.com>
parents:
9783
diff
changeset
|
128 if (! ya.all_integers () && xa.any_element_is_negative ()) |
c15a5ed0da58
optimize bsxfun (@power, ...)
Jaroslav Hajek <highegg@gmail.com>
parents:
9783
diff
changeset
|
129 return octave_value (bsxfun_pow (CNDA (xa), ya)); |
c15a5ed0da58
optimize bsxfun (@power, ...)
Jaroslav Hajek <highegg@gmail.com>
parents:
9783
diff
changeset
|
130 else |
c15a5ed0da58
optimize bsxfun (@power, ...)
Jaroslav Hajek <highegg@gmail.com>
parents:
9783
diff
changeset
|
131 return octave_value (bsxfun_pow (xa, ya)); |
c15a5ed0da58
optimize bsxfun (@power, ...)
Jaroslav Hajek <highegg@gmail.com>
parents:
9783
diff
changeset
|
132 } |
c15a5ed0da58
optimize bsxfun (@power, ...)
Jaroslav Hajek <highegg@gmail.com>
parents:
9783
diff
changeset
|
133 |
9743
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
134 static void maybe_fill_table (void) |
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 static bool filled = false; |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
137 if (filled) |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
138 return; |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
139 |
22197
e43d83253e28
refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
140 #define REGISTER_OP_HANDLER(OP, BTYP, NDA, FUNOP) \ |
9743
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
141 bsxfun_handler_table[OP][BTYP] = bsxfun_forward_op<NDA, FUNOP> |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
142 |
22197
e43d83253e28
refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
143 #define REGISTER_REL_HANDLER(REL, BTYP, NDA, FUNREL) \ |
9743
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
144 bsxfun_handler_table[REL][BTYP] = bsxfun_forward_rel<NDA, FUNREL> |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
145 |
22197
e43d83253e28
refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
146 #define REGISTER_STD_HANDLERS(BTYP, NDA) \ |
e43d83253e28
refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
147 REGISTER_OP_HANDLER (bsxfun_builtin_plus, BTYP, NDA, bsxfun_add); \ |
e43d83253e28
refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
148 REGISTER_OP_HANDLER (bsxfun_builtin_minus, BTYP, NDA, bsxfun_sub); \ |
e43d83253e28
refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
149 REGISTER_OP_HANDLER (bsxfun_builtin_times, BTYP, NDA, bsxfun_mul); \ |
e43d83253e28
refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
150 REGISTER_OP_HANDLER (bsxfun_builtin_divide, BTYP, NDA, bsxfun_div); \ |
e43d83253e28
refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
151 REGISTER_OP_HANDLER (bsxfun_builtin_max, BTYP, NDA, bsxfun_max); \ |
e43d83253e28
refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
152 REGISTER_OP_HANDLER (bsxfun_builtin_min, BTYP, NDA, bsxfun_min); \ |
e43d83253e28
refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
153 REGISTER_REL_HANDLER (bsxfun_builtin_eq, BTYP, NDA, bsxfun_eq); \ |
e43d83253e28
refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
154 REGISTER_REL_HANDLER (bsxfun_builtin_ne, BTYP, NDA, bsxfun_ne); \ |
e43d83253e28
refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
155 REGISTER_REL_HANDLER (bsxfun_builtin_lt, BTYP, NDA, bsxfun_lt); \ |
e43d83253e28
refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
156 REGISTER_REL_HANDLER (bsxfun_builtin_le, BTYP, NDA, bsxfun_le); \ |
e43d83253e28
refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
157 REGISTER_REL_HANDLER (bsxfun_builtin_gt, BTYP, NDA, bsxfun_gt); \ |
9743
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
158 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
|
159 |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
160 REGISTER_STD_HANDLERS (btyp_double, NDArray); |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
161 REGISTER_STD_HANDLERS (btyp_float, FloatNDArray); |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
162 REGISTER_STD_HANDLERS (btyp_complex, ComplexNDArray); |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
163 REGISTER_STD_HANDLERS (btyp_float_complex, FloatComplexNDArray); |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
164 REGISTER_STD_HANDLERS (btyp_int8, int8NDArray); |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
165 REGISTER_STD_HANDLERS (btyp_int16, int16NDArray); |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
166 REGISTER_STD_HANDLERS (btyp_int32, int32NDArray); |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
167 REGISTER_STD_HANDLERS (btyp_int64, int64NDArray); |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
168 REGISTER_STD_HANDLERS (btyp_uint8, uint8NDArray); |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
169 REGISTER_STD_HANDLERS (btyp_uint16, uint16NDArray); |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
170 REGISTER_STD_HANDLERS (btyp_uint32, uint32NDArray); |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
171 REGISTER_STD_HANDLERS (btyp_uint64, uint64NDArray); |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
172 |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
173 // For bools, we register and/or. |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
174 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
|
175 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
|
176 |
9827
c15a5ed0da58
optimize bsxfun (@power, ...)
Jaroslav Hajek <highegg@gmail.com>
parents:
9783
diff
changeset
|
177 // Register power handlers. |
27277
db687716fed6
style fixes: generally aim to break long lines before operators, not after
John W. Eaton <jwe@octave.org>
parents:
26376
diff
changeset
|
178 bsxfun_handler_table[bsxfun_builtin_power][btyp_double] |
db687716fed6
style fixes: generally aim to break long lines before operators, not after
John W. Eaton <jwe@octave.org>
parents:
26376
diff
changeset
|
179 = do_bsxfun_real_pow<NDArray, ComplexNDArray>; |
db687716fed6
style fixes: generally aim to break long lines before operators, not after
John W. Eaton <jwe@octave.org>
parents:
26376
diff
changeset
|
180 bsxfun_handler_table[bsxfun_builtin_power][btyp_float] |
db687716fed6
style fixes: generally aim to break long lines before operators, not after
John W. Eaton <jwe@octave.org>
parents:
26376
diff
changeset
|
181 = do_bsxfun_real_pow<FloatNDArray, FloatComplexNDArray>; |
9827
c15a5ed0da58
optimize bsxfun (@power, ...)
Jaroslav Hajek <highegg@gmail.com>
parents:
9783
diff
changeset
|
182 |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
183 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
|
184 bsxfun_pow); |
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
185 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
|
186 FloatComplexNDArray, bsxfun_pow); |
9827
c15a5ed0da58
optimize bsxfun (@power, ...)
Jaroslav Hajek <highegg@gmail.com>
parents:
9783
diff
changeset
|
187 |
10107
fd262afea1d1
optimize bsxfun for chars
Jaroslav Hajek <highegg@gmail.com>
parents:
9827
diff
changeset
|
188 // For chars, we want just relational handlers. |
fd262afea1d1
optimize bsxfun for chars
Jaroslav Hajek <highegg@gmail.com>
parents:
9827
diff
changeset
|
189 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
|
190 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
|
191 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
|
192 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
|
193 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
|
194 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
|
195 |
9783
119d97db51f0
avoid repeated table init in bsxfun
Jaroslav Hajek <highegg@gmail.com>
parents:
9743
diff
changeset
|
196 filled = true; |
9743
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
197 } |
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 static octave_value |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
200 maybe_optimized_builtin (const std::string& name, |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
201 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
|
202 { |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
203 octave_value retval; |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
204 |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
205 maybe_fill_table (); |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
206 |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
207 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
|
208 if (op != bsxfun_builtin_unknown) |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
209 { |
18100
6a71e5030df5
Follow coding convention of defining and initializing only 1 variable per line in liboctinterp.
Rik <rik@octave.org>
parents:
17787
diff
changeset
|
210 builtin_type_t btyp_a = a.builtin_type (); |
6a71e5030df5
Follow coding convention of defining and initializing only 1 variable per line in liboctinterp.
Rik <rik@octave.org>
parents:
17787
diff
changeset
|
211 builtin_type_t btyp_b = b.builtin_type (); |
9743
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
212 |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
213 // Simplify single/double combinations. |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
214 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
|
215 btyp_b = btyp_float; |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
216 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
|
217 btyp_a = btyp_float; |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
218 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
|
219 btyp_b = btyp_float_complex; |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
220 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
|
221 btyp_a = btyp_float_complex; |
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 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
|
224 { |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
225 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
|
226 if (handler) |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
227 retval = handler (a, b); |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
228 } |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
229 } |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
230 |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
231 return retval; |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
232 } |
6869 | 233 |
234 static bool | |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
235 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
|
236 const dim_vector& dva, const dim_vector& dvc, |
23433
c9fab0bc983e
maint: Use convention 'int& x' for naming references.
Rik <rik@octave.org>
parents:
23220
diff
changeset
|
237 octave_idx_type i, octave_value_list& idx) |
6869 | 238 { |
21660
53728df3e4c9
maint: for clarity, call ndims() rather than length() on dimension vectors.
Rik <rik@octave.org>
parents:
21602
diff
changeset
|
239 octave_idx_type nd = dva.ndims (); |
6869 | 240 |
241 if (i == 0) | |
242 { | |
243 idx(0) = octave_value (':'); | |
244 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
|
245 { |
20218
b2100e1659ac
maint: Use cuddled parentheses when indexing dimension_vectors.
Rik <rik@octave.org>
parents:
20172
diff
changeset
|
246 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
|
247 idx(j) = octave_value (1); |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
248 else |
14854
5ae9f0f77635
maint: Use Octave coding conventions for coddling parenthis is DLD-FUNCTIONS directory
Rik <octave@nomad.inbox5.com>
parents:
14846
diff
changeset
|
249 idx(j) = octave_value ((i % dvc(j)) + 1); |
6869 | 250 |
20230
e914b5399c67
Use in-place operators in C++ code where possible.
Rik <rik@octave.org>
parents:
20218
diff
changeset
|
251 i /= dvc(j); |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
252 } |
6869 | 253 |
254 Ac = A; | |
255 Ac = Ac.single_subsref ("(", idx); | |
256 return true; | |
257 } | |
258 else | |
259 { | |
260 bool is_changed = false; | |
261 octave_idx_type k = i; | |
262 octave_idx_type k1 = i - 1; | |
263 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
|
264 { |
20218
b2100e1659ac
maint: Use cuddled parentheses when indexing dimension_vectors.
Rik <rik@octave.org>
parents:
20172
diff
changeset
|
265 if (dva(j) != 1 && k % dvc(j) != k1 % dvc(j)) |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
266 { |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
267 idx (j) = octave_value ((k % dvc(j)) + 1); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
268 is_changed = true; |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
269 } |
6869 | 270 |
20230
e914b5399c67
Use in-place operators in C++ code where possible.
Rik <rik@octave.org>
parents:
20218
diff
changeset
|
271 k /= dvc(j); |
e914b5399c67
Use in-place operators in C++ code where possible.
Rik <rik@octave.org>
parents:
20218
diff
changeset
|
272 k1 /= dvc(j); |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
273 } |
6869 | 274 |
275 if (is_changed) | |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
276 { |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
277 Ac = A; |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
278 Ac = Ac.single_subsref ("(", idx); |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
279 return true; |
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
280 } |
6869 | 281 else |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
282 return false; |
6869 | 283 } |
284 } | |
285 | |
6959 | 286 #if 0 |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
287 // FIXME: this function is not used; is it OK to delete it? |
6869 | 288 static void |
289 update_index (octave_value_list& idx, const dim_vector& dv, octave_idx_type i) | |
290 { | |
21660
53728df3e4c9
maint: for clarity, call ndims() rather than length() on dimension vectors.
Rik <rik@octave.org>
parents:
21602
diff
changeset
|
291 octave_idx_type nd = dv.ndims (); |
6869 | 292 |
293 if (i == 0) | |
294 { | |
295 for (octave_idx_type j = nd - 1; j > 0; j--) | |
19739
3fa35defe495
Adjust spacing of static_cast<> calls to follow Octave coding conventions.
Rik <rik@octave.org>
parents:
19697
diff
changeset
|
296 idx(j) = octave_value (1.0); |
6869 | 297 idx(0) = octave_value (':'); |
298 } | |
299 else | |
300 { | |
301 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
|
302 { |
20218
b2100e1659ac
maint: Use cuddled parentheses when indexing dimension_vectors.
Rik <rik@octave.org>
parents:
20172
diff
changeset
|
303 idx (j) = octave_value (i % dv(j) + 1); |
20230
e914b5399c67
Use in-place operators in C++ code where possible.
Rik <rik@octave.org>
parents:
20218
diff
changeset
|
304 i /= dv(j); |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
305 } |
6869 | 306 } |
307 } | |
6959 | 308 #endif |
6869 | 309 |
310 static void | |
311 update_index (Array<int>& idx, const dim_vector& dv, octave_idx_type i) | |
312 { | |
21660
53728df3e4c9
maint: for clarity, call ndims() rather than length() on dimension vectors.
Rik <rik@octave.org>
parents:
21602
diff
changeset
|
313 octave_idx_type nd = dv.ndims (); |
6869 | 314 |
315 idx(0) = 0; | |
316 for (octave_idx_type j = 1; j < nd; j++) | |
317 { | |
20218
b2100e1659ac
maint: Use cuddled parentheses when indexing dimension_vectors.
Rik <rik@octave.org>
parents:
20172
diff
changeset
|
318 idx(j) = i % dv(j); |
20230
e914b5399c67
Use in-place operators in C++ code where possible.
Rik <rik@octave.org>
parents:
20218
diff
changeset
|
319 i /= dv(j); |
6869 | 320 } |
321 } | |
322 | |
29958
32c3a5805893
move DEFUN and DEFMETHOD functions inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
29359
diff
changeset
|
323 OCTAVE_NAMESPACE_BEGIN |
32c3a5805893
move DEFUN and DEFMETHOD functions inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
29359
diff
changeset
|
324 |
30390
a61e1a0f6024
maint: style check C++ files in libinterp/ ahead of 7.1 release.
Rik <rik@octave.org>
parents:
30326
diff
changeset
|
325 DEFMETHOD (bsxfun, interp, args, , |
23599
5cb3a2bb5e1e
don't use singleton for symbol_table
John W. Eaton <jwe@octave.org>
parents:
23587
diff
changeset
|
326 doc: /* -*- texinfo -*- |
30888
32d2b6604a9f
doc: Ensure documentation lists output argument when it exists for functions in libinterp/
Rik <rik@octave.org>
parents:
30565
diff
changeset
|
327 @deftypefn {} {@var{C} =} bsxfun (@var{f}, @var{A}, @var{B}) |
25106
d7ad543255c5
doc: Shorten very long first sentences of docstrings (bug #53388).
Rik <rik@octave.org>
parents:
25054
diff
changeset
|
328 Apply a binary function @var{f} element-by-element to two array arguments |
d7ad543255c5
doc: Shorten very long first sentences of docstrings (bug #53388).
Rik <rik@octave.org>
parents:
25054
diff
changeset
|
329 @var{A} and @var{B}, expanding singleton dimensions in either input argument as |
d7ad543255c5
doc: Shorten very long first sentences of docstrings (bug #53388).
Rik <rik@octave.org>
parents:
25054
diff
changeset
|
330 necessary. |
21966
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
331 |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
332 @var{f} is a function handle, inline function, or string containing the name |
25106
d7ad543255c5
doc: Shorten very long first sentences of docstrings (bug #53388).
Rik <rik@octave.org>
parents:
25054
diff
changeset
|
333 of the function to evaluate. The function @var{f} must be capable of accepting |
d7ad543255c5
doc: Shorten very long first sentences of docstrings (bug #53388).
Rik <rik@octave.org>
parents:
25054
diff
changeset
|
334 two column-vector arguments of equal length, or one column vector argument and |
d7ad543255c5
doc: Shorten very long first sentences of docstrings (bug #53388).
Rik <rik@octave.org>
parents:
25054
diff
changeset
|
335 a scalar. |
21966
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
336 |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
337 The dimensions of @var{A} and @var{B} must be equal or singleton. The |
25106
d7ad543255c5
doc: Shorten very long first sentences of docstrings (bug #53388).
Rik <rik@octave.org>
parents:
25054
diff
changeset
|
338 singleton dimensions of the arrays will be expanded to the same dimensionality |
d7ad543255c5
doc: Shorten very long first sentences of docstrings (bug #53388).
Rik <rik@octave.org>
parents:
25054
diff
changeset
|
339 as the other array. |
21966
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
340 @seealso{arrayfun, cellfun} |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
341 @end deftypefn */) |
6869 | 342 { |
20819
f428cbe7576f
eliminate unnecessary uses of nargin
John W. Eaton <jwe@octave.org>
parents:
20802
diff
changeset
|
343 if (args.length () != 3) |
6869 | 344 print_usage (); |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
345 |
30896
c9788d7f6e65
maint: Use "fcn" as preferred abbreviation for "function" in libinterp/.
Rik <rik@octave.org>
parents:
30888
diff
changeset
|
346 octave_value fcn = args(0); |
c9788d7f6e65
maint: Use "fcn" as preferred abbreviation for "function" in libinterp/.
Rik <rik@octave.org>
parents:
30888
diff
changeset
|
347 if (fcn.is_string ()) |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
348 { |
30896
c9788d7f6e65
maint: Use "fcn" as preferred abbreviation for "function" in libinterp/.
Rik <rik@octave.org>
parents:
30888
diff
changeset
|
349 std::string name = fcn.string_value (); |
23599
5cb3a2bb5e1e
don't use singleton for symbol_table
John W. Eaton <jwe@octave.org>
parents:
23587
diff
changeset
|
350 |
29961
7d6709900da7
eliminate octave:: namespace tags in DEFUN and DEFMETHOD and more
John W. Eaton <jwe@octave.org>
parents:
29958
diff
changeset
|
351 symbol_table& symtab = interp.get_symbol_table (); |
23599
5cb3a2bb5e1e
don't use singleton for symbol_table
John W. Eaton <jwe@octave.org>
parents:
23587
diff
changeset
|
352 |
30896
c9788d7f6e65
maint: Use "fcn" as preferred abbreviation for "function" in libinterp/.
Rik <rik@octave.org>
parents:
30888
diff
changeset
|
353 fcn = symtab.find_function (name); |
23599
5cb3a2bb5e1e
don't use singleton for symbol_table
John W. Eaton <jwe@octave.org>
parents:
23587
diff
changeset
|
354 |
30896
c9788d7f6e65
maint: Use "fcn" as preferred abbreviation for "function" in libinterp/.
Rik <rik@octave.org>
parents:
30888
diff
changeset
|
355 if (fcn.is_undefined ()) |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
356 error ("bsxfun: invalid function name: %s", name.c_str ()); |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
357 } |
20918
6f0bd96f93c0
maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents:
20853
diff
changeset
|
358 else if (! (args(0).is_function_handle () || args(0).is_inline_function ())) |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
359 error ("bsxfun: F must be a string or function handle"); |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
360 |
20918
6f0bd96f93c0
maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents:
20853
diff
changeset
|
361 octave_value_list retval; |
6f0bd96f93c0
maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents:
20853
diff
changeset
|
362 |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
363 const octave_value A = args(1); |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
364 const octave_value B = args(2); |
6869 | 365 |
30896
c9788d7f6e65
maint: Use "fcn" as preferred abbreviation for "function" in libinterp/.
Rik <rik@octave.org>
parents:
30888
diff
changeset
|
366 if (fcn.is_builtin_function () |
c9788d7f6e65
maint: Use "fcn" as preferred abbreviation for "function" in libinterp/.
Rik <rik@octave.org>
parents:
30888
diff
changeset
|
367 || (fcn.is_function_handle () && ! A.isobject () && ! B.isobject ())) |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
368 { |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
369 // This may break if the default behavior is overridden. But if you |
20918
6f0bd96f93c0
maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents:
20853
diff
changeset
|
370 // override arithmetic operators for builtin classes, you should expect |
6f0bd96f93c0
maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents:
20853
diff
changeset
|
371 // mayhem anyway (constant folding etc). Querying is_overloaded() may |
6f0bd96f93c0
maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents:
20853
diff
changeset
|
372 // not be exactly what we need here. |
30896
c9788d7f6e65
maint: Use "fcn" as preferred abbreviation for "function" in libinterp/.
Rik <rik@octave.org>
parents:
30888
diff
changeset
|
373 octave_function *fcn_val = fcn.function_value (); |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
374 if (fcn_val) |
9743
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
375 { |
20918
6f0bd96f93c0
maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents:
20853
diff
changeset
|
376 octave_value tmp = maybe_optimized_builtin (fcn_val->name (), A, B); |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
377 if (tmp.is_defined ()) |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
378 retval(0) = tmp; |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
379 } |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
380 } |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
381 |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
382 if (retval.empty ()) |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
383 { |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
384 dim_vector dva = A.dims (); |
21660
53728df3e4c9
maint: for clarity, call ndims() rather than length() on dimension vectors.
Rik <rik@octave.org>
parents:
21602
diff
changeset
|
385 octave_idx_type nda = dva.ndims (); |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
386 dim_vector dvb = B.dims (); |
21660
53728df3e4c9
maint: for clarity, call ndims() rather than length() on dimension vectors.
Rik <rik@octave.org>
parents:
21602
diff
changeset
|
387 octave_idx_type ndb = dvb.ndims (); |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
388 octave_idx_type nd = nda; |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
389 |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
390 if (nda > ndb) |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
391 dvb.resize (nda, 1); |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
392 else if (nda < ndb) |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
393 { |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
394 dva.resize (ndb, 1); |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
395 nd = ndb; |
9743
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
396 } |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9450
diff
changeset
|
397 |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
398 for (octave_idx_type i = 0; i < nd; i++) |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
399 if (dva(i) != dvb(i) && dva(i) != 1 && dvb(i) != 1) |
20918
6f0bd96f93c0
maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents:
20853
diff
changeset
|
400 error ("bsxfun: dimensions of A and B must match"); |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
401 |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
402 // Find the size of the output |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
403 dim_vector dvc; |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
404 dvc.resize (nd); |
6869 | 405 |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
406 for (octave_idx_type i = 0; i < nd; i++) |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
407 dvc(i) = (dva(i) < 1 ? dva(i) |
23450
855122b993da
maint: Wrap tertiary operator in parentheses "(COND ? x : y)".
Rik <rik@octave.org>
parents:
23433
diff
changeset
|
408 : (dvb(i) < 1 ? dvb(i) |
855122b993da
maint: Wrap tertiary operator in parentheses "(COND ? x : y)".
Rik <rik@octave.org>
parents:
23433
diff
changeset
|
409 : (dva(i) > dvb(i) ? dva(i) |
855122b993da
maint: Wrap tertiary operator in parentheses "(COND ? x : y)".
Rik <rik@octave.org>
parents:
23433
diff
changeset
|
410 : dvb(i)))); |
6869 | 411 |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
412 if (dva == dvb || dva.numel () == 1 || dvb.numel () == 1) |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
413 { |
21080
529593df22fa
bsxfun.cc: Pre-declare size of octave_value_list.
Rik <rik@octave.org>
parents:
20918
diff
changeset
|
414 octave_value_list inputs (2); |
529593df22fa
bsxfun.cc: Pre-declare size of octave_value_list.
Rik <rik@octave.org>
parents:
20918
diff
changeset
|
415 inputs(0) = A; |
529593df22fa
bsxfun.cc: Pre-declare size of octave_value_list.
Rik <rik@octave.org>
parents:
20918
diff
changeset
|
416 inputs(1) = B; |
30896
c9788d7f6e65
maint: Use "fcn" as preferred abbreviation for "function" in libinterp/.
Rik <rik@octave.org>
parents:
30888
diff
changeset
|
417 retval = feval (fcn, inputs, 1); |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
418 } |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
419 else if (dvc.numel () < 1) |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
420 { |
21080
529593df22fa
bsxfun.cc: Pre-declare size of octave_value_list.
Rik <rik@octave.org>
parents:
20918
diff
changeset
|
421 octave_value_list inputs (2); |
529593df22fa
bsxfun.cc: Pre-declare size of octave_value_list.
Rik <rik@octave.org>
parents:
20918
diff
changeset
|
422 inputs(0) = A.resize (dvc); |
529593df22fa
bsxfun.cc: Pre-declare size of octave_value_list.
Rik <rik@octave.org>
parents:
20918
diff
changeset
|
423 inputs(1) = B.resize (dvc); |
30896
c9788d7f6e65
maint: Use "fcn" as preferred abbreviation for "function" in libinterp/.
Rik <rik@octave.org>
parents:
30888
diff
changeset
|
424 retval = feval (fcn, inputs, 1); |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
425 } |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
426 else |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
427 { |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
428 octave_idx_type ncount = 1; |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
429 for (octave_idx_type i = 1; i < nd; i++) |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
430 ncount *= dvc(i); |
6869 | 431 |
22197
e43d83253e28
refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
432 #define BSXDEF(T) \ |
e43d83253e28
refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
433 T result_ ## T; \ |
e43d83253e28
refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
434 bool have_ ## T = false; |
6869 | 435 |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
436 BSXDEF(NDArray); |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
437 BSXDEF(ComplexNDArray); |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
438 BSXDEF(FloatNDArray); |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
439 BSXDEF(FloatComplexNDArray); |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
440 BSXDEF(boolNDArray); |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
441 BSXDEF(int8NDArray); |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
442 BSXDEF(int16NDArray); |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
443 BSXDEF(int32NDArray); |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
444 BSXDEF(int64NDArray); |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
445 BSXDEF(uint8NDArray); |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
446 BSXDEF(uint16NDArray); |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
447 BSXDEF(uint32NDArray); |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
448 BSXDEF(uint64NDArray); |
6869 | 449 |
21602
47c76e56a1de
maint: Remove extra space between end of statement and semicolon.
Rik <rik@octave.org>
parents:
21580
diff
changeset
|
450 octave_value Ac; |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
451 octave_value_list idxA; |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
452 octave_value Bc; |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
453 octave_value_list idxB; |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
454 octave_value C; |
21080
529593df22fa
bsxfun.cc: Pre-declare size of octave_value_list.
Rik <rik@octave.org>
parents:
20918
diff
changeset
|
455 octave_value_list inputs (2); |
21660
53728df3e4c9
maint: for clarity, call ndims() rather than length() on dimension vectors.
Rik <rik@octave.org>
parents:
21602
diff
changeset
|
456 Array<int> ra_idx (dim_vector (dvc.ndims (), 1), 0); |
6869 | 457 |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
458 for (octave_idx_type i = 0; i < ncount; i++) |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
459 { |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
460 if (maybe_update_column (Ac, A, dva, dvc, i, idxA)) |
21080
529593df22fa
bsxfun.cc: Pre-declare size of octave_value_list.
Rik <rik@octave.org>
parents:
20918
diff
changeset
|
461 inputs(0) = Ac; |
6869 | 462 |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
463 if (maybe_update_column (Bc, B, dvb, dvc, i, idxB)) |
21080
529593df22fa
bsxfun.cc: Pre-declare size of octave_value_list.
Rik <rik@octave.org>
parents:
20918
diff
changeset
|
464 inputs(1) = Bc; |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
465 |
30896
c9788d7f6e65
maint: Use "fcn" as preferred abbreviation for "function" in libinterp/.
Rik <rik@octave.org>
parents:
30888
diff
changeset
|
466 octave_value_list tmp = feval (fcn, inputs, 1); |
6869 | 467 |
22197
e43d83253e28
refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
468 #define BSXINIT(T, CLS, EXTRACTOR) \ |
e43d83253e28
refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
469 (result_type == CLS) \ |
e43d83253e28
refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
470 { \ |
e43d83253e28
refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
471 have_ ## T = true; \ |
e43d83253e28
refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
472 result_ ## T = tmp(0). EXTRACTOR ## _array_value (); \ |
e43d83253e28
refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
473 result_ ## T .resize (dvc); \ |
e43d83253e28
refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
474 } |
6869 | 475 |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
476 if (i == 0) |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
477 { |
23583
b7747a2c88b2
maint: Deprecate is_sparse_type and replace with issparse.
Rik <rik@octave.org>
parents:
23582
diff
changeset
|
478 if (! tmp(0).issparse ()) |
20555
f90c8372b7ba
eliminate many more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents:
20230
diff
changeset
|
479 { |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
480 std::string result_type = tmp(0).class_name (); |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
481 if (result_type == "double") |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
482 { |
23582
0cc2011d800e
maint: Deprecate is_real_type and replace with isreal.
Rik <rik@octave.org>
parents:
23581
diff
changeset
|
483 if (tmp(0).isreal ()) |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
484 { |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
485 have_NDArray = true; |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
486 result_NDArray = tmp(0).array_value (); |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
487 result_NDArray.resize (dvc); |
20555
f90c8372b7ba
eliminate many more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents:
20230
diff
changeset
|
488 } |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
489 else |
20555
f90c8372b7ba
eliminate many more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents:
20230
diff
changeset
|
490 { |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
491 have_ComplexNDArray = true; |
27277
db687716fed6
style fixes: generally aim to break long lines before operators, not after
John W. Eaton <jwe@octave.org>
parents:
26376
diff
changeset
|
492 result_ComplexNDArray |
db687716fed6
style fixes: generally aim to break long lines before operators, not after
John W. Eaton <jwe@octave.org>
parents:
26376
diff
changeset
|
493 = tmp(0).complex_array_value (); |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
494 result_ComplexNDArray.resize (dvc); |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
495 } |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
496 } |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
497 else if (result_type == "single") |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
498 { |
23582
0cc2011d800e
maint: Deprecate is_real_type and replace with isreal.
Rik <rik@octave.org>
parents:
23581
diff
changeset
|
499 if (tmp(0).isreal ()) |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
500 { |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
501 have_FloatNDArray = true; |
27277
db687716fed6
style fixes: generally aim to break long lines before operators, not after
John W. Eaton <jwe@octave.org>
parents:
26376
diff
changeset
|
502 result_FloatNDArray |
db687716fed6
style fixes: generally aim to break long lines before operators, not after
John W. Eaton <jwe@octave.org>
parents:
26376
diff
changeset
|
503 = tmp(0).float_array_value (); |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
504 result_FloatNDArray.resize (dvc); |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
505 } |
20555
f90c8372b7ba
eliminate many more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents:
20230
diff
changeset
|
506 else |
f90c8372b7ba
eliminate many more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents:
20230
diff
changeset
|
507 { |
24947
bff4a7c7bc39
Fix bsxfun when operating with float complex values (bug #53179).
Rik <rik@octave.org>
parents:
24534
diff
changeset
|
508 have_FloatComplexNDArray = true; |
27277
db687716fed6
style fixes: generally aim to break long lines before operators, not after
John W. Eaton <jwe@octave.org>
parents:
26376
diff
changeset
|
509 result_FloatComplexNDArray |
db687716fed6
style fixes: generally aim to break long lines before operators, not after
John W. Eaton <jwe@octave.org>
parents:
26376
diff
changeset
|
510 = tmp(0).float_complex_array_value (); |
24947
bff4a7c7bc39
Fix bsxfun when operating with float complex values (bug #53179).
Rik <rik@octave.org>
parents:
24534
diff
changeset
|
511 result_FloatComplexNDArray.resize (dvc); |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
512 } |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
513 } |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
514 else if BSXINIT(boolNDArray, "logical", bool) |
20918
6f0bd96f93c0
maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents:
20853
diff
changeset
|
515 else if BSXINIT(int8NDArray, "int8", int8) |
6f0bd96f93c0
maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents:
20853
diff
changeset
|
516 else if BSXINIT(int16NDArray, "int16", int16) |
6f0bd96f93c0
maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents:
20853
diff
changeset
|
517 else if BSXINIT(int32NDArray, "int32", int32) |
6f0bd96f93c0
maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents:
20853
diff
changeset
|
518 else if BSXINIT(int64NDArray, "int64", int64) |
6f0bd96f93c0
maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents:
20853
diff
changeset
|
519 else if BSXINIT(uint8NDArray, "uint8", uint8) |
6f0bd96f93c0
maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents:
20853
diff
changeset
|
520 else if BSXINIT(uint16NDArray, "uint16", uint16) |
6f0bd96f93c0
maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents:
20853
diff
changeset
|
521 else if BSXINIT(uint32NDArray, "uint32", uint32) |
6f0bd96f93c0
maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents:
20853
diff
changeset
|
522 else if BSXINIT(uint64NDArray, "uint64", uint64) |
6f0bd96f93c0
maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents:
20853
diff
changeset
|
523 else |
6f0bd96f93c0
maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents:
20853
diff
changeset
|
524 { |
6f0bd96f93c0
maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents:
20853
diff
changeset
|
525 C = tmp(0); |
6f0bd96f93c0
maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents:
20853
diff
changeset
|
526 C = C.resize (dvc); |
6f0bd96f93c0
maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents:
20853
diff
changeset
|
527 } |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
528 } |
21372
a1aa52bff079
Allow bsxfun to work for sparse and type conversion (bug #45219, bug #40089).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21345
diff
changeset
|
529 else // Skip semi-fast path for sparse matrices |
a1aa52bff079
Allow bsxfun to work for sparse and type conversion (bug #45219, bug #40089).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21345
diff
changeset
|
530 { |
a1aa52bff079
Allow bsxfun to work for sparse and type conversion (bug #45219, bug #40089).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21345
diff
changeset
|
531 C = tmp (0); |
a1aa52bff079
Allow bsxfun to work for sparse and type conversion (bug #45219, bug #40089).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21345
diff
changeset
|
532 C = C.resize (dvc); |
a1aa52bff079
Allow bsxfun to work for sparse and type conversion (bug #45219, bug #40089).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21345
diff
changeset
|
533 } |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
534 } |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
535 else |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
536 { |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
537 update_index (ra_idx, dvc, i); |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
538 |
24947
bff4a7c7bc39
Fix bsxfun when operating with float complex values (bug #53179).
Rik <rik@octave.org>
parents:
24534
diff
changeset
|
539 if (have_NDArray) |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
540 { |
23585
570170b6eb09
maint: Deprecate is_float_type and replace with isfloat.
Rik <rik@octave.org>
parents:
23583
diff
changeset
|
541 if (! tmp(0).isfloat ()) |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
542 { |
24947
bff4a7c7bc39
Fix bsxfun when operating with float complex values (bug #53179).
Rik <rik@octave.org>
parents:
24534
diff
changeset
|
543 have_NDArray = false; |
bff4a7c7bc39
Fix bsxfun when operating with float complex values (bug #53179).
Rik <rik@octave.org>
parents:
24534
diff
changeset
|
544 C = result_NDArray; |
29961
7d6709900da7
eliminate octave:: namespace tags in DEFUN and DEFMETHOD and more
John W. Eaton <jwe@octave.org>
parents:
29958
diff
changeset
|
545 C = cat_op (C, tmp(0), ra_idx); |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
546 } |
24947
bff4a7c7bc39
Fix bsxfun when operating with float complex values (bug #53179).
Rik <rik@octave.org>
parents:
24534
diff
changeset
|
547 else if (tmp(0).isreal ()) |
bff4a7c7bc39
Fix bsxfun when operating with float complex values (bug #53179).
Rik <rik@octave.org>
parents:
24534
diff
changeset
|
548 result_NDArray.insert (tmp(0).array_value (), ra_idx); |
bff4a7c7bc39
Fix bsxfun when operating with float complex values (bug #53179).
Rik <rik@octave.org>
parents:
24534
diff
changeset
|
549 else |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
550 { |
27277
db687716fed6
style fixes: generally aim to break long lines before operators, not after
John W. Eaton <jwe@octave.org>
parents:
26376
diff
changeset
|
551 result_ComplexNDArray |
db687716fed6
style fixes: generally aim to break long lines before operators, not after
John W. Eaton <jwe@octave.org>
parents:
26376
diff
changeset
|
552 = ComplexNDArray (result_NDArray); |
24947
bff4a7c7bc39
Fix bsxfun when operating with float complex values (bug #53179).
Rik <rik@octave.org>
parents:
24534
diff
changeset
|
553 result_ComplexNDArray.insert |
bff4a7c7bc39
Fix bsxfun when operating with float complex values (bug #53179).
Rik <rik@octave.org>
parents:
24534
diff
changeset
|
554 (tmp(0).complex_array_value (), ra_idx); |
bff4a7c7bc39
Fix bsxfun when operating with float complex values (bug #53179).
Rik <rik@octave.org>
parents:
24534
diff
changeset
|
555 have_NDArray = false; |
bff4a7c7bc39
Fix bsxfun when operating with float complex values (bug #53179).
Rik <rik@octave.org>
parents:
24534
diff
changeset
|
556 have_ComplexNDArray = true; |
bff4a7c7bc39
Fix bsxfun when operating with float complex values (bug #53179).
Rik <rik@octave.org>
parents:
24534
diff
changeset
|
557 } |
bff4a7c7bc39
Fix bsxfun when operating with float complex values (bug #53179).
Rik <rik@octave.org>
parents:
24534
diff
changeset
|
558 } |
bff4a7c7bc39
Fix bsxfun when operating with float complex values (bug #53179).
Rik <rik@octave.org>
parents:
24534
diff
changeset
|
559 else if (have_FloatNDArray) |
bff4a7c7bc39
Fix bsxfun when operating with float complex values (bug #53179).
Rik <rik@octave.org>
parents:
24534
diff
changeset
|
560 { |
bff4a7c7bc39
Fix bsxfun when operating with float complex values (bug #53179).
Rik <rik@octave.org>
parents:
24534
diff
changeset
|
561 if (! tmp(0).isfloat ()) |
bff4a7c7bc39
Fix bsxfun when operating with float complex values (bug #53179).
Rik <rik@octave.org>
parents:
24534
diff
changeset
|
562 { |
bff4a7c7bc39
Fix bsxfun when operating with float complex values (bug #53179).
Rik <rik@octave.org>
parents:
24534
diff
changeset
|
563 have_FloatNDArray = false; |
bff4a7c7bc39
Fix bsxfun when operating with float complex values (bug #53179).
Rik <rik@octave.org>
parents:
24534
diff
changeset
|
564 C = result_FloatNDArray; |
29961
7d6709900da7
eliminate octave:: namespace tags in DEFUN and DEFMETHOD and more
John W. Eaton <jwe@octave.org>
parents:
29958
diff
changeset
|
565 C = cat_op (C, tmp(0), ra_idx); |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
566 } |
23582
0cc2011d800e
maint: Deprecate is_real_type and replace with isreal.
Rik <rik@octave.org>
parents:
23581
diff
changeset
|
567 else if (tmp(0).isreal ()) |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
568 result_FloatNDArray.insert |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
569 (tmp(0).float_array_value (), ra_idx); |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
570 else |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
571 { |
27277
db687716fed6
style fixes: generally aim to break long lines before operators, not after
John W. Eaton <jwe@octave.org>
parents:
26376
diff
changeset
|
572 result_FloatComplexNDArray |
db687716fed6
style fixes: generally aim to break long lines before operators, not after
John W. Eaton <jwe@octave.org>
parents:
26376
diff
changeset
|
573 = FloatComplexNDArray (result_FloatNDArray); |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
574 result_FloatComplexNDArray.insert |
24947
bff4a7c7bc39
Fix bsxfun when operating with float complex values (bug #53179).
Rik <rik@octave.org>
parents:
24534
diff
changeset
|
575 (tmp(0).float_complex_array_value (), ra_idx); |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
576 have_FloatNDArray = false; |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
577 have_FloatComplexNDArray = true; |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
578 } |
20555
f90c8372b7ba
eliminate many more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents:
20230
diff
changeset
|
579 } |
6869 | 580 |
22197
e43d83253e28
refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
581 #define BSXLOOP(T, CLS, EXTRACTOR) \ |
e43d83253e28
refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
582 (have_ ## T) \ |
e43d83253e28
refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
583 { \ |
e43d83253e28
refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
584 if (tmp(0).class_name () != CLS) \ |
e43d83253e28
refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
585 { \ |
e43d83253e28
refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
586 have_ ## T = false; \ |
e43d83253e28
refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
587 C = result_ ## T; \ |
29961
7d6709900da7
eliminate octave:: namespace tags in DEFUN and DEFMETHOD and more
John W. Eaton <jwe@octave.org>
parents:
29958
diff
changeset
|
588 C = cat_op (C, tmp(0), ra_idx); \ |
22197
e43d83253e28
refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
589 } \ |
e43d83253e28
refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
590 else \ |
e43d83253e28
refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
591 result_ ## T .insert (tmp(0). EXTRACTOR ## _array_value (), ra_idx); \ |
e43d83253e28
refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
592 } |
6869 | 593 |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
594 else if BSXLOOP(ComplexNDArray, "double", complex) |
24947
bff4a7c7bc39
Fix bsxfun when operating with float complex values (bug #53179).
Rik <rik@octave.org>
parents:
24534
diff
changeset
|
595 else if BSXLOOP(FloatComplexNDArray, "single", float_complex) |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
596 else if BSXLOOP(boolNDArray, "logical", bool) |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
597 else if BSXLOOP(int8NDArray, "int8", int8) |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
598 else if BSXLOOP(int16NDArray, "int16", int16) |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
599 else if BSXLOOP(int32NDArray, "int32", int32) |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
600 else if BSXLOOP(int64NDArray, "int64", int64) |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
601 else if BSXLOOP(uint8NDArray, "uint8", uint8) |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
602 else if BSXLOOP(uint16NDArray, "uint16", uint16) |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
603 else if BSXLOOP(uint32NDArray, "uint32", uint32) |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
604 else if BSXLOOP(uint64NDArray, "uint64", uint64) |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
605 else |
29961
7d6709900da7
eliminate octave:: namespace tags in DEFUN and DEFMETHOD and more
John W. Eaton <jwe@octave.org>
parents:
29958
diff
changeset
|
606 C = cat_op (C, tmp(0), ra_idx); |
20555
f90c8372b7ba
eliminate many more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents:
20230
diff
changeset
|
607 } |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
608 } |
6869 | 609 |
22197
e43d83253e28
refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
610 #define BSXEND(T) \ |
e43d83253e28
refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
611 (have_ ## T) \ |
e43d83253e28
refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
612 retval(0) = result_ ## T; |
6869 | 613 |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
614 if BSXEND(NDArray) |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
615 else if BSXEND(ComplexNDArray) |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
616 else if BSXEND(FloatNDArray) |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
617 else if BSXEND(FloatComplexNDArray) |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
618 else if BSXEND(boolNDArray) |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
619 else if BSXEND(int8NDArray) |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
620 else if BSXEND(int16NDArray) |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
621 else if BSXEND(int32NDArray) |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
622 else if BSXEND(int64NDArray) |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
623 else if BSXEND(uint8NDArray) |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
624 else if BSXEND(uint16NDArray) |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
625 else if BSXEND(uint32NDArray) |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
626 else if BSXEND(uint64NDArray) |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
627 else |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
628 retval(0) = C; |
10154
40dfc0c99116
DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents:
10141
diff
changeset
|
629 } |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
630 } |
6869 | 631 |
632 return retval; | |
633 } | |
634 | |
635 /* | |
636 | |
637 %!shared a, b, c, f | |
638 %! a = randn (4, 4); | |
639 %! b = mean (a, 1); | |
640 %! c = mean (a, 2); | |
641 %! f = @minus; | |
28930
2883b3d08b7e
maint: Remove unnecessary parentheses bracketing %!error BIST tests.
Rik <rik@octave.org>
parents:
28631
diff
changeset
|
642 %!error bsxfun (f) |
2883b3d08b7e
maint: Remove unnecessary parentheses bracketing %!error BIST tests.
Rik <rik@octave.org>
parents:
28631
diff
changeset
|
643 %!error bsxfun (f, a) |
2883b3d08b7e
maint: Remove unnecessary parentheses bracketing %!error BIST tests.
Rik <rik@octave.org>
parents:
28631
diff
changeset
|
644 %!error bsxfun (a, b) |
2883b3d08b7e
maint: Remove unnecessary parentheses bracketing %!error BIST tests.
Rik <rik@octave.org>
parents:
28631
diff
changeset
|
645 %!error bsxfun (a, b, c) |
2883b3d08b7e
maint: Remove unnecessary parentheses bracketing %!error BIST tests.
Rik <rik@octave.org>
parents:
28631
diff
changeset
|
646 %!error bsxfun (f, a, b, c) |
2883b3d08b7e
maint: Remove unnecessary parentheses bracketing %!error BIST tests.
Rik <rik@octave.org>
parents:
28631
diff
changeset
|
647 %!error bsxfun (f, ones (4, 0), ones (4, 4)) |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
648 %!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
|
649 %!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
|
650 %!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
|
651 %!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
|
652 %!assert (bsxfun ("minus", ones (1, 4), ones (4, 1)), zeros (4, 4)) |
6869 | 653 |
654 %!shared a, b, c, f | |
655 %! a = randn (4, 4); | |
656 %! a(1) *= 1i; | |
657 %! b = mean (a, 1); | |
658 %! c = mean (a, 2); | |
659 %! f = @minus; | |
28930
2883b3d08b7e
maint: Remove unnecessary parentheses bracketing %!error BIST tests.
Rik <rik@octave.org>
parents:
28631
diff
changeset
|
660 %!error bsxfun (f) |
2883b3d08b7e
maint: Remove unnecessary parentheses bracketing %!error BIST tests.
Rik <rik@octave.org>
parents:
28631
diff
changeset
|
661 %!error bsxfun (f, a) |
2883b3d08b7e
maint: Remove unnecessary parentheses bracketing %!error BIST tests.
Rik <rik@octave.org>
parents:
28631
diff
changeset
|
662 %!error bsxfun (a, b) |
2883b3d08b7e
maint: Remove unnecessary parentheses bracketing %!error BIST tests.
Rik <rik@octave.org>
parents:
28631
diff
changeset
|
663 %!error bsxfun (a, b, c) |
2883b3d08b7e
maint: Remove unnecessary parentheses bracketing %!error BIST tests.
Rik <rik@octave.org>
parents:
28631
diff
changeset
|
664 %!error bsxfun (f, a, b, c) |
2883b3d08b7e
maint: Remove unnecessary parentheses bracketing %!error BIST tests.
Rik <rik@octave.org>
parents:
28631
diff
changeset
|
665 %!error bsxfun (f, ones (4, 0), ones (4, 4)) |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
666 %!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
|
667 %!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
|
668 %!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
|
669 %!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
|
670 %!assert (bsxfun ("minus", ones (1, 4), ones (4, 1)), zeros (4, 4)) |
6869 | 671 |
672 %!shared a, b, c, f | |
673 %! a = randn (4, 4); | |
674 %! a(end) *= 1i; | |
675 %! b = mean (a, 1); | |
676 %! c = mean (a, 2); | |
677 %! f = @minus; | |
28930
2883b3d08b7e
maint: Remove unnecessary parentheses bracketing %!error BIST tests.
Rik <rik@octave.org>
parents:
28631
diff
changeset
|
678 %!error bsxfun (f) |
2883b3d08b7e
maint: Remove unnecessary parentheses bracketing %!error BIST tests.
Rik <rik@octave.org>
parents:
28631
diff
changeset
|
679 %!error bsxfun (f, a) |
2883b3d08b7e
maint: Remove unnecessary parentheses bracketing %!error BIST tests.
Rik <rik@octave.org>
parents:
28631
diff
changeset
|
680 %!error bsxfun (a, b) |
2883b3d08b7e
maint: Remove unnecessary parentheses bracketing %!error BIST tests.
Rik <rik@octave.org>
parents:
28631
diff
changeset
|
681 %!error bsxfun (a, b, c) |
2883b3d08b7e
maint: Remove unnecessary parentheses bracketing %!error BIST tests.
Rik <rik@octave.org>
parents:
28631
diff
changeset
|
682 %!error bsxfun (f, a, b, c) |
2883b3d08b7e
maint: Remove unnecessary parentheses bracketing %!error BIST tests.
Rik <rik@octave.org>
parents:
28631
diff
changeset
|
683 %!error bsxfun (f, ones (4, 0), ones (4, 4)) |
14501
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 (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
|
685 %!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
|
686 %!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
|
687 %!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
|
688 %!assert (bsxfun ("minus", ones (1, 4), ones (4, 1)), zeros (4, 4)) |
6869 | 689 |
690 %!shared a, b, c, f | |
691 %! a = randn (4, 4); | |
692 %! b = a (1, :); | |
693 %! c = a (:, 1); | |
694 %! f = @(x, y) x == y; | |
28930
2883b3d08b7e
maint: Remove unnecessary parentheses bracketing %!error BIST tests.
Rik <rik@octave.org>
parents:
28631
diff
changeset
|
695 %!error bsxfun (f) |
2883b3d08b7e
maint: Remove unnecessary parentheses bracketing %!error BIST tests.
Rik <rik@octave.org>
parents:
28631
diff
changeset
|
696 %!error bsxfun (f, a) |
2883b3d08b7e
maint: Remove unnecessary parentheses bracketing %!error BIST tests.
Rik <rik@octave.org>
parents:
28631
diff
changeset
|
697 %!error bsxfun (a, b) |
2883b3d08b7e
maint: Remove unnecessary parentheses bracketing %!error BIST tests.
Rik <rik@octave.org>
parents:
28631
diff
changeset
|
698 %!error bsxfun (a, b, c) |
2883b3d08b7e
maint: Remove unnecessary parentheses bracketing %!error BIST tests.
Rik <rik@octave.org>
parents:
28631
diff
changeset
|
699 %!error bsxfun (f, a, b, c) |
2883b3d08b7e
maint: Remove unnecessary parentheses bracketing %!error BIST tests.
Rik <rik@octave.org>
parents:
28631
diff
changeset
|
700 %!error bsxfun (f, ones (4, 0), ones (4, 4)) |
14501
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, "logical")) |
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)), ones (4, 4, "logical")) |
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)) |
6869 | 705 |
706 %!shared a, b, c, d, f | |
707 %! a = randn (4, 4, 4); | |
708 %! b = mean (a, 1); | |
709 %! c = mean (a, 2); | |
710 %! d = mean (a, 3); | |
711 %! f = @minus; | |
28930
2883b3d08b7e
maint: Remove unnecessary parentheses bracketing %!error BIST tests.
Rik <rik@octave.org>
parents:
28631
diff
changeset
|
712 %!error bsxfun (f, ones ([4, 0, 4]), ones ([4, 4, 4])) |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
713 %!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
|
714 %!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
|
715 %!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
|
716 %!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
|
717 %!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
|
718 %!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
|
719 %!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
|
720 %!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
|
721 %!assert (bsxfun (f, a, d), a - repmat (d, [1, 1, 4])) |
30346
91c6288781ba
maint: Shorten some long lines in libinterp to <= 80 characters (bug #57599)
Rik <rik@octave.org>
parents:
30326
diff
changeset
|
722 %!assert (bsxfun ("minus", ones ([4, 0, 4]), ones ([4, 1, 4])), |
91c6288781ba
maint: Shorten some long lines in libinterp to <= 80 characters (bug #57599)
Rik <rik@octave.org>
parents:
30326
diff
changeset
|
723 %! zeros ([4, 0, 4])) |
6869 | 724 |
22737
7abc25e6206a
maint: Clean up code base to follow Octave coding conventions.
Rik <rik@octave.org>
parents:
22489
diff
changeset
|
725 ## The test below is a very hard case to treat |
30346
91c6288781ba
maint: Shorten some long lines in libinterp to <= 80 characters (bug #57599)
Rik <rik@octave.org>
parents:
30326
diff
changeset
|
726 %!assert (bsxfun (f, ones ([4, 1, 4, 1]), ones ([1, 4, 1, 4])), |
91c6288781ba
maint: Shorten some long lines in libinterp to <= 80 characters (bug #57599)
Rik <rik@octave.org>
parents:
30326
diff
changeset
|
727 %! zeros ([4, 4, 4, 4])) |
6869 | 728 |
10141 | 729 %!shared a, b, aa, bb |
25245
9b93b85459da
Set a known random seed so bsxfun BIST tests pass (bug #53636).
Rik <rik@octave.org>
parents:
25106
diff
changeset
|
730 %! ## FIXME: Set a known "good" random seed. See bug #51779. |
9b93b85459da
Set a known random seed so bsxfun BIST tests pass (bug #53636).
Rik <rik@octave.org>
parents:
25106
diff
changeset
|
731 %! old_nstate = randn ("state"); |
9b93b85459da
Set a known random seed so bsxfun BIST tests pass (bug #53636).
Rik <rik@octave.org>
parents:
25106
diff
changeset
|
732 %! restore_nstate = onCleanup (@() randn ("state", old_nstate)); |
9b93b85459da
Set a known random seed so bsxfun BIST tests pass (bug #53636).
Rik <rik@octave.org>
parents:
25106
diff
changeset
|
733 %! randn ("state", 42); # initialize generator to make behavior reproducible |
10141 | 734 %! a = randn (3, 1, 3); |
735 %! aa = a(:, ones (1, 3), :, ones (1, 3)); | |
736 %! b = randn (1, 3, 3, 3); | |
737 %! 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
|
738 %!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
|
739 %!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
|
740 %!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
|
741 %!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
|
742 %!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
|
743 %!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
|
744 %!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
|
745 %!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
|
746 %!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
|
747 %!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
|
748 %!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
|
749 %!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
|
750 %!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
|
751 %!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
|
752 %!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
|
753 %!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
|
754 %!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
|
755 |
22737
7abc25e6206a
maint: Clean up code base to follow Octave coding conventions.
Rik <rik@octave.org>
parents:
22489
diff
changeset
|
756 ## Test automatic bsxfun |
13013
5307bf69cd88
Add tests for automatic bsxfun
Jordi Gutiérrez Hermoso <jordigh@gmail.com>
parents:
12972
diff
changeset
|
757 % |
5307bf69cd88
Add tests for automatic bsxfun
Jordi Gutiérrez Hermoso <jordigh@gmail.com>
parents:
12972
diff
changeset
|
758 %!test |
30896
c9788d7f6e65
maint: Use "fcn" as preferred abbreviation for "function" in libinterp/.
Rik <rik@octave.org>
parents:
30888
diff
changeset
|
759 %! fcns = {@plus, @minus, @times, @rdivide, @ldivide, @power, @max, @min, ... |
17245
7babcdb9bc13
Use ... instead of \ for line continuation marker.
Stefan Mahr <dac922@gmx.de>
parents:
15195
diff
changeset
|
760 %! @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
|
761 %! @and, @or, @xor }; |
5307bf69cd88
Add tests for automatic bsxfun
Jordi Gutiérrez Hermoso <jordigh@gmail.com>
parents:
12972
diff
changeset
|
762 %! |
5307bf69cd88
Add tests for automatic bsxfun
Jordi Gutiérrez Hermoso <jordigh@gmail.com>
parents:
12972
diff
changeset
|
763 %! float_types = {@single, @double}; |
17245
7babcdb9bc13
Use ... instead of \ for line continuation marker.
Stefan Mahr <dac922@gmx.de>
parents:
15195
diff
changeset
|
764 %! 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
|
765 %! @uint8, @uint16, @uint32, @uint64}; |
13013
5307bf69cd88
Add tests for automatic bsxfun
Jordi Gutiérrez Hermoso <jordigh@gmail.com>
parents:
12972
diff
changeset
|
766 %! |
25245
9b93b85459da
Set a known random seed so bsxfun BIST tests pass (bug #53636).
Rik <rik@octave.org>
parents:
25106
diff
changeset
|
767 %! ## FIXME: Set a known "good" random seed. See bug #51779. |
9b93b85459da
Set a known random seed so bsxfun BIST tests pass (bug #53636).
Rik <rik@octave.org>
parents:
25106
diff
changeset
|
768 %! old_state = rand ("state"); |
9b93b85459da
Set a known random seed so bsxfun BIST tests pass (bug #53636).
Rik <rik@octave.org>
parents:
25106
diff
changeset
|
769 %! restore_state = onCleanup (@() rand ("state", old_state)); |
9b93b85459da
Set a known random seed so bsxfun BIST tests pass (bug #53636).
Rik <rik@octave.org>
parents:
25106
diff
changeset
|
770 %! rand ("state", 42); # initialize generator to make behavior reproducible |
9b93b85459da
Set a known random seed so bsxfun BIST tests pass (bug #53636).
Rik <rik@octave.org>
parents:
25106
diff
changeset
|
771 %! |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14138
diff
changeset
|
772 %! 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
|
773 %! y = rand (3,1) * 10-5; |
13013
5307bf69cd88
Add tests for automatic bsxfun
Jordi Gutiérrez Hermoso <jordigh@gmail.com>
parents:
12972
diff
changeset
|
774 %! |
30896
c9788d7f6e65
maint: Use "fcn" as preferred abbreviation for "function" in libinterp/.
Rik <rik@octave.org>
parents:
30888
diff
changeset
|
775 %! for i=1:length (fcns) |
14854
5ae9f0f77635
maint: Use Octave coding conventions for coddling parenthis is DLD-FUNCTIONS directory
Rik <octave@nomad.inbox5.com>
parents:
14846
diff
changeset
|
776 %! 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
|
777 %! for k = 1:length (int_types) |
13013
5307bf69cd88
Add tests for automatic bsxfun
Jordi Gutiérrez Hermoso <jordigh@gmail.com>
parents:
12972
diff
changeset
|
778 %! |
30896
c9788d7f6e65
maint: Use "fcn" as preferred abbreviation for "function" in libinterp/.
Rik <rik@octave.org>
parents:
30888
diff
changeset
|
779 %! fcn = fcns{i}; |
13013
5307bf69cd88
Add tests for automatic bsxfun
Jordi Gutiérrez Hermoso <jordigh@gmail.com>
parents:
12972
diff
changeset
|
780 %! f_type = float_types{j}; |
5307bf69cd88
Add tests for automatic bsxfun
Jordi Gutiérrez Hermoso <jordigh@gmail.com>
parents:
12972
diff
changeset
|
781 %! i_type = int_types{k}; |
5307bf69cd88
Add tests for automatic bsxfun
Jordi Gutiérrez Hermoso <jordigh@gmail.com>
parents:
12972
diff
changeset
|
782 %! |
30896
c9788d7f6e65
maint: Use "fcn" as preferred abbreviation for "function" in libinterp/.
Rik <rik@octave.org>
parents:
30888
diff
changeset
|
783 %! assert (bsxfun (fcn, f_type (x), i_type (y)), ... |
c9788d7f6e65
maint: Use "fcn" as preferred abbreviation for "function" in libinterp/.
Rik <rik@octave.org>
parents:
30888
diff
changeset
|
784 %! fcn (f_type(x), i_type (y))); |
c9788d7f6e65
maint: Use "fcn" as preferred abbreviation for "function" in libinterp/.
Rik <rik@octave.org>
parents:
30888
diff
changeset
|
785 %! assert (bsxfun (fcn, f_type (y), i_type (x)), ... |
c9788d7f6e65
maint: Use "fcn" as preferred abbreviation for "function" in libinterp/.
Rik <rik@octave.org>
parents:
30888
diff
changeset
|
786 %! fcn (f_type(y), i_type (x))); |
13013
5307bf69cd88
Add tests for automatic bsxfun
Jordi Gutiérrez Hermoso <jordigh@gmail.com>
parents:
12972
diff
changeset
|
787 %! |
30896
c9788d7f6e65
maint: Use "fcn" as preferred abbreviation for "function" in libinterp/.
Rik <rik@octave.org>
parents:
30888
diff
changeset
|
788 %! assert (bsxfun (fcn, i_type (x), i_type (y)), ... |
c9788d7f6e65
maint: Use "fcn" as preferred abbreviation for "function" in libinterp/.
Rik <rik@octave.org>
parents:
30888
diff
changeset
|
789 %! fcn (i_type (x), i_type (y))); |
c9788d7f6e65
maint: Use "fcn" as preferred abbreviation for "function" in libinterp/.
Rik <rik@octave.org>
parents:
30888
diff
changeset
|
790 %! assert (bsxfun (fcn, i_type (y), i_type (x)), ... |
c9788d7f6e65
maint: Use "fcn" as preferred abbreviation for "function" in libinterp/.
Rik <rik@octave.org>
parents:
30888
diff
changeset
|
791 %! fcn (i_type (y), i_type (x))); |
13013
5307bf69cd88
Add tests for automatic bsxfun
Jordi Gutiérrez Hermoso <jordigh@gmail.com>
parents:
12972
diff
changeset
|
792 %! |
30896
c9788d7f6e65
maint: Use "fcn" as preferred abbreviation for "function" in libinterp/.
Rik <rik@octave.org>
parents:
30888
diff
changeset
|
793 %! assert (bsxfun (fcn, f_type (x), f_type (y)), ... |
c9788d7f6e65
maint: Use "fcn" as preferred abbreviation for "function" in libinterp/.
Rik <rik@octave.org>
parents:
30888
diff
changeset
|
794 %! fcn (f_type (x), f_type (y))); |
c9788d7f6e65
maint: Use "fcn" as preferred abbreviation for "function" in libinterp/.
Rik <rik@octave.org>
parents:
30888
diff
changeset
|
795 %! assert (bsxfun (fcn, f_type(y), f_type(x)), ... |
c9788d7f6e65
maint: Use "fcn" as preferred abbreviation for "function" in libinterp/.
Rik <rik@octave.org>
parents:
30888
diff
changeset
|
796 %! fcn (f_type (y), f_type (x))); |
13013
5307bf69cd88
Add tests for automatic bsxfun
Jordi Gutiérrez Hermoso <jordigh@gmail.com>
parents:
12972
diff
changeset
|
797 %! endfor |
5307bf69cd88
Add tests for automatic bsxfun
Jordi Gutiérrez Hermoso <jordigh@gmail.com>
parents:
12972
diff
changeset
|
798 %! endfor |
5307bf69cd88
Add tests for automatic bsxfun
Jordi Gutiérrez Hermoso <jordigh@gmail.com>
parents:
12972
diff
changeset
|
799 %! endfor |
21345
12280fef2741
automatic broadcasting: correctly handle dimensions of length zero (bug #47085)
Carnë Draug <carandraug@octave.org>
parents:
21317
diff
changeset
|
800 |
22489
93ea313301f9
test: Add bug ids (<#####>) to BIST tests.
Rik <rik@octave.org>
parents:
22407
diff
changeset
|
801 ## Automatic broadcasting with zero length dimensions |
30326
cd7c824f3f22
eliminate use of .+ and .- operators in Octave sources
John W. Eaton <jwe@octave.org>
parents:
29961
diff
changeset
|
802 %!assert <*47085> ([1 2 3] + zeros (0, 3), zeros (0, 3)) |
cd7c824f3f22
eliminate use of .+ and .- operators in Octave sources
John W. Eaton <jwe@octave.org>
parents:
29961
diff
changeset
|
803 %!assert <*47085> (rand (3, 3, 1) + rand (3, 3, 0), zeros (3, 3, 0)) |
21345
12280fef2741
automatic broadcasting: correctly handle dimensions of length zero (bug #47085)
Carnë Draug <carandraug@octave.org>
parents:
21317
diff
changeset
|
804 |
22489
93ea313301f9
test: Add bug ids (<#####>) to BIST tests.
Rik <rik@octave.org>
parents:
22407
diff
changeset
|
805 ## In-place broadcasting with zero length dimensions |
23573
1b4f4ec53b4a
use new script to tag fixed bugs in tests
John W. Eaton <jwe@octave.org>
parents:
23572
diff
changeset
|
806 %!test <*47085> |
21345
12280fef2741
automatic broadcasting: correctly handle dimensions of length zero (bug #47085)
Carnë Draug <carandraug@octave.org>
parents:
21317
diff
changeset
|
807 %! a = zeros (0, 3); |
30326
cd7c824f3f22
eliminate use of .+ and .- operators in Octave sources
John W. Eaton <jwe@octave.org>
parents:
29961
diff
changeset
|
808 %! a += [1 2 3]; |
21580
ecce63c99c3f
maint: Add semicolons to terminate code in %! blocks.
Rik <rik@octave.org>
parents:
21372
diff
changeset
|
809 %! assert (a, zeros (0, 3)); |
21345
12280fef2741
automatic broadcasting: correctly handle dimensions of length zero (bug #47085)
Carnë Draug <carandraug@octave.org>
parents:
21317
diff
changeset
|
810 |
24947
bff4a7c7bc39
Fix bsxfun when operating with float complex values (bug #53179).
Rik <rik@octave.org>
parents:
24534
diff
changeset
|
811 %!test <*53179> |
bff4a7c7bc39
Fix bsxfun when operating with float complex values (bug #53179).
Rik <rik@octave.org>
parents:
24534
diff
changeset
|
812 %! im = ones (4,4,2) + single (i); |
bff4a7c7bc39
Fix bsxfun when operating with float complex values (bug #53179).
Rik <rik@octave.org>
parents:
24534
diff
changeset
|
813 %! mask = true (4,4); |
bff4a7c7bc39
Fix bsxfun when operating with float complex values (bug #53179).
Rik <rik@octave.org>
parents:
24534
diff
changeset
|
814 %! mask(:,1:2) = false; |
bff4a7c7bc39
Fix bsxfun when operating with float complex values (bug #53179).
Rik <rik@octave.org>
parents:
24534
diff
changeset
|
815 %! r = bsxfun (@times, im, mask); |
bff4a7c7bc39
Fix bsxfun when operating with float complex values (bug #53179).
Rik <rik@octave.org>
parents:
24534
diff
changeset
|
816 %! assert (r(:,:,1), repmat (single ([0, 0, 1+i, 1+i]), [4, 1])); |
bff4a7c7bc39
Fix bsxfun when operating with float complex values (bug #53179).
Rik <rik@octave.org>
parents:
24534
diff
changeset
|
817 |
30913
a4ed2fed7dfa
Add tests for automatic broadcasting with inplace times operator ".*=" (bug #38466).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30896
diff
changeset
|
818 ## automatic broadcasting with inplace times operator |
a4ed2fed7dfa
Add tests for automatic broadcasting with inplace times operator ".*=" (bug #38466).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30896
diff
changeset
|
819 %!test <*38466> |
a4ed2fed7dfa
Add tests for automatic broadcasting with inplace times operator ".*=" (bug #38466).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30896
diff
changeset
|
820 %! a = ones (2, 2, 2); |
a4ed2fed7dfa
Add tests for automatic broadcasting with inplace times operator ".*=" (bug #38466).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30896
diff
changeset
|
821 %! b = 2 * ones (2, 1); |
a4ed2fed7dfa
Add tests for automatic broadcasting with inplace times operator ".*=" (bug #38466).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30896
diff
changeset
|
822 %! a .*= b; |
a4ed2fed7dfa
Add tests for automatic broadcasting with inplace times operator ".*=" (bug #38466).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30896
diff
changeset
|
823 %! assert (a, 2 * ones (2, 2, 2)); |
a4ed2fed7dfa
Add tests for automatic broadcasting with inplace times operator ".*=" (bug #38466).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30896
diff
changeset
|
824 |
a4ed2fed7dfa
Add tests for automatic broadcasting with inplace times operator ".*=" (bug #38466).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30896
diff
changeset
|
825 %!test <*38466> |
a4ed2fed7dfa
Add tests for automatic broadcasting with inplace times operator ".*=" (bug #38466).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30896
diff
changeset
|
826 %! a = ones (2, 2, 2); |
a4ed2fed7dfa
Add tests for automatic broadcasting with inplace times operator ".*=" (bug #38466).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30896
diff
changeset
|
827 %! b = 2 * ones (1, 2); |
a4ed2fed7dfa
Add tests for automatic broadcasting with inplace times operator ".*=" (bug #38466).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30896
diff
changeset
|
828 %! a .*= b; |
a4ed2fed7dfa
Add tests for automatic broadcasting with inplace times operator ".*=" (bug #38466).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30896
diff
changeset
|
829 %! assert (a, 2 * ones (2, 2, 2)); |
a4ed2fed7dfa
Add tests for automatic broadcasting with inplace times operator ".*=" (bug #38466).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30896
diff
changeset
|
830 |
a4ed2fed7dfa
Add tests for automatic broadcasting with inplace times operator ".*=" (bug #38466).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30896
diff
changeset
|
831 %!test <*38466> |
a4ed2fed7dfa
Add tests for automatic broadcasting with inplace times operator ".*=" (bug #38466).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30896
diff
changeset
|
832 %! a = ones (2, 2, 2); |
a4ed2fed7dfa
Add tests for automatic broadcasting with inplace times operator ".*=" (bug #38466).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30896
diff
changeset
|
833 %! b = 2 * ones (2, 2); |
a4ed2fed7dfa
Add tests for automatic broadcasting with inplace times operator ".*=" (bug #38466).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30896
diff
changeset
|
834 %! a .*= b; |
a4ed2fed7dfa
Add tests for automatic broadcasting with inplace times operator ".*=" (bug #38466).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30896
diff
changeset
|
835 %! assert (a, 2 * ones (2, 2, 2)); |
a4ed2fed7dfa
Add tests for automatic broadcasting with inplace times operator ".*=" (bug #38466).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30896
diff
changeset
|
836 |
a4ed2fed7dfa
Add tests for automatic broadcasting with inplace times operator ".*=" (bug #38466).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30896
diff
changeset
|
837 %!test <*38466> |
a4ed2fed7dfa
Add tests for automatic broadcasting with inplace times operator ".*=" (bug #38466).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30896
diff
changeset
|
838 %! a = ones (2, 2, 2); |
a4ed2fed7dfa
Add tests for automatic broadcasting with inplace times operator ".*=" (bug #38466).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30896
diff
changeset
|
839 %! b = 2 * ones (1, 1, 2); |
a4ed2fed7dfa
Add tests for automatic broadcasting with inplace times operator ".*=" (bug #38466).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30896
diff
changeset
|
840 %! a .*= b; |
a4ed2fed7dfa
Add tests for automatic broadcasting with inplace times operator ".*=" (bug #38466).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30896
diff
changeset
|
841 %! assert (a, 2 * ones (2, 2, 2)); |
a4ed2fed7dfa
Add tests for automatic broadcasting with inplace times operator ".*=" (bug #38466).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30896
diff
changeset
|
842 |
a4ed2fed7dfa
Add tests for automatic broadcasting with inplace times operator ".*=" (bug #38466).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30896
diff
changeset
|
843 %!assert (ones (2,2,2) .* ones (1,2), ones (2,2,2)); |
a4ed2fed7dfa
Add tests for automatic broadcasting with inplace times operator ".*=" (bug #38466).
Markus Mützel <markus.muetzel@gmx.de>
parents:
30896
diff
changeset
|
844 |
6869 | 845 */ |
29958
32c3a5805893
move DEFUN and DEFMETHOD functions inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
29359
diff
changeset
|
846 |
32c3a5805893
move DEFUN and DEFMETHOD functions inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
29359
diff
changeset
|
847 OCTAVE_NAMESPACE_END |