Mercurial > octave

comparison libinterp/operators/ops.h @ 22197:e43d83253e28

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
refill multi-line macro definitions Use the Emacs C++ mode style for line continuation markers in multi-line macro definitions. * make_int.cc, __dsearchn__.cc, __magick_read__.cc, besselj.cc, bitfcns.cc, bsxfun.cc, cellfun.cc, data.cc, defun-dld.h, defun-int.h, defun.h, det.cc, error.h, find.cc, gcd.cc, graphics.cc, interpreter.h, jit-ir.h, jit-typeinfo.h, lookup.cc, ls-mat5.cc, max.cc, mexproto.h, mxarray.in.h, oct-stream.cc, ordschur.cc, pr-output.cc, profiler.h, psi.cc, regexp.cc, sparse-xdiv.cc, sparse-xpow.cc, tril.cc, txt-eng.h, utils.cc, variables.cc, variables.h, xdiv.cc, xpow.cc, __glpk__.cc, ov-base.cc, ov-base.h, ov-cell.cc, ov-ch-mat.cc, ov-classdef.cc, ov-complex.cc, ov-cx-mat.cc, ov-cx-sparse.cc, ov-float.cc, ov-float.h, ov-flt-complex.cc, ov-flt-cx-mat.cc, ov-flt-re-mat.cc, ov-int-traits.h, ov-lazy-idx.h, ov-perm.cc, ov-re-mat.cc, ov-re-sparse.cc, ov-scalar.cc, ov-scalar.h, ov-str-mat.cc, ov-type-conv.h, ov.cc, ov.h, op-class.cc, op-int-conv.cc, op-int.h, op-str-str.cc, ops.h, lex.ll, Array.cc, CMatrix.cc, CSparse.cc, MArray.cc, MArray.h, MDiagArray2.cc, MDiagArray2.h, MSparse.h, Sparse.cc, dMatrix.cc, dSparse.cc, fCMatrix.cc, fMatrix.cc, idx-vector.cc, f77-fcn.h, quit.h, bsxfun-decl.h, bsxfun-defs.cc, lo-specfun.cc, oct-convn.cc, oct-convn.h, oct-norm.cc, oct-norm.h, oct-rand.cc, Sparse-op-decls.h, Sparse-op-defs.h, mx-inlines.cc, mx-op-decl.h, mx-op-defs.h, mach-info.cc, oct-group.cc, oct-passwd.cc, oct-syscalls.cc, oct-time.cc, data-conv.cc, kpse.cc, lo-ieee.h, lo-macros.h, oct-cmplx.h, oct-glob.cc, oct-inttypes.cc, oct-inttypes.h, oct-locbuf.h, oct-sparse.h, url-transfer.cc, oct-conf-post.in.h, shared-fcns.h: Refill macro definitions.
author John W. Eaton <jwe@octave.org>
date Mon, 01 Aug 2016 12:40:18 -0400
parents 2aef506f3fec
children 8b18f46f6427
comparison
equal deleted inserted replaced
22196:dd992fd74fce 22197:e43d83253e28
35 #define CONCAT3X(x, y, z) x ## y ## z 35 #define CONCAT3X(x, y, z) x ## y ## z
36 #define CONCAT3(x, y, z) CONCAT3X (x, y, z) 36 #define CONCAT3(x, y, z) CONCAT3X (x, y, z)
37 37
38 extern void install_ops (void); 38 extern void install_ops (void);
39 39
40 #define INSTALL_UNOP(op, t, f) \ 40 #define INSTALL_UNOP(op, t, f) \
41 octave_value_typeinfo::register_unary_op \ 41 octave_value_typeinfo::register_unary_op \
42 (octave_value::op, t::static_type_id (), CONCAT2 (oct_unop_, f)); 42 (octave_value::op, t::static_type_id (), CONCAT2 (oct_unop_, f));
43 43
44 #define INSTALL_NCUNOP(op, t, f) \ 44 #define INSTALL_NCUNOP(op, t, f) \
45 octave_value_typeinfo::register_non_const_unary_op \ 45 octave_value_typeinfo::register_non_const_unary_op \
46 (octave_value::op, t::static_type_id (), CONCAT2 (oct_unop_, f)); 46 (octave_value::op, t::static_type_id (), CONCAT2 (oct_unop_, f));
47 47
48 #define INSTALL_BINOP(op, t1, t2, f) \ 48 #define INSTALL_BINOP(op, t1, t2, f) \
49 octave_value_typeinfo::register_binary_op \ 49 octave_value_typeinfo::register_binary_op \
50 (octave_value::op, t1::static_type_id (), t2::static_type_id (), \ 50 (octave_value::op, t1::static_type_id (), t2::static_type_id (), \
51 CONCAT2 (oct_binop_, f)); 51 CONCAT2 (oct_binop_, f));
52 52
53 #define INSTALL_CATOP(t1, t2, f) \ 53 #define INSTALL_CATOP(t1, t2, f) \
54 octave_value_typeinfo::register_cat_op \ 54 octave_value_typeinfo::register_cat_op \
55 (t1::static_type_id (), t2::static_type_id (), CONCAT2 (oct_catop_, f)); 55 (t1::static_type_id (), t2::static_type_id (), CONCAT2 (oct_catop_, f));
56 56
57 #define INSTALL_ASSIGNOP(op, t1, t2, f) \ 57 #define INSTALL_ASSIGNOP(op, t1, t2, f) \
58 octave_value_typeinfo::register_assign_op \ 58 octave_value_typeinfo::register_assign_op \
59 (octave_value::op, t1::static_type_id (), t2::static_type_id (), \ 59 (octave_value::op, t1::static_type_id (), t2::static_type_id (), \
60 CONCAT2 (oct_assignop_, f)); 60 CONCAT2 (oct_assignop_, f));
61 61
62 #define INSTALL_ASSIGNANYOP(op, t1, f) \ 62 #define INSTALL_ASSIGNANYOP(op, t1, f) \
63 octave_value_typeinfo::register_assignany_op \ 63 octave_value_typeinfo::register_assignany_op \
64 (octave_value::op, t1::static_type_id (), CONCAT2 (oct_assignop_, f)); 64 (octave_value::op, t1::static_type_id (), CONCAT2 (oct_assignop_, f));
65 65
66 #define INSTALL_ASSIGNCONV(t1, t2, tr) \ 66 #define INSTALL_ASSIGNCONV(t1, t2, tr) \
67 octave_value_typeinfo::register_pref_assign_conv \ 67 octave_value_typeinfo::register_pref_assign_conv \
68 (t1::static_type_id (), t2::static_type_id (), tr::static_type_id ()); 68 (t1::static_type_id (), t2::static_type_id (), tr::static_type_id ());
69 69
70 #define INSTALL_CONVOP(t1, t2, f) \ 70 #define INSTALL_CONVOP(t1, t2, f) \
71 octave_value_typeinfo::register_type_conv_op \ 71 octave_value_typeinfo::register_type_conv_op \
72 (t1::static_type_id (), t2::static_type_id (), CONCAT2 (oct_conv_, f)); 72 (t1::static_type_id (), t2::static_type_id (), CONCAT2 (oct_conv_, f));
73 73
74 #define INSTALL_WIDENOP(t1, t2, f) \ 74 #define INSTALL_WIDENOP(t1, t2, f) \
75 octave_value_typeinfo::register_widening_op \ 75 octave_value_typeinfo::register_widening_op \
76 (t1::static_type_id (), t2::static_type_id (), CONCAT2 (oct_conv_, f)); 76 (t1::static_type_id (), t2::static_type_id (), CONCAT2 (oct_conv_, f));
77 77
78 #define DEFASSIGNOP(name, t1, t2) \ 78 #define DEFASSIGNOP(name, t1, t2) \
79 static octave_value \ 79 static octave_value \
80 CONCAT2 (oct_assignop_, name) (octave_base_value& a1, \ 80 CONCAT2 (oct_assignop_, name) (octave_base_value& a1, \
81 const octave_value_list& idx, \ 81 const octave_value_list& idx, \
82 const octave_base_value& a2) 82 const octave_base_value& a2)
83 83
84 #define DEFASSIGNOP_FN(name, t1, t2, f) \ 84 #define DEFASSIGNOP_FN(name, t1, t2, f) \
85 static octave_value \ 85 static octave_value \
86 CONCAT2 (oct_assignop_, name) (octave_base_value& a1, \ 86 CONCAT2 (oct_assignop_, name) (octave_base_value& a1, \
87 const octave_value_list& idx, \ 87 const octave_value_list& idx, \
88 const octave_base_value& a2) \ 88 const octave_base_value& a2) \
89 { \ 89 { \
90 CONCAT2 (octave_, t1)& v1 = dynamic_cast<CONCAT2 (octave_, t1)&> (a1); \ 90 CONCAT2 (octave_, t1)& v1 = dynamic_cast<CONCAT2 (octave_, t1)&> (a1); \
91 const CONCAT2 (octave_, t2)& v2 = dynamic_cast<const CONCAT2 (octave_, t2)&> (a2); \ 91 const CONCAT2 (octave_, t2)& v2 = dynamic_cast<const CONCAT2 (octave_, t2)&> (a2); \
92 \ 92 \
93 v1.f (idx, v2.CONCAT2 (t1, _value) ()); \ 93 v1.f (idx, v2.CONCAT2 (t1, _value) ()); \
94 return octave_value (); \ 94 return octave_value (); \
95 } 95 }
96 96
97 #define DEFNULLASSIGNOP_FN(name, t, f) \ 97 #define DEFNULLASSIGNOP_FN(name, t, f) \
98 static octave_value \ 98 static octave_value \
99 CONCAT2 (oct_assignop_, name) (octave_base_value& a, \ 99 CONCAT2 (oct_assignop_, name) (octave_base_value& a, \
100 const octave_value_list& idx, \ 100 const octave_value_list& idx, \
101 const octave_base_value&) \ 101 const octave_base_value&) \
102 { \ 102 { \
103 CONCAT2 (octave_, t)& v = dynamic_cast<CONCAT2 (octave_, t)&> (a); \ 103 CONCAT2 (octave_, t)& v = dynamic_cast<CONCAT2 (octave_, t)&> (a); \
104 \ 104 \
105 v.f (idx); \ 105 v.f (idx); \
106 return octave_value (); \ 106 return octave_value (); \
107 } 107 }
108 108
109 #define DEFNDASSIGNOP_FN(name, t1, t2, e, f) \ 109 #define DEFNDASSIGNOP_FN(name, t1, t2, e, f) \
110 static octave_value \ 110 static octave_value \
111 CONCAT2 (oct_assignop_, name) (octave_base_value& a1, \ 111 CONCAT2 (oct_assignop_, name) (octave_base_value& a1, \
112 const octave_value_list& idx, \ 112 const octave_value_list& idx, \
113 const octave_base_value& a2) \ 113 const octave_base_value& a2) \
114 { \ 114 { \
115 CONCAT2 (octave_, t1)& v1 = dynamic_cast<CONCAT2 (octave_, t1)&> (a1); \ 115 CONCAT2 (octave_, t1)& v1 = dynamic_cast<CONCAT2 (octave_, t1)&> (a1); \
116 const CONCAT2 (octave_, t2)& v2 = dynamic_cast<const CONCAT2 (octave_, t2)&> (a2); \ 116 const CONCAT2 (octave_, t2)& v2 = dynamic_cast<const CONCAT2 (octave_, t2)&> (a2); \
117 \ 117 \
118 v1.f (idx, v2.CONCAT2 (e, _value) ()); \ 118 v1.f (idx, v2.CONCAT2 (e, _value) ()); \
119 return octave_value (); \ 119 return octave_value (); \
120 } 120 }
121 121
122 // FIXME: the following currently don't handle index. 122 // FIXME: the following currently don't handle index.
123 #define DEFNDASSIGNOP_OP(name, t1, t2, f, op) \ 123 #define DEFNDASSIGNOP_OP(name, t1, t2, f, op) \
124 static octave_value \ 124 static octave_value \
125 CONCAT2 (oct_assignop_, name) (octave_base_value& a1, \ 125 CONCAT2 (oct_assignop_, name) (octave_base_value& a1, \
126 const octave_value_list& idx, \ 126 const octave_value_list& idx, \
127 const octave_base_value& a2) \ 127 const octave_base_value& a2) \
128 { \ 128 { \
129 CONCAT2 (octave_, t1)& v1 = dynamic_cast<CONCAT2 (octave_, t1)&> (a1); \ 129 CONCAT2 (octave_, t1)& v1 = dynamic_cast<CONCAT2 (octave_, t1)&> (a1); \
130 const CONCAT2 (octave_, t2)& v2 = dynamic_cast<const CONCAT2 (octave_, t2)&> (a2); \ 130 const CONCAT2 (octave_, t2)& v2 = dynamic_cast<const CONCAT2 (octave_, t2)&> (a2); \
131 \ 131 \
132 assert (idx.empty ()); \ 132 assert (idx.empty ()); \
133 v1.matrix_ref () op v2.CONCAT2 (f, _value) (); \ 133 v1.matrix_ref () op v2.CONCAT2 (f, _value) (); \
134 \ 134 \
135 return octave_value (); \ 135 return octave_value (); \
136 } 136 }
137 137
138 #define DEFNDASSIGNOP_FNOP(name, t1, t2, f, fnop) \ 138 #define DEFNDASSIGNOP_FNOP(name, t1, t2, f, fnop) \
139 static octave_value \ 139 static octave_value \
140 CONCAT2 (oct_assignop_, name) (octave_base_value& a1, \ 140 CONCAT2 (oct_assignop_, name) (octave_base_value& a1, \
141 const octave_value_list& idx, \ 141 const octave_value_list& idx, \
142 const octave_base_value& a2) \ 142 const octave_base_value& a2) \
143 { \ 143 { \
144 CONCAT2 (octave_, t1)& v1 = dynamic_cast<CONCAT2 (octave_, t1)&> (a1); \ 144 CONCAT2 (octave_, t1)& v1 = dynamic_cast<CONCAT2 (octave_, t1)&> (a1); \
145 const CONCAT2 (octave_, t2)& v2 = dynamic_cast<const CONCAT2 (octave_, t2)&> (a2); \ 145 const CONCAT2 (octave_, t2)& v2 = dynamic_cast<const CONCAT2 (octave_, t2)&> (a2); \
146 \ 146 \
147 assert (idx.empty ()); \ 147 assert (idx.empty ()); \
148 fnop (v1.matrix_ref (), v2.CONCAT2 (f, _value) ()); \ 148 fnop (v1.matrix_ref (), v2.CONCAT2 (f, _value) ()); \
149 \ 149 \
150 return octave_value (); \ 150 return octave_value (); \
151 } 151 }
152 152
153 #define DEFASSIGNANYOP_FN(name, t1, f) \ 153 #define DEFASSIGNANYOP_FN(name, t1, f) \
154 static octave_value \ 154 static octave_value \
155 CONCAT2 (oct_assignop_, name) (octave_base_value& a1, \ 155 CONCAT2 (oct_assignop_, name) (octave_base_value& a1, \
156 const octave_value_list& idx, \ 156 const octave_value_list& idx, \
157 const octave_value& a2) \ 157 const octave_value& a2) \
158 { \ 158 { \
159 CONCAT2 (octave_, t1)& v1 = dynamic_cast<CONCAT2 (octave_, t1)&> (a1); \ 159 CONCAT2 (octave_, t1)& v1 = dynamic_cast<CONCAT2 (octave_, t1)&> (a1); \
160 \ 160 \
161 v1.f (idx, a2); \ 161 v1.f (idx, a2); \
162 return octave_value (); \ 162 return octave_value (); \
163 } 163 }
164 164
165 #define CONVDECL(name) \ 165 #define CONVDECL(name) \
166 static octave_base_value * \ 166 static octave_base_value * \
167 CONCAT2 (oct_conv_, name) (const octave_base_value& a) 167 CONCAT2 (oct_conv_, name) (const octave_base_value& a)
168 168
169 #define CONVDECLX(name) \ 169 #define CONVDECLX(name) \
170 static octave_base_value * \ 170 static octave_base_value * \
171 CONCAT2 (oct_conv_, name) (const octave_base_value&) 171 CONCAT2 (oct_conv_, name) (const octave_base_value&)
172 172
173 #define DEFCONV(name, a_dummy, b_dummy) \ 173 #define DEFCONV(name, a_dummy, b_dummy) \
174 CONVDECL (name) 174 CONVDECL (name)
175 175
176 #define DEFCONVFNX(name, tfrom, ovtto, tto, e) \ 176 #define DEFCONVFNX(name, tfrom, ovtto, tto, e) \
177 CONVDECL (name) \ 177 CONVDECL (name) \
178 { \ 178 { \
179 const CONCAT2 (octave_, tfrom)& v = dynamic_cast<const CONCAT2 (octave_, tfrom)&> (a); \ 179 const CONCAT2 (octave_, tfrom)& v = dynamic_cast<const CONCAT2 (octave_, tfrom)&> (a); \
180 \ 180 \
181 return new CONCAT2 (octave_, ovtto) (CONCAT2 (tto, NDArray) (v.CONCAT2 (e, array_value) ())); \ 181 return new CONCAT2 (octave_, ovtto) (CONCAT2 (tto, NDArray) (v.CONCAT2 (e, array_value) ())); \
182 } 182 }
183 183
184 #define DEFCONVFNX2(name, tfrom, ovtto, e) \ 184 #define DEFCONVFNX2(name, tfrom, ovtto, e) \
185 CONVDECL (name) \ 185 CONVDECL (name) \
186 { \ 186 { \
187 const CONCAT2 (octave_, tfrom)& v = dynamic_cast<const CONCAT2 (octave_, tfrom)&> (a); \ 187 const CONCAT2 (octave_, tfrom)& v = dynamic_cast<const CONCAT2 (octave_, tfrom)&> (a); \
188 \ 188 \
189 return new CONCAT2 (octave_, ovtto) (v.CONCAT2 (e, array_value) ()); \ 189 return new CONCAT2 (octave_, ovtto) (v.CONCAT2 (e, array_value) ()); \
190 } 190 }
191 191
192 #define DEFDBLCONVFN(name, ovtfrom, e) \ 192 #define DEFDBLCONVFN(name, ovtfrom, e) \
193 CONVDECL (name) \ 193 CONVDECL (name) \
194 { \ 194 { \
195 const CONCAT2 (octave_, ovtfrom)& v = dynamic_cast<const CONCAT2 (octave_, ovtfrom)&> (a); \ 195 const CONCAT2 (octave_, ovtfrom)& v = dynamic_cast<const CONCAT2 (octave_, ovtfrom)&> (a); \
196 \ 196 \
197 return new octave_matrix (NDArray (v.CONCAT2 (e, _value) ())); \ 197 return new octave_matrix (NDArray (v.CONCAT2 (e, _value) ())); \
198 } 198 }
199 199
200 #define DEFFLTCONVFN(name, ovtfrom, e) \ 200 #define DEFFLTCONVFN(name, ovtfrom, e) \
201 CONVDECL (name) \ 201 CONVDECL (name) \
202 { \ 202 { \
203 const CONCAT2 (octave_, ovtfrom)& v = dynamic_cast<const CONCAT2 (octave_, ovtfrom)&> (a); \ 203 const CONCAT2 (octave_, ovtfrom)& v = dynamic_cast<const CONCAT2 (octave_, ovtfrom)&> (a); \
204 \ 204 \
205 return new octave_float_matrix (FloatNDArray (v.CONCAT2 (e, _value) ())); \ 205 return new octave_float_matrix (FloatNDArray (v.CONCAT2 (e, _value) ())); \
206 } 206 }
207 207
208 #define DEFSTRINTCONVFN(name, tto) \ 208 #define DEFSTRINTCONVFN(name, tto) \
209 DEFCONVFNX(name, char_matrix_str, CONCAT2 (tto, _matrix), tto, char_) 209 DEFCONVFNX(name, char_matrix_str, CONCAT2 (tto, _matrix), tto, char_)
210 210
211 #define DEFSTRDBLCONVFN(name, tfrom) \ 211 #define DEFSTRDBLCONVFN(name, tfrom) \
212 DEFCONVFNX(name, tfrom, matrix, , char_) 212 DEFCONVFNX(name, tfrom, matrix, , char_)
213 213
214 #define DEFSTRFLTCONVFN(name, tfrom) \ 214 #define DEFSTRFLTCONVFN(name, tfrom) \
215 DEFCONVFNX(name, tfrom, float_matrix, Float, char_) 215 DEFCONVFNX(name, tfrom, float_matrix, Float, char_)
216 216
217 #define DEFCONVFN(name, tfrom, tto) \ 217 #define DEFCONVFN(name, tfrom, tto) \
218 DEFCONVFNX2 (name, tfrom, CONCAT2 (tto, _matrix), CONCAT2 (tto, _)) 218 DEFCONVFNX2 (name, tfrom, CONCAT2 (tto, _matrix), CONCAT2 (tto, _))
219 219
220 #define DEFCONVFN2(name, tfrom, sm, tto) \ 220 #define DEFCONVFN2(name, tfrom, sm, tto) \
221 DEFCONVFNX2 (name, CONCAT3 (tfrom, _, sm), CONCAT2 (tto, _matrix), CONCAT2 (tto, _)) 221 DEFCONVFNX2 (name, CONCAT3 (tfrom, _, sm), CONCAT2 (tto, _matrix), CONCAT2 (tto, _))
222 222
223 #define DEFUNOPX(name, t) \ 223 #define DEFUNOPX(name, t) \
224 static octave_value \ 224 static octave_value \
225 CONCAT2 (oct_unop_, name) (const octave_base_value&) 225 CONCAT2 (oct_unop_, name) (const octave_base_value&)
226 226
227 #define DEFUNOP(name, t) \ 227 #define DEFUNOP(name, t) \
228 static octave_value \ 228 static octave_value \
229 CONCAT2 (oct_unop_, name) (const octave_base_value& a) 229 CONCAT2 (oct_unop_, name) (const octave_base_value& a)
230 230
231 #define DEFUNOP_OP(name, t, op) \ 231 #define DEFUNOP_OP(name, t, op) \
232 static octave_value \ 232 static octave_value \
233 CONCAT2 (oct_unop_, name) (const octave_base_value& a) \ 233 CONCAT2 (oct_unop_, name) (const octave_base_value& a) \
234 { \ 234 { \
235 const CONCAT2 (octave_, t)& v = dynamic_cast<const CONCAT2 (octave_, t)&> (a); \ 235 const CONCAT2 (octave_, t)& v = dynamic_cast<const CONCAT2 (octave_, t)&> (a); \
236 return octave_value (op v.CONCAT2 (t, _value) ()); \ 236 return octave_value (op v.CONCAT2 (t, _value) ()); \
237 } 237 }
238 238
239 #define DEFNDUNOP_OP(name, t, e, op) \ 239 #define DEFNDUNOP_OP(name, t, e, op) \
240 static octave_value \ 240 static octave_value \
241 CONCAT2 (oct_unop_, name) (const octave_base_value& a) \ 241 CONCAT2 (oct_unop_, name) (const octave_base_value& a) \
242 { \ 242 { \
243 const CONCAT2 (octave_, t)& v = dynamic_cast<const CONCAT2 (octave_, t)&> (a); \ 243 const CONCAT2 (octave_, t)& v = dynamic_cast<const CONCAT2 (octave_, t)&> (a); \
244 return octave_value (op v.CONCAT2 (e, _value) ()); \ 244 return octave_value (op v.CONCAT2 (e, _value) ()); \
245 } 245 }
246 246
247 // FIXME: in some cases, the constructor isn't necessary. 247 // FIXME: in some cases, the constructor isn't necessary.
248 248
249 #define DEFUNOP_FN(name, t, f) \ 249 #define DEFUNOP_FN(name, t, f) \
250 static octave_value \ 250 static octave_value \
251 CONCAT2 (oct_unop_, name) (const octave_base_value& a) \ 251 CONCAT2 (oct_unop_, name) (const octave_base_value& a) \
252 { \ 252 { \
253 const CONCAT2 (octave_, t)& v = dynamic_cast<const CONCAT2 (octave_, t)&> (a); \ 253 const CONCAT2 (octave_, t)& v = dynamic_cast<const CONCAT2 (octave_, t)&> (a); \
254 return octave_value (f (v.CONCAT2 (t, _value) ())); \ 254 return octave_value (f (v.CONCAT2 (t, _value) ())); \
255 } 255 }
256 256
257 #define DEFNDUNOP_FN(name, t, e, f) \ 257 #define DEFNDUNOP_FN(name, t, e, f) \
258 static octave_value \ 258 static octave_value \
259 CONCAT2 (oct_unop_, name) (const octave_base_value& a) \ 259 CONCAT2 (oct_unop_, name) (const octave_base_value& a) \
260 { \ 260 { \
261 const CONCAT2 (octave_, t)& v = dynamic_cast<const CONCAT2 (octave_, t)&> (a); \ 261 const CONCAT2 (octave_, t)& v = dynamic_cast<const CONCAT2 (octave_, t)&> (a); \
262 return octave_value (f (v.CONCAT2 (e, _value) ())); \ 262 return octave_value (f (v.CONCAT2 (e, _value) ())); \
263 } 263 }
264 264
265 #define DEFNCUNOP_METHOD(name, t, method) \ 265 #define DEFNCUNOP_METHOD(name, t, method) \
266 static void \ 266 static void \
267 CONCAT2 (oct_unop_, name) (octave_base_value& a) \ 267 CONCAT2 (oct_unop_, name) (octave_base_value& a) \
268 { \ 268 { \
269 CONCAT2 (octave_, t)& v = dynamic_cast<CONCAT2 (octave_, t)&> (a); \ 269 CONCAT2 (octave_, t)& v = dynamic_cast<CONCAT2 (octave_, t)&> (a); \
270 v.method (); \ 270 v.method (); \
271 } 271 }
272 272
273 #define DEFBINOPX(name, t1, t2) \ 273 #define DEFBINOPX(name, t1, t2) \
274 static octave_value \ 274 static octave_value \
275 CONCAT2 (oct_binop_, name) (const octave_base_value&, \ 275 CONCAT2 (oct_binop_, name) (const octave_base_value&, \
276 const octave_base_value&) 276 const octave_base_value&)
277 277
278 #define DEFBINOP(name, t1, t2) \ 278 #define DEFBINOP(name, t1, t2) \
279 static octave_value \ 279 static octave_value \
280 CONCAT2 (oct_binop_, name) (const octave_base_value& a1, \ 280 CONCAT2 (oct_binop_, name) (const octave_base_value& a1, \
281 const octave_base_value& a2) 281 const octave_base_value& a2)
282 282
283 #define DEFBINOP_OP(name, t1, t2, op) \ 283 #define DEFBINOP_OP(name, t1, t2, op) \
284 static octave_value \ 284 static octave_value \
285 CONCAT2 (oct_binop_, name) (const octave_base_value& a1, \ 285 CONCAT2 (oct_binop_, name) (const octave_base_value& a1, \
286 const octave_base_value& a2) \ 286 const octave_base_value& a2) \
287 { \ 287 { \
288 const CONCAT2 (octave_, t1)& v1 = dynamic_cast<const CONCAT2 (octave_, t1)&> (a1); \ 288 const CONCAT2 (octave_, t1)& v1 = dynamic_cast<const CONCAT2 (octave_, t1)&> (a1); \
289 const CONCAT2 (octave_, t2)& v2 = dynamic_cast<const CONCAT2 (octave_, t2)&> (a2); \ 289 const CONCAT2 (octave_, t2)& v2 = dynamic_cast<const CONCAT2 (octave_, t2)&> (a2); \
290 \ 290 \
291 return octave_value \ 291 return octave_value \
292 (v1.CONCAT2 (t1, _value) () op v2.CONCAT2 (t2, _value) ()); \ 292 (v1.CONCAT2 (t1, _value) () op v2.CONCAT2 (t2, _value) ()); \
293 } 293 }
294 294
295 #define DEFCMPLXCMPOP_OP(name, t1, t2, op) \ 295 #define DEFCMPLXCMPOP_OP(name, t1, t2, op) \
296 static octave_value \ 296 static octave_value \
297 CONCAT2 (oct_binop_, name) (const octave_base_value& a1, \ 297 CONCAT2 (oct_binop_, name) (const octave_base_value& a1, \
298 const octave_base_value& a2) \ 298 const octave_base_value& a2) \
299 { \ 299 { \
300 const CONCAT2 (octave_, t1)& v1 = dynamic_cast<const CONCAT2 (octave_, t1)&> (a1); \ 300 const CONCAT2 (octave_, t1)& v1 = dynamic_cast<const CONCAT2 (octave_, t1)&> (a1); \
301 const CONCAT2 (octave_, t2)& v2 = dynamic_cast<const CONCAT2 (octave_, t2)&> (a2); \ 301 const CONCAT2 (octave_, t2)& v2 = dynamic_cast<const CONCAT2 (octave_, t2)&> (a2); \
302 \ 302 \
303 warn_complex_cmp (); \ 303 warn_complex_cmp (); \
304 \ 304 \
305 return octave_value \ 305 return octave_value \
306 (v1.CONCAT2 (t1, _value) () op v2.CONCAT2 (t2, _value) ()); \ 306 (v1.CONCAT2 (t1, _value) () op v2.CONCAT2 (t2, _value) ()); \
307 } 307 }
308 308
309 #define DEFSCALARBOOLOP_OP(name, t1, t2, op) \ 309 #define DEFSCALARBOOLOP_OP(name, t1, t2, op) \
310 static octave_value \ 310 static octave_value \
311 CONCAT2 (oct_binop_, name) (const octave_base_value& a1, \ 311 CONCAT2 (oct_binop_, name) (const octave_base_value& a1, \
312 const octave_base_value& a2) \ 312 const octave_base_value& a2) \
313 { \ 313 { \
314 const CONCAT2 (octave_, t1)& v1 = dynamic_cast<const CONCAT2 (octave_, t1)&> (a1); \ 314 const CONCAT2 (octave_, t1)& v1 = dynamic_cast<const CONCAT2 (octave_, t1)&> (a1); \
315 const CONCAT2 (octave_, t2)& v2 = dynamic_cast<const CONCAT2 (octave_, t2)&> (a2); \ 315 const CONCAT2 (octave_, t2)& v2 = dynamic_cast<const CONCAT2 (octave_, t2)&> (a2); \
316 \ 316 \
317 if (octave::math::isnan (v1.CONCAT2 (t1, _value) ()) || octave::math::isnan (v2.CONCAT2 (t2, _value) ())) \ 317 if (octave::math::isnan (v1.CONCAT2 (t1, _value) ()) || octave::math::isnan (v2.CONCAT2 (t2, _value) ())) \
318 err_nan_to_logical_conversion (); \ 318 err_nan_to_logical_conversion (); \
319 \ 319 \
320 return octave_value \ 320 return octave_value \
321 (v1.CONCAT2 (t1, _value) () op v2.CONCAT2 (t2, _value) ()); \ 321 (v1.CONCAT2 (t1, _value) () op v2.CONCAT2 (t2, _value) ()); \
322 } 322 }
323 323
324 #define DEFNDBINOP_OP(name, t1, t2, e1, e2, op) \ 324 #define DEFNDBINOP_OP(name, t1, t2, e1, e2, op) \
325 static octave_value \ 325 static octave_value \
326 CONCAT2 (oct_binop_, name) (const octave_base_value& a1, \ 326 CONCAT2 (oct_binop_, name) (const octave_base_value& a1, \
327 const octave_base_value& a2) \ 327 const octave_base_value& a2) \
328 { \ 328 { \
329 const CONCAT2 (octave_, t1)& v1 = dynamic_cast<const CONCAT2 (octave_, t1)&> (a1); \ 329 const CONCAT2 (octave_, t1)& v1 = dynamic_cast<const CONCAT2 (octave_, t1)&> (a1); \
330 const CONCAT2 (octave_, t2)& v2 = dynamic_cast<const CONCAT2 (octave_, t2)&> (a2); \ 330 const CONCAT2 (octave_, t2)& v2 = dynamic_cast<const CONCAT2 (octave_, t2)&> (a2); \
331 \ 331 \
332 return octave_value \ 332 return octave_value \
333 (v1.CONCAT2 (e1, _value) () op v2.CONCAT2 (e2, _value) ()); \ 333 (v1.CONCAT2 (e1, _value) () op v2.CONCAT2 (e2, _value) ()); \
334 } 334 }
335 335
336 // FIXME: in some cases, the constructor isn't necessary. 336 // FIXME: in some cases, the constructor isn't necessary.
337 337
338 #define DEFBINOP_FN(name, t1, t2, f) \ 338 #define DEFBINOP_FN(name, t1, t2, f) \
339 static octave_value \ 339 static octave_value \
340 CONCAT2 (oct_binop_, name) (const octave_base_value& a1, \ 340 CONCAT2 (oct_binop_, name) (const octave_base_value& a1, \
341 const octave_base_value& a2) \ 341 const octave_base_value& a2) \
342 { \ 342 { \
343 const CONCAT2 (octave_, t1)& v1 = dynamic_cast<const CONCAT2 (octave_, t1)&> (a1); \ 343 const CONCAT2 (octave_, t1)& v1 = dynamic_cast<const CONCAT2 (octave_, t1)&> (a1); \
344 const CONCAT2 (octave_, t2)& v2 = dynamic_cast<const CONCAT2 (octave_, t2)&> (a2); \ 344 const CONCAT2 (octave_, t2)& v2 = dynamic_cast<const CONCAT2 (octave_, t2)&> (a2); \
345 \ 345 \
346 return octave_value (f (v1.CONCAT2 (t1, _value) (), v2.CONCAT2 (t2, _value) ())); \ 346 return octave_value (f (v1.CONCAT2 (t1, _value) (), v2.CONCAT2 (t2, _value) ())); \
347 } 347 }
348 348
349 #define DEFNDBINOP_FN(name, t1, t2, e1, e2, f) \ 349 #define DEFNDBINOP_FN(name, t1, t2, e1, e2, f) \
350 static octave_value \ 350 static octave_value \
351 CONCAT2 (oct_binop_, name) (const octave_base_value& a1, \ 351 CONCAT2 (oct_binop_, name) (const octave_base_value& a1, \
352 const octave_base_value& a2) \ 352 const octave_base_value& a2) \
353 { \ 353 { \
354 const CONCAT2 (octave_, t1)& v1 = dynamic_cast<const CONCAT2 (octave_, t1)&> (a1); \ 354 const CONCAT2 (octave_, t1)& v1 = dynamic_cast<const CONCAT2 (octave_, t1)&> (a1); \
355 const CONCAT2 (octave_, t2)& v2 = dynamic_cast<const CONCAT2 (octave_, t2)&> (a2); \ 355 const CONCAT2 (octave_, t2)& v2 = dynamic_cast<const CONCAT2 (octave_, t2)&> (a2); \
356 \ 356 \
357 return octave_value (f (v1.CONCAT2 (e1, _value) (), v2.CONCAT2 (e2, _value) ())); \ 357 return octave_value (f (v1.CONCAT2 (e1, _value) (), v2.CONCAT2 (e2, _value) ())); \
358 } 358 }
359 359
360 #define DEFNDCMPLXCMPOP_FN(name, t1, t2, e1, e2, f) \ 360 #define DEFNDCMPLXCMPOP_FN(name, t1, t2, e1, e2, f) \
361 static octave_value \ 361 static octave_value \
362 CONCAT2 (oct_binop_, name) (const octave_base_value& a1, \ 362 CONCAT2 (oct_binop_, name) (const octave_base_value& a1, \
363 const octave_base_value& a2) \ 363 const octave_base_value& a2) \
364 { \ 364 { \
365 const CONCAT2 (octave_, t1)& v1 = dynamic_cast<const CONCAT2 (octave_, t1)&> (a1); \ 365 const CONCAT2 (octave_, t1)& v1 = dynamic_cast<const CONCAT2 (octave_, t1)&> (a1); \
366 const CONCAT2 (octave_, t2)& v2 = dynamic_cast<const CONCAT2 (octave_, t2)&> (a2); \ 366 const CONCAT2 (octave_, t2)& v2 = dynamic_cast<const CONCAT2 (octave_, t2)&> (a2); \
367 \ 367 \
368 return octave_value (f (v1.CONCAT2 (e1, _value) (), v2.CONCAT2 (e2, _value) ())); \ 368 return octave_value (f (v1.CONCAT2 (e1, _value) (), v2.CONCAT2 (e2, _value) ())); \
369 } 369 }
370 370
371 #define DEFCATOPX(name, t1, t2) \ 371 #define DEFCATOPX(name, t1, t2) \
372 static octave_value \ 372 static octave_value \
373 CONCAT2 (oct_catop_, name) (octave_base_value&, const octave_base_value&, \ 373 CONCAT2 (oct_catop_, name) (octave_base_value&, const octave_base_value&, \
374 const Array<octave_idx_type>& ra_idx) 374 const Array<octave_idx_type>& ra_idx)
375 375
376 #define DEFCATOP(name, t1, t2) \ 376 #define DEFCATOP(name, t1, t2) \
377 static octave_value \ 377 static octave_value \
378 CONCAT2 (oct_catop_, name) (octave_base_value& a1, \ 378 CONCAT2 (oct_catop_, name) (octave_base_value& a1, \
379 const octave_base_value& a2, \ 379 const octave_base_value& a2, \
380 const Array<octave_idx_type>& ra_idx) 380 const Array<octave_idx_type>& ra_idx)
381 381
382 // FIXME: in some cases, the constructor isn't necessary. 382 // FIXME: in some cases, the constructor isn't necessary.
383 383
384 #define DEFCATOP_FN(name, t1, t2, f) \ 384 #define DEFCATOP_FN(name, t1, t2, f) \
385 static octave_value \ 385 static octave_value \
386 CONCAT2 (oct_catop_, name) (octave_base_value& a1, \ 386 CONCAT2 (oct_catop_, name) (octave_base_value& a1, \
387 const octave_base_value& a2, \ 387 const octave_base_value& a2, \
388 const Array<octave_idx_type>& ra_idx) \ 388 const Array<octave_idx_type>& ra_idx) \
389 { \ 389 { \
390 CONCAT2 (octave_, t1)& v1 = dynamic_cast<CONCAT2 (octave_, t1)&> (a1); \ 390 CONCAT2 (octave_, t1)& v1 = dynamic_cast<CONCAT2 (octave_, t1)&> (a1); \
391 const CONCAT2 (octave_, t2)& v2 = dynamic_cast<const CONCAT2 (octave_, t2)&> (a2); \ 391 const CONCAT2 (octave_, t2)& v2 = dynamic_cast<const CONCAT2 (octave_, t2)&> (a2); \
392 \ 392 \
393 return octave_value (v1.CONCAT2 (t1, _value) () . f (v2.CONCAT2 (t2, _value) (), ra_idx)); \ 393 return octave_value (v1.CONCAT2 (t1, _value) () . f (v2.CONCAT2 (t2, _value) (), ra_idx)); \
394 } 394 }
395 395
396 #define DEFNDCATOP_FN(name, t1, t2, e1, e2, f) \ 396 #define DEFNDCATOP_FN(name, t1, t2, e1, e2, f) \
397 static octave_value \ 397 static octave_value \
398 CONCAT2 (oct_catop_, name) (octave_base_value& a1, \ 398 CONCAT2 (oct_catop_, name) (octave_base_value& a1, \
399 const octave_base_value& a2, \ 399 const octave_base_value& a2, \
400 const Array<octave_idx_type>& ra_idx) \ 400 const Array<octave_idx_type>& ra_idx) \
401 { \ 401 { \
402 CONCAT2 (octave_, t1)& v1 = dynamic_cast<CONCAT2 (octave_, t1)&> (a1); \ 402 CONCAT2 (octave_, t1)& v1 = dynamic_cast<CONCAT2 (octave_, t1)&> (a1); \
403 const CONCAT2 (octave_, t2)& v2 = dynamic_cast<const CONCAT2 (octave_, t2)&> (a2); \ 403 const CONCAT2 (octave_, t2)& v2 = dynamic_cast<const CONCAT2 (octave_, t2)&> (a2); \
404 \ 404 \
405 return octave_value (v1.CONCAT2 (e1, _value) () . f (v2.CONCAT2 (e2, _value) (), ra_idx)); \ 405 return octave_value (v1.CONCAT2 (e1, _value) () . f (v2.CONCAT2 (e2, _value) (), ra_idx)); \
406 } 406 }
407 407
408 #define DEFNDCHARCATOP_FN(name, t1, t2, f) \ 408 #define DEFNDCHARCATOP_FN(name, t1, t2, f) \
409 static octave_value \ 409 static octave_value \
410 CONCAT2 (oct_catop_, name) (octave_base_value& a1, \ 410 CONCAT2 (oct_catop_, name) (octave_base_value& a1, \
411 const octave_base_value& a2, \ 411 const octave_base_value& a2, \
412 const Array<octave_idx_type>& ra_idx) \ 412 const Array<octave_idx_type>& ra_idx) \
413 { \ 413 { \
414 CONCAT2 (octave_, t1)& v1 = dynamic_cast<CONCAT2 (octave_, t1)&> (a1); \ 414 CONCAT2 (octave_, t1)& v1 = dynamic_cast<CONCAT2 (octave_, t1)&> (a1); \
415 const CONCAT2 (octave_, t2)& v2 = dynamic_cast<const CONCAT2 (octave_, t2)&> (a2); \ 415 const CONCAT2 (octave_, t2)& v2 = dynamic_cast<const CONCAT2 (octave_, t2)&> (a2); \
416 \ 416 \
417 return octave_value (v1.char_array_value () . f (v2.char_array_value (), ra_idx), \ 417 return octave_value (v1.char_array_value () . f (v2.char_array_value (), ra_idx), \
418 ((a1.is_sq_string () || a2.is_sq_string ()) \ 418 ((a1.is_sq_string () || a2.is_sq_string ()) \
419 ? '\'' : '"')); \ 419 ? '\'' : '"')); \
420 } 420 }
421 421
422 // For compatibility, the second arg is always converted to the type 422 // For compatibility, the second arg is always converted to the type
423 // of the first. Hmm. 423 // of the first. Hmm.
424 424
425 #define DEFNDCATOP_FN2(name, t1, t2, tc1, tc2, e1, e2, f) \ 425 #define DEFNDCATOP_FN2(name, t1, t2, tc1, tc2, e1, e2, f) \
426 static octave_value \ 426 static octave_value \
427 CONCAT2 (oct_catop_, name) (octave_base_value& a1, \ 427 CONCAT2 (oct_catop_, name) (octave_base_value& a1, \
428 const octave_base_value& a2, \ 428 const octave_base_value& a2, \
429 const Array<octave_idx_type>& ra_idx) \ 429 const Array<octave_idx_type>& ra_idx) \
430 { \ 430 { \
431 CONCAT2 (octave_, t1)& v1 = dynamic_cast<CONCAT2 (octave_, t1)&> (a1); \ 431 CONCAT2 (octave_, t1)& v1 = dynamic_cast<CONCAT2 (octave_, t1)&> (a1); \
432 const CONCAT2 (octave_, t2)& v2 = dynamic_cast<const CONCAT2 (octave_, t2)&> (a2); \ 432 const CONCAT2 (octave_, t2)& v2 = dynamic_cast<const CONCAT2 (octave_, t2)&> (a2); \
433 \ 433 \
434 return octave_value (tc1 (v1.CONCAT2 (e1, _value) ()) . f (tc2 (v2.CONCAT2 (e2, _value) ()), ra_idx)); \ 434 return octave_value (tc1 (v1.CONCAT2 (e1, _value) ()) . f (tc2 (v2.CONCAT2 (e2, _value) ()), ra_idx)); \
435 } 435 }
436 436
437 #endif 437 #endif