Mercurial > octave
annotate src/ops.h @ 8366:8b1a2555c4e2
implement diagonal matrix objects
* * *
author | Jaroslav Hajek <highegg@gmail.com> |
---|---|
date | Wed, 03 Dec 2008 13:32:57 +0100 |
parents | 283989f2da9b |
children | 86088b49a6d7 |
rev | line source |
---|---|
2376 | 1 /* |
2 | |
7017 | 3 Copyright (C) 1996, 1997, 1998, 2003, 2004, 2005, 2006, 2007 |
4 John W. Eaton | |
2376 | 5 |
6 This file is part of Octave. | |
7 | |
8 Octave is free software; you can redistribute it and/or modify it | |
9 under the terms of the GNU General Public License as published by the | |
7016 | 10 Free Software Foundation; either version 3 of the License, or (at your |
11 option) any later version. | |
2376 | 12 |
13 Octave is distributed in the hope that it will be useful, but WITHOUT | |
14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
16 for more details. | |
17 | |
18 You should have received a copy of the GNU General Public License | |
7016 | 19 along with Octave; see the file COPYING. If not, see |
20 <http://www.gnu.org/licenses/>. | |
2376 | 21 |
22 */ | |
23 | |
24 #if !defined (octave_ops_h) | |
25 #define octave_ops_h 1 | |
26 | |
4669 | 27 #include "Array-util.h" |
28 | |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
29 // Concatenation macros that enforce argument prescan |
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
30 #define CONCAT2X(x,y) x ## y |
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
31 #define CONCAT2(x,y) CONCAT2X(x,y) |
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
32 |
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
33 #define CONCAT3X(x,y,z) x ## y ## z |
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
34 #define CONCAT3(x,y,z) CONCAT3X(x,y,z) |
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
35 |
2376 | 36 extern void install_ops (void); |
37 | |
3203 | 38 #define INSTALL_UNOP(op, t, f) \ |
39 octave_value_typeinfo::register_unary_op \ | |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
40 (octave_value::op, t::static_type_id (), CONCAT2(oct_unop_, f)); |
3203 | 41 |
42 #define INSTALL_NCUNOP(op, t, f) \ | |
43 octave_value_typeinfo::register_non_const_unary_op \ | |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
44 (octave_value::op, t::static_type_id (), CONCAT2(oct_unop_, f)); |
3203 | 45 |
2376 | 46 #define INSTALL_BINOP(op, t1, t2, f) \ |
47 octave_value_typeinfo::register_binary_op \ | |
3203 | 48 (octave_value::op, t1::static_type_id (), t2::static_type_id (), \ |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
49 CONCAT2(oct_binop_, f)); |
2376 | 50 |
4915 | 51 #define INSTALL_CATOP(t1, t2, f) \ |
52 octave_value_typeinfo::register_cat_op \ | |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
53 (t1::static_type_id (), t2::static_type_id (), CONCAT2(oct_catop_, f)); |
4915 | 54 |
2879 | 55 #define INSTALL_ASSIGNOP(op, t1, t2, f) \ |
2376 | 56 octave_value_typeinfo::register_assign_op \ |
3203 | 57 (octave_value::op, t1::static_type_id (), t2::static_type_id (), \ |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
58 CONCAT2(oct_assignop_, f)); |
2376 | 59 |
3195 | 60 #define INSTALL_ASSIGNANYOP(op, t1, f) \ |
61 octave_value_typeinfo::register_assignany_op \ | |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
62 (octave_value::op, t1::static_type_id (), CONCAT2(oct_assignop_, f)); |
3195 | 63 |
2376 | 64 #define INSTALL_ASSIGNCONV(t1, t2, tr) \ |
65 octave_value_typeinfo::register_pref_assign_conv \ | |
66 (t1::static_type_id (), t2::static_type_id (), tr::static_type_id ()); | |
67 | |
4901 | 68 #define INSTALL_CONVOP(t1, t2, f) \ |
69 octave_value_typeinfo::register_type_conv_op \ | |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
70 (t1::static_type_id (), t2::static_type_id (), CONCAT2(oct_conv_, f)); |
4901 | 71 |
2376 | 72 #define INSTALL_WIDENOP(t1, t2, f) \ |
73 octave_value_typeinfo::register_widening_op \ | |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
74 (t1::static_type_id (), t2::static_type_id (), CONCAT2(oct_conv_, f)); |
2376 | 75 |
76 #define BOOL_OP1(xt, xn, get_x, yt, yn, get_y) \ | |
77 xt xn = get_x; \ | |
78 yt yn = get_y; | |
79 | |
80 #define BOOL_OP2(x) \ | |
5275 | 81 octave_idx_type nr = x.rows (); \ |
82 octave_idx_type nc = x.columns (); | |
2376 | 83 |
84 #define BOOL_OP3(test) \ | |
2825 | 85 boolMatrix retval (nr, nc); \ |
5275 | 86 for (octave_idx_type j = 0; j < nc; j++) \ |
87 for (octave_idx_type i = 0; i < nr; i++) \ | |
2376 | 88 retval (i, j) = test; \ |
89 return retval; | |
90 | |
2601 | 91 #define SC_MX_BOOL_OP(st, sn, get_s, mt, mn, get_m, test, empty_result) \ |
2376 | 92 do \ |
93 { \ | |
94 BOOL_OP1 (st, sn, get_s, mt, mn, get_m) \ | |
95 BOOL_OP2 (mn) \ | |
2612 | 96 if (nr == 0 || nc == 0) \ |
2601 | 97 return empty_result; \ |
2376 | 98 BOOL_OP3 (test) \ |
99 } \ | |
100 while (0) | |
101 | |
2601 | 102 #define MX_SC_BOOL_OP(mt, mn, get_m, st, sn, get_s, test, empty_result) \ |
2376 | 103 do \ |
104 { \ | |
105 BOOL_OP1 (mt, mn, get_m, st, sn, get_s) \ | |
106 BOOL_OP2 (mn) \ | |
2612 | 107 if (nr == 0 || nc == 0) \ |
2601 | 108 return empty_result; \ |
2376 | 109 BOOL_OP3 (test) \ |
110 } \ | |
111 while (0) | |
112 | |
113 #define MX_MX_BOOL_OP(m1t, m1n, get_m1, m2t, m2n, get_m2, test, op, \ | |
2613 | 114 one_empty_result, two_empty_result) \ |
2376 | 115 do \ |
116 { \ | |
117 BOOL_OP1 (m1t, m1n, get_m1, m2t, m2n, get_m2) \ | |
5275 | 118 octave_idx_type m1_nr = m1n.rows (); \ |
119 octave_idx_type m1_nc = m1n.cols (); \ | |
120 octave_idx_type m2_nr = m2n.rows (); \ | |
121 octave_idx_type m2_nc = m2n.cols (); \ | |
2613 | 122 if (m1_nr == m2_nr && m1_nc == m2_nc) \ |
2376 | 123 { \ |
2613 | 124 if (m1_nr == 0 && m1_nc == 0) \ |
125 return two_empty_result; \ | |
126 else \ | |
127 { \ | |
128 BOOL_OP2 (m1n) \ | |
129 BOOL_OP3 (test) \ | |
130 } \ | |
2376 | 131 } \ |
2613 | 132 else \ |
133 { \ | |
134 if ((m1_nr == 0 && m1_nc == 0) || (m2_nr == 0 && m2_nc == 0)) \ | |
135 return one_empty_result; \ | |
136 else \ | |
137 { \ | |
138 gripe_nonconformant ("operator " op, m1_nr, m1_nc, \ | |
139 m2_nr, m2_nc); \ | |
2825 | 140 return boolMatrix (); \ |
2613 | 141 } \ |
142 } \ | |
2376 | 143 } \ |
144 while (0) | |
145 | |
3203 | 146 #define CAST_UNOP_ARG(t) \ |
5760 | 147 t v = dynamic_cast<t> (a) |
3203 | 148 |
2376 | 149 #define CAST_BINOP_ARGS(t1, t2) \ |
5760 | 150 t1 v1 = dynamic_cast<t1> (a1); \ |
151 t2 v2 = dynamic_cast<t2> (a2) | |
2376 | 152 |
153 #define CAST_CONV_ARG(t) \ | |
5760 | 154 t v = dynamic_cast<t> (a) |
2376 | 155 |
2914 | 156 #define ASSIGNOPDECL(name) \ |
157 static octave_value \ | |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
158 CONCAT2(oct_assignop_, name) (octave_base_value& a1, \ |
5759 | 159 const octave_value_list& idx, \ |
160 const octave_base_value& a2) | |
161 | |
8150
283989f2da9b
make null assignment matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
7997
diff
changeset
|
162 #define NULLASSIGNOPDECL(name) \ |
283989f2da9b
make null assignment matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
7997
diff
changeset
|
163 static octave_value \ |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
164 CONCAT2(oct_assignop_, name) (octave_base_value& a, \ |
8150
283989f2da9b
make null assignment matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
7997
diff
changeset
|
165 const octave_value_list& idx, \ |
283989f2da9b
make null assignment matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
7997
diff
changeset
|
166 const octave_base_value&) |
283989f2da9b
make null assignment matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
7997
diff
changeset
|
167 |
5759 | 168 #define ASSIGNANYOPDECL(name) \ |
169 static octave_value \ | |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
170 CONCAT2(oct_assignop_, name) (octave_base_value& a1, \ |
3203 | 171 const octave_value_list& idx, \ |
172 const octave_value& a2) | |
2914 | 173 |
174 #define DEFASSIGNOP(name, t1, t2) \ | |
175 ASSIGNOPDECL (name) | |
176 | |
177 #define DEFASSIGNOP_FN(name, t1, t2, f) \ | |
178 ASSIGNOPDECL (name) \ | |
179 { \ | |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
180 CAST_BINOP_ARGS (CONCAT2(octave_, t1)&, const CONCAT2(octave_, t2)&); \ |
2914 | 181 \ |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
182 v1.f (idx, v2.CONCAT2(t1, _value) ()); \ |
2914 | 183 return octave_value (); \ |
184 } | |
185 | |
8150
283989f2da9b
make null assignment matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
7997
diff
changeset
|
186 #define DEFNULLASSIGNOP_FN(name, t, f) \ |
283989f2da9b
make null assignment matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
7997
diff
changeset
|
187 NULLASSIGNOPDECL (name) \ |
283989f2da9b
make null assignment matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
7997
diff
changeset
|
188 { \ |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
189 CAST_UNOP_ARG (CONCAT2(octave_, t)&); \ |
8150
283989f2da9b
make null assignment matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
7997
diff
changeset
|
190 \ |
283989f2da9b
make null assignment matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
7997
diff
changeset
|
191 v.f (idx); \ |
283989f2da9b
make null assignment matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
7997
diff
changeset
|
192 return octave_value (); \ |
283989f2da9b
make null assignment matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
7997
diff
changeset
|
193 } |
283989f2da9b
make null assignment matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
7997
diff
changeset
|
194 |
4686 | 195 #define DEFNDASSIGNOP_FN(name, t1, t2, e, f) \ |
196 ASSIGNOPDECL (name) \ | |
197 { \ | |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
198 CAST_BINOP_ARGS (CONCAT2(octave_, t1)&, const CONCAT2(octave_, t2)&); \ |
4686 | 199 \ |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
200 v1.f (idx, v2.CONCAT2(e, _value) ()); \ |
4686 | 201 return octave_value (); \ |
202 } | |
203 | |
3195 | 204 #define DEFASSIGNANYOP_FN(name, t1, f) \ |
5759 | 205 ASSIGNANYOPDECL (name) \ |
3195 | 206 { \ |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
207 CONCAT2(octave_, t1)& v1 = dynamic_cast<CONCAT2(octave_, t1)&> (a1); \ |
3195 | 208 \ |
209 v1.f (idx, a2); \ | |
210 return octave_value (); \ | |
211 } | |
212 | |
2914 | 213 #define CONVDECL(name) \ |
5759 | 214 static octave_base_value * \ |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
215 CONCAT2(oct_conv_, name) (const octave_base_value& a) |
3203 | 216 |
217 #define CONVDECLX(name) \ | |
5759 | 218 static octave_base_value * \ |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
219 CONCAT2(oct_conv_, name) (const octave_base_value&) |
2914 | 220 |
4901 | 221 #define DEFCONV(name, a_dummy, b_dummy) \ |
2914 | 222 CONVDECL (name) |
223 | |
4901 | 224 #define DEFCONVFNX(name, tfrom, ovtto, tto, e) \ |
225 CONVDECL (name) \ | |
226 { \ | |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
227 CAST_CONV_ARG (const CONCAT2(octave_, tfrom)&); \ |
4901 | 228 \ |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
229 return new CONCAT2(octave_, ovtto) (CONCAT2(tto, NDArray) (v.CONCAT2(e, array_value) ())); \ |
4901 | 230 } |
231 | |
7997
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7922
diff
changeset
|
232 #define DEFCONVFNX2(name, tfrom, ovtto, e) \ |
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7922
diff
changeset
|
233 CONVDECL (name) \ |
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7922
diff
changeset
|
234 { \ |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
235 CAST_CONV_ARG (const CONCAT2(octave_, tfrom)&); \ |
7997
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7922
diff
changeset
|
236 \ |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
237 return new CONCAT2(octave_, ovtto) (v.CONCAT2(e, array_value) ()); \ |
7997
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7922
diff
changeset
|
238 } |
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7922
diff
changeset
|
239 |
4901 | 240 #define DEFDBLCONVFN(name, ovtfrom, e) \ |
241 CONVDECL (name) \ | |
242 { \ | |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
243 CAST_CONV_ARG (const CONCAT2(octave_, ovtfrom)&); \ |
4901 | 244 \ |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
245 return new octave_matrix (NDArray (v.CONCAT2(e, _value) ())); \ |
4901 | 246 } |
247 | |
5032 | 248 #define DEFSTRINTCONVFN(name, tto) \ |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
249 DEFCONVFNX(name, char_matrix_str, CONCAT2(tto, _matrix), tto, char_) |
5032 | 250 |
5992 | 251 #define DEFSTRDBLCONVFN(name, tfrom) \ |
252 DEFCONVFNX(name, tfrom, matrix, , char_) | |
5032 | 253 |
4901 | 254 #define DEFCONVFN(name, tfrom, tto) \ |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
255 DEFCONVFNX2 (name, tfrom, CONCAT2(tto, _matrix), CONCAT2(tto, _)) |
4901 | 256 |
257 #define DEFCONVFN2(name, tfrom, sm, tto) \ | |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
258 DEFCONVFNX2 (name, CONCAT3(tfrom, _, sm), CONCAT2(tto, _matrix), CONCAT2(tto, _)) |
4901 | 259 |
3203 | 260 #define UNOPDECL(name, a) \ |
261 static octave_value \ | |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
262 CONCAT2(oct_unop_, name) (const octave_base_value& a) |
3203 | 263 |
264 #define DEFUNOPX(name, t) \ | |
265 UNOPDECL (name, , ) | |
266 | |
267 #define DEFUNOP(name, t) \ | |
268 UNOPDECL (name, a) | |
269 | |
270 #define DEFUNOP_OP(name, t, op) \ | |
271 UNOPDECL (name, a) \ | |
272 { \ | |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
273 CAST_UNOP_ARG (const CONCAT2(octave_, t)&); \ |
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
274 return octave_value (op v.CONCAT2(t, _value) ()); \ |
3203 | 275 } |
276 | |
4550 | 277 #define DEFNDUNOP_OP(name, t, e, op) \ |
4543 | 278 UNOPDECL (name, a) \ |
279 { \ | |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
280 CAST_UNOP_ARG (const CONCAT2(octave_, t)&); \ |
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
281 return octave_value (op v.CONCAT2(e, _value) ()); \ |
4543 | 282 } |
283 | |
5775 | 284 // FIXME -- in some cases, the constructor isn't necessary. |
3203 | 285 |
286 #define DEFUNOP_FN(name, t, f) \ | |
287 UNOPDECL (name, a) \ | |
288 { \ | |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
289 CAST_UNOP_ARG (const CONCAT2(octave_, t)&); \ |
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
290 return octave_value (f (v.CONCAT2(t, _value) ())); \ |
3203 | 291 } |
292 | |
4550 | 293 #define DEFNDUNOP_FN(name, t, e, f) \ |
4543 | 294 UNOPDECL (name, a) \ |
295 { \ | |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
296 CAST_UNOP_ARG (const CONCAT2(octave_, t)&); \ |
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
297 return octave_value (f (v.CONCAT2(e, _value) ())); \ |
4543 | 298 } |
299 | |
3203 | 300 #define DEFNCUNOP_METHOD(name, t, method) \ |
301 static void \ | |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
302 CONCAT2(oct_unop_, name) (octave_base_value& a) \ |
3203 | 303 { \ |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
304 CAST_UNOP_ARG (CONCAT2(octave_, t)&); \ |
3203 | 305 v.method (); \ |
306 } | |
307 | |
2914 | 308 #define BINOPDECL(name, a1, a2) \ |
309 static octave_value \ | |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
310 CONCAT2(oct_binop_, name) (const octave_base_value& a1, const octave_base_value& a2) |
2914 | 311 |
312 #define DEFBINOPX(name, t1, t2) \ | |
313 BINOPDECL (name, , ) | |
314 | |
315 #define DEFBINOP(name, t1, t2) \ | |
316 BINOPDECL (name, a1, a2) | |
317 | |
318 #define DEFBINOP_OP(name, t1, t2, op) \ | |
319 BINOPDECL (name, a1, a2) \ | |
320 { \ | |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
321 CAST_BINOP_ARGS (const CONCAT2(octave_, t1)&, const CONCAT2(octave_, t2)&); \ |
2914 | 322 return octave_value \ |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
323 (v1.CONCAT2(t1, _value) () op v2.CONCAT2(t2, _value) ()); \ |
2914 | 324 } |
325 | |
7922
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7017
diff
changeset
|
326 #define DEFSCALARBOOLOP_OP(name, t1, t2, op) \ |
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7017
diff
changeset
|
327 BINOPDECL (name, a1, a2) \ |
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7017
diff
changeset
|
328 { \ |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
329 CAST_BINOP_ARGS (const CONCAT2(octave_, t1)&, const CONCAT2(octave_, t2)&); \ |
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
330 if (xisnan (v1.CONCAT2(t1, _value) ()) || xisnan (v2.CONCAT2(t2, _value) ())) \ |
7922
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7017
diff
changeset
|
331 { \ |
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7017
diff
changeset
|
332 error ("invalid conversion from NaN to logical"); \ |
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7017
diff
changeset
|
333 return octave_value (); \ |
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7017
diff
changeset
|
334 } \ |
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7017
diff
changeset
|
335 else \ |
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7017
diff
changeset
|
336 return octave_value \ |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
337 (v1.CONCAT2(t1, _value) () op v2.CONCAT2(t2, _value) ()); \ |
7922
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7017
diff
changeset
|
338 } |
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7017
diff
changeset
|
339 |
4543 | 340 #define DEFNDBINOP_OP(name, t1, t2, e1, e2, op) \ |
341 BINOPDECL (name, a1, a2) \ | |
342 { \ | |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
343 CAST_BINOP_ARGS (const CONCAT2(octave_, t1)&, const CONCAT2(octave_, t2)&); \ |
4543 | 344 return octave_value \ |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
345 (v1.CONCAT2(e1, _value) () op v2.CONCAT2(e2, _value) ()); \ |
4543 | 346 } |
347 | |
5775 | 348 // FIXME -- in some cases, the constructor isn't necessary. |
2914 | 349 |
350 #define DEFBINOP_FN(name, t1, t2, f) \ | |
351 BINOPDECL (name, a1, a2) \ | |
352 { \ | |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
353 CAST_BINOP_ARGS (const CONCAT2(octave_, t1)&, const CONCAT2(octave_, t2)&); \ |
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
354 return octave_value (f (v1.CONCAT2(t1, _value) (), v2.CONCAT2(t2, _value) ())); \ |
2914 | 355 } |
356 | |
4543 | 357 #define DEFNDBINOP_FN(name, t1, t2, e1, e2, f) \ |
358 BINOPDECL (name, a1, a2) \ | |
359 { \ | |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
360 CAST_BINOP_ARGS (const CONCAT2(octave_, t1)&, const CONCAT2(octave_, t2)&); \ |
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
361 return octave_value (f (v1.CONCAT2(e1, _value) (), v2.CONCAT2(e2, _value) ())); \ |
4543 | 362 } |
363 | |
2914 | 364 #define BINOP_NONCONFORMANT(msg) \ |
365 gripe_nonconformant (msg, \ | |
366 a1.rows (), a1.columns (), \ | |
367 a2.rows (), a2.columns ()); \ | |
368 return octave_value () | |
369 | |
4915 | 370 #define CATOPDECL(name, a1, a2) \ |
371 static octave_value \ | |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
372 CONCAT2(oct_catop_, name) (octave_base_value& a1, const octave_base_value& a2, \ |
6871 | 373 const Array<octave_idx_type>& ra_idx) |
4915 | 374 |
375 #define DEFCATOPX(name, t1, t2) \ | |
376 CATOPDECL (name, , ) | |
377 | |
378 #define DEFCATOP(name, t1, t2) \ | |
379 CATOPDECL (name, a1, a2) | |
380 | |
5775 | 381 // FIXME -- in some cases, the constructor isn't necessary. |
4915 | 382 |
383 #define DEFCATOP_FN(name, t1, t2, f) \ | |
5075 | 384 CATOPDECL (name, a1, a2) \ |
4915 | 385 { \ |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
386 CAST_BINOP_ARGS (CONCAT2(octave_, t1)&, const CONCAT2(octave_, t2)&); \ |
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
387 return octave_value (v1.CONCAT2(t1, _value) () . f (v2.CONCAT2(t2, _value) (), ra_idx)); \ |
4915 | 388 } |
389 | |
5075 | 390 #define DEFNDCATOP_FN(name, t1, t2, e1, e2, f) \ |
391 CATOPDECL (name, a1, a2) \ | |
4915 | 392 { \ |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
393 CAST_BINOP_ARGS (CONCAT2(octave_, t1)&, const CONCAT2(octave_, t2)&); \ |
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
394 return octave_value (v1.CONCAT2(e1, _value) () . f (v2.CONCAT2(e2, _value) (), ra_idx)); \ |
5533 | 395 } |
396 | |
397 #define DEFNDCHARCATOP_FN(name, t1, t2, f) \ | |
398 CATOPDECL (name, a1, a2) \ | |
399 { \ | |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
400 CAST_BINOP_ARGS (CONCAT2(octave_, t1)&, const CONCAT2(octave_, t2)&); \ |
5533 | 401 \ |
402 return octave_value (v1.char_array_value () . f (v2.char_array_value (), ra_idx), \ | |
403 true, ((a1.is_sq_string () || a2.is_sq_string ()) \ | |
404 ? '\'' : '"')); \ | |
4915 | 405 } |
406 | |
5075 | 407 // For compatibility, the second arg is always converted to the type |
408 // of the first. Hmm. | |
409 | |
410 #define DEFNDCATOP_FN2(name, t1, t2, tc1, tc2, e1, e2, f) \ | |
411 CATOPDECL (name, a1, a2) \ | |
412 { \ | |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
413 CAST_BINOP_ARGS (CONCAT2(octave_, t1)&, const CONCAT2(octave_, t2)&); \ |
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
414 return octave_value (tc1 (v1.CONCAT2(e1, _value) ()) . f (tc2 (v2.CONCAT2(e2, _value) ()), ra_idx)); \ |
5075 | 415 } |
416 | |
4915 | 417 #define CATOP_NONCONFORMANT(msg) \ |
418 gripe_nonconformant (msg, \ | |
419 a1.rows (), a1.columns (), \ | |
420 a2.rows (), a2.columns ()); \ | |
421 return octave_value () | |
422 | |
2376 | 423 #endif |
424 | |
425 /* | |
426 ;;; Local Variables: *** | |
427 ;;; mode: C++ *** | |
428 ;;; End: *** | |
429 */ |