Mercurial > hg > octave-nkf
annotate src/ops.h @ 8870:eea0e1b45ec0
optimize string manipulation in lookfor
author | Jaroslav Hajek <highegg@gmail.com> |
---|---|
date | Wed, 25 Feb 2009 10:21:33 +0100 |
parents | 86088b49a6d7 |
children | eb63fbe60fab |
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 | |
8852 | 248 #define DEFFLTCONVFN(name, ovtfrom, e) \ |
249 CONVDECL (name) \ | |
250 { \ | |
251 CAST_CONV_ARG (const CONCAT2(octave_, ovtfrom)&); \ | |
252 \ | |
253 return new octave_float_matrix (FloatNDArray (v.CONCAT2(e, _value) ())); \ | |
254 } | |
255 | |
5032 | 256 #define DEFSTRINTCONVFN(name, tto) \ |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
257 DEFCONVFNX(name, char_matrix_str, CONCAT2(tto, _matrix), tto, char_) |
5032 | 258 |
5992 | 259 #define DEFSTRDBLCONVFN(name, tfrom) \ |
260 DEFCONVFNX(name, tfrom, matrix, , char_) | |
5032 | 261 |
8852 | 262 #define DEFSTRFLTCONVFN(name, tfrom) \ |
263 DEFCONVFNX(name, tfrom, float_matrix, Float, char_) | |
264 | |
4901 | 265 #define DEFCONVFN(name, tfrom, tto) \ |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
266 DEFCONVFNX2 (name, tfrom, CONCAT2(tto, _matrix), CONCAT2(tto, _)) |
4901 | 267 |
268 #define DEFCONVFN2(name, tfrom, sm, tto) \ | |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
269 DEFCONVFNX2 (name, CONCAT3(tfrom, _, sm), CONCAT2(tto, _matrix), CONCAT2(tto, _)) |
4901 | 270 |
3203 | 271 #define UNOPDECL(name, a) \ |
272 static octave_value \ | |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
273 CONCAT2(oct_unop_, name) (const octave_base_value& a) |
3203 | 274 |
275 #define DEFUNOPX(name, t) \ | |
276 UNOPDECL (name, , ) | |
277 | |
278 #define DEFUNOP(name, t) \ | |
279 UNOPDECL (name, a) | |
280 | |
281 #define DEFUNOP_OP(name, t, op) \ | |
282 UNOPDECL (name, a) \ | |
283 { \ | |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
284 CAST_UNOP_ARG (const CONCAT2(octave_, t)&); \ |
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
285 return octave_value (op v.CONCAT2(t, _value) ()); \ |
3203 | 286 } |
287 | |
4550 | 288 #define DEFNDUNOP_OP(name, t, e, op) \ |
4543 | 289 UNOPDECL (name, a) \ |
290 { \ | |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
291 CAST_UNOP_ARG (const CONCAT2(octave_, t)&); \ |
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
292 return octave_value (op v.CONCAT2(e, _value) ()); \ |
4543 | 293 } |
294 | |
5775 | 295 // FIXME -- in some cases, the constructor isn't necessary. |
3203 | 296 |
297 #define DEFUNOP_FN(name, t, f) \ | |
298 UNOPDECL (name, a) \ | |
299 { \ | |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
300 CAST_UNOP_ARG (const CONCAT2(octave_, t)&); \ |
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
301 return octave_value (f (v.CONCAT2(t, _value) ())); \ |
3203 | 302 } |
303 | |
4550 | 304 #define DEFNDUNOP_FN(name, t, e, f) \ |
4543 | 305 UNOPDECL (name, a) \ |
306 { \ | |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
307 CAST_UNOP_ARG (const CONCAT2(octave_, t)&); \ |
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
308 return octave_value (f (v.CONCAT2(e, _value) ())); \ |
4543 | 309 } |
310 | |
3203 | 311 #define DEFNCUNOP_METHOD(name, t, method) \ |
312 static void \ | |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
313 CONCAT2(oct_unop_, name) (octave_base_value& a) \ |
3203 | 314 { \ |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
315 CAST_UNOP_ARG (CONCAT2(octave_, t)&); \ |
3203 | 316 v.method (); \ |
317 } | |
318 | |
2914 | 319 #define BINOPDECL(name, a1, a2) \ |
320 static octave_value \ | |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
321 CONCAT2(oct_binop_, name) (const octave_base_value& a1, const octave_base_value& a2) |
2914 | 322 |
323 #define DEFBINOPX(name, t1, t2) \ | |
324 BINOPDECL (name, , ) | |
325 | |
326 #define DEFBINOP(name, t1, t2) \ | |
327 BINOPDECL (name, a1, a2) | |
328 | |
329 #define DEFBINOP_OP(name, t1, t2, op) \ | |
330 BINOPDECL (name, a1, a2) \ | |
331 { \ | |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
332 CAST_BINOP_ARGS (const CONCAT2(octave_, t1)&, const CONCAT2(octave_, t2)&); \ |
2914 | 333 return octave_value \ |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
334 (v1.CONCAT2(t1, _value) () op v2.CONCAT2(t2, _value) ()); \ |
2914 | 335 } |
336 | |
7922
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7017
diff
changeset
|
337 #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
|
338 BINOPDECL (name, a1, a2) \ |
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7017
diff
changeset
|
339 { \ |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
340 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
|
341 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
|
342 { \ |
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7017
diff
changeset
|
343 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
|
344 return octave_value (); \ |
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7017
diff
changeset
|
345 } \ |
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7017
diff
changeset
|
346 else \ |
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7017
diff
changeset
|
347 return octave_value \ |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
348 (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
|
349 } |
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7017
diff
changeset
|
350 |
4543 | 351 #define DEFNDBINOP_OP(name, t1, t2, e1, e2, op) \ |
352 BINOPDECL (name, a1, a2) \ | |
353 { \ | |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
354 CAST_BINOP_ARGS (const CONCAT2(octave_, t1)&, const CONCAT2(octave_, t2)&); \ |
4543 | 355 return octave_value \ |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
356 (v1.CONCAT2(e1, _value) () op v2.CONCAT2(e2, _value) ()); \ |
4543 | 357 } |
358 | |
5775 | 359 // FIXME -- in some cases, the constructor isn't necessary. |
2914 | 360 |
361 #define DEFBINOP_FN(name, t1, t2, f) \ | |
362 BINOPDECL (name, a1, a2) \ | |
363 { \ | |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
364 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
|
365 return octave_value (f (v1.CONCAT2(t1, _value) (), v2.CONCAT2(t2, _value) ())); \ |
2914 | 366 } |
367 | |
4543 | 368 #define DEFNDBINOP_FN(name, t1, t2, e1, e2, f) \ |
369 BINOPDECL (name, a1, a2) \ | |
370 { \ | |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
371 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
|
372 return octave_value (f (v1.CONCAT2(e1, _value) (), v2.CONCAT2(e2, _value) ())); \ |
4543 | 373 } |
374 | |
2914 | 375 #define BINOP_NONCONFORMANT(msg) \ |
376 gripe_nonconformant (msg, \ | |
377 a1.rows (), a1.columns (), \ | |
378 a2.rows (), a2.columns ()); \ | |
379 return octave_value () | |
380 | |
4915 | 381 #define CATOPDECL(name, a1, a2) \ |
382 static octave_value \ | |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
383 CONCAT2(oct_catop_, name) (octave_base_value& a1, const octave_base_value& a2, \ |
6871 | 384 const Array<octave_idx_type>& ra_idx) |
4915 | 385 |
386 #define DEFCATOPX(name, t1, t2) \ | |
387 CATOPDECL (name, , ) | |
388 | |
389 #define DEFCATOP(name, t1, t2) \ | |
390 CATOPDECL (name, a1, a2) | |
391 | |
5775 | 392 // FIXME -- in some cases, the constructor isn't necessary. |
4915 | 393 |
394 #define DEFCATOP_FN(name, t1, t2, f) \ | |
5075 | 395 CATOPDECL (name, a1, a2) \ |
4915 | 396 { \ |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
397 CAST_BINOP_ARGS (CONCAT2(octave_, t1)&, const CONCAT2(octave_, t2)&); \ |
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
398 return octave_value (v1.CONCAT2(t1, _value) () . f (v2.CONCAT2(t2, _value) (), ra_idx)); \ |
4915 | 399 } |
400 | |
5075 | 401 #define DEFNDCATOP_FN(name, t1, t2, e1, e2, f) \ |
402 CATOPDECL (name, a1, a2) \ | |
4915 | 403 { \ |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
404 CAST_BINOP_ARGS (CONCAT2(octave_, t1)&, const CONCAT2(octave_, t2)&); \ |
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
405 return octave_value (v1.CONCAT2(e1, _value) () . f (v2.CONCAT2(e2, _value) (), ra_idx)); \ |
5533 | 406 } |
407 | |
408 #define DEFNDCHARCATOP_FN(name, t1, t2, f) \ | |
409 CATOPDECL (name, a1, a2) \ | |
410 { \ | |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
411 CAST_BINOP_ARGS (CONCAT2(octave_, t1)&, const CONCAT2(octave_, t2)&); \ |
5533 | 412 \ |
413 return octave_value (v1.char_array_value () . f (v2.char_array_value (), ra_idx), \ | |
414 true, ((a1.is_sq_string () || a2.is_sq_string ()) \ | |
415 ? '\'' : '"')); \ | |
4915 | 416 } |
417 | |
5075 | 418 // For compatibility, the second arg is always converted to the type |
419 // of the first. Hmm. | |
420 | |
421 #define DEFNDCATOP_FN2(name, t1, t2, tc1, tc2, e1, e2, f) \ | |
422 CATOPDECL (name, a1, a2) \ | |
423 { \ | |
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
424 CAST_BINOP_ARGS (CONCAT2(octave_, t1)&, const CONCAT2(octave_, t2)&); \ |
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
425 return octave_value (tc1 (v1.CONCAT2(e1, _value) ()) . f (tc2 (v2.CONCAT2(e2, _value) ()), ra_idx)); \ |
5075 | 426 } |
427 | |
4915 | 428 #define CATOP_NONCONFORMANT(msg) \ |
429 gripe_nonconformant (msg, \ | |
430 a1.rows (), a1.columns (), \ | |
431 a2.rows (), a2.columns ()); \ | |
432 return octave_value () | |
433 | |
2376 | 434 #endif |
435 | |
436 /* | |
437 ;;; Local Variables: *** | |
438 ;;; mode: C++ *** | |
439 ;;; End: *** | |
440 */ |