GNU Octave  9.1.0
A high-level interpreted language, primarily intended for numerical computations, mostly compatible with Matlab
ops.h
Go to the documentation of this file.
1 ////////////////////////////////////////////////////////////////////////
2 //
3 // Copyright (C) 1996-2024 The Octave Project Developers
4 //
5 // See the file COPYRIGHT.md in the top-level directory of this
6 // distribution or <https://octave.org/copyright/>.
7 //
8 // This file is part of Octave.
9 //
10 // Octave is free software: you can redistribute it and/or modify it
11 // under the terms of the GNU General Public License as published by
12 // the Free Software Foundation, either version 3 of the License, or
13 // (at your option) any later version.
14 //
15 // Octave is distributed in the hope that it will be useful, but
16 // WITHOUT ANY WARRANTY; without even the implied warranty of
17 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 // GNU General Public License for more details.
19 //
20 // You should have received a copy of the GNU General Public License
21 // along with Octave; see the file COPYING. If not, see
22 // <https://www.gnu.org/licenses/>.
23 //
24 ////////////////////////////////////////////////////////////////////////
25 
26 #if ! defined (octave_ops_h)
27 #define octave_ops_h 1
28 
29 #include "octave-config.h"
30 
31 #include "Array-util.h"
32 #include "error.h"
33 
34 OCTAVE_BEGIN_NAMESPACE(octave)
35 
36 class type_info;
37 
38 OCTAVE_END_NAMESPACE(octave)
39 
40 // NOTE: If OCTAVE_ENABLE_INTERNAL_CHECKS is defined, then
41 // OCTAVE_DYNAMIC_CAST is only safe if you can ensure that the cast will
42 // succeed. Using static_cast disables the RTTI checks used by
43 // dynamic_cast that ensure an unsuccesful cast will either throw an
44 // error for reference types or or return nullptr for pointer types.
45 
46 #if defined (OCTAVE_ENABLE_INTERNAL_CHECKS)
47 # define OCTAVE_DYNAMIC_CAST dynamic_cast
48 #else
49 # define OCTAVE_DYNAMIC_CAST static_cast
50 #endif
51 
52 #define OCTAVE_CAST_BASE_VALUE(T, T_VAL, BASE_VAL) \
53  T T_VAL = OCTAVE_DYNAMIC_CAST<T> (BASE_VAL)
54 
55 // Concatenation macros that enforce argument prescan
56 #define CONCAT2X(x, y) x ## y
57 #define CONCAT2(x, y) CONCAT2X (x, y)
58 
59 #define CONCAT3X(x, y, z) x ## y ## z
60 #define CONCAT3(x, y, z) CONCAT3X (x, y, z)
61 
62 #define INSTALL_UNOP_TI(ti, op, t, f) \
63  ti.install_unary_op \
64  (octave_value::op, t::static_type_id (), CONCAT2 (oct_unop_, f));
65 
66 #define INSTALL_NCUNOP_TI(ti, op, t, f) \
67  ti.install_non_const_unary_op \
68  (octave_value::op, t::static_type_id (), CONCAT2 (oct_unop_, f));
69 
70 #define INSTALL_BINOP_TI(ti, op, t1, t2, f) \
71  ti.install_binary_op \
72  (octave_value::op, t1::static_type_id (), t2::static_type_id (), \
73  CONCAT2 (oct_binop_, f));
74 
75 #define INSTALL_CATOP_TI(ti, t1, t2, f) \
76  ti.install_cat_op \
77  (t1::static_type_id (), t2::static_type_id (), CONCAT2 (oct_catop_, f));
78 
79 #define INSTALL_ASSIGNOP_TI(ti, op, t1, t2, f) \
80  ti.install_assign_op \
81  (octave_value::op, t1::static_type_id (), t2::static_type_id (), \
82  CONCAT2 (oct_assignop_, f));
83 
84 #define INSTALL_ASSIGNANYOP_TI(ti, op, t1, f) \
85  ti.install_assignany_op \
86  (octave_value::op, t1::static_type_id (), CONCAT2 (oct_assignop_, f));
87 
88 #define INSTALL_ASSIGNCONV_TI(ti, t1, t2, tr) \
89  ti.install_pref_assign_conv \
90  (t1::static_type_id (), t2::static_type_id (), tr::static_type_id ());
91 
92 #define INSTALL_WIDENOP_TI(ti, t1, t2, f) \
93  ti.install_widening_op \
94  (t1::static_type_id (), t2::static_type_id (), CONCAT2 (oct_conv_, f));
95 
96 #define DEFASSIGNOP(name, t1, t2) \
97  static octave_value \
98  CONCAT2 (oct_assignop_, name) (octave_base_value& a1, \
99  const octave_value_list& idx, \
100  const octave_base_value& a2)
101 
102 #define DEFASSIGNOP_FN(name, t1, t2, f) \
103  static octave_value \
104  CONCAT2 (oct_assignop_, name) (octave_base_value& a1, \
105  const octave_value_list& idx, \
106  const octave_base_value& a2) \
107  { \
108  OCTAVE_CAST_BASE_VALUE (CONCAT2 (octave_, t1)&, v1, a1); \
109  OCTAVE_CAST_BASE_VALUE (const CONCAT2 (octave_, t2)&, v2, a2); \
110  \
111  v1.f (idx, v2.CONCAT2 (t1, _value) ()); \
112  return octave_value (); \
113  }
114 
115 #define DEFNULLASSIGNOP_FN(name, t, f) \
116  static octave_value \
117  CONCAT2 (oct_assignop_, name) (octave_base_value& a, \
118  const octave_value_list& idx, \
119  const octave_base_value&) \
120  { \
121  OCTAVE_CAST_BASE_VALUE (CONCAT2 (octave_, t)&, v, a); \
122  \
123  v.f (idx); \
124  return octave_value (); \
125  }
126 
127 #define DEFNDASSIGNOP_FN(name, t1, t2, e, f) \
128  static octave_value \
129  CONCAT2 (oct_assignop_, name) (octave_base_value& a1, \
130  const octave_value_list& idx, \
131  const octave_base_value& a2) \
132  { \
133  OCTAVE_CAST_BASE_VALUE (CONCAT2 (octave_, t1)&, v1, a1); \
134  OCTAVE_CAST_BASE_VALUE (const CONCAT2 (octave_, t2)&, v2, a2); \
135  \
136  v1.f (idx, v2.CONCAT2 (e, _value) ()); \
137  return octave_value (); \
138  }
139 
140 // FIXME: the following currently don't handle index.
141 #define DEFNDASSIGNOP_OP(name, t1, t2, f, op) \
142  static octave_value \
143  CONCAT2 (oct_assignop_, name) (octave_base_value& a1, \
144  const octave_value_list& idx, \
145  const octave_base_value& a2) \
146  { \
147  OCTAVE_CAST_BASE_VALUE (CONCAT2 (octave_, t1)&, v1, a1); \
148  OCTAVE_CAST_BASE_VALUE (const CONCAT2 (octave_, t2)&, v2, a2); \
149  \
150  error_unless (idx.empty ()); \
151  v1.matrix_ref () op v2.CONCAT2 (f, _value) (); \
152  \
153  return octave_value (); \
154  }
155 
156 #define DEFNDASSIGNOP_FNOP(name, t1, t2, f, fnop) \
157  static octave_value \
158  CONCAT2 (oct_assignop_, name) (octave_base_value& a1, \
159  const octave_value_list& idx, \
160  const octave_base_value& a2) \
161  { \
162  OCTAVE_CAST_BASE_VALUE (CONCAT2 (octave_, t1)&, v1, a1); \
163  OCTAVE_CAST_BASE_VALUE (const CONCAT2 (octave_, t2)&, v2, a2); \
164  \
165  error_unless (idx.empty ()); \
166  fnop (v1.matrix_ref (), v2.CONCAT2 (f, _value) ()); \
167  \
168  return octave_value (); \
169  }
170 
171 #define DEFASSIGNANYOP_FN(name, t1, f) \
172  static octave_value \
173  CONCAT2 (oct_assignop_, name) (octave_base_value& a1, \
174  const octave_value_list& idx, \
175  const octave_value& a2) \
176  { \
177  OCTAVE_CAST_BASE_VALUE (CONCAT2 (octave_, t1)&, v1, a1); \
178  \
179  v1.f (idx, a2); \
180  return octave_value (); \
181  }
182 
183 #define CONVDECL(name) \
184  static octave_base_value * \
185  CONCAT2 (oct_conv_, name) (const octave_base_value& a)
186 
187 #define DEFCONV(name, a_dummy, b_dummy) \
188  CONVDECL (name)
189 
190 #define DEFUNOPX(name, t) \
191  static octave_value \
192  CONCAT2 (oct_unop_, name) (const octave_base_value&)
193 
194 #define DEFUNOP(name, t) \
195  static octave_value \
196  CONCAT2 (oct_unop_, name) (const octave_base_value& a)
197 
198 #define DEFUNOP_OP(name, t, op) \
199  static octave_value \
200  CONCAT2 (oct_unop_, name) (const octave_base_value& a) \
201  { \
202  OCTAVE_CAST_BASE_VALUE (const CONCAT2 (octave_, t)&, v, a); \
203  return octave_value (op v.CONCAT2 (t, _value) ()); \
204  }
205 
206 #define DEFNDUNOP_OP(name, t, e, op) \
207  static octave_value \
208  CONCAT2 (oct_unop_, name) (const octave_base_value& a) \
209  { \
210  OCTAVE_CAST_BASE_VALUE (const CONCAT2 (octave_, t)&, v, a); \
211  return octave_value (op v.CONCAT2 (e, _value) ()); \
212  }
213 
214 // FIXME: in some cases, the constructor isn't necessary.
215 
216 #define DEFUNOP_FN(name, t, f) \
217  static octave_value \
218  CONCAT2 (oct_unop_, name) (const octave_base_value& a) \
219  { \
220  OCTAVE_CAST_BASE_VALUE (const CONCAT2 (octave_, t)&, v, a); \
221  return octave_value (f (v.CONCAT2 (t, _value) ())); \
222  }
223 
224 #define DEFNDUNOP_FN(name, t, e, f) \
225  static octave_value \
226  CONCAT2 (oct_unop_, name) (const octave_base_value& a) \
227  { \
228  OCTAVE_CAST_BASE_VALUE (const CONCAT2 (octave_, t)&, v, a); \
229  return octave_value (f (v.CONCAT2 (e, _value) ())); \
230  }
231 
232 #define DEFNCUNOP_METHOD(name, t, method) \
233  static void \
234  CONCAT2 (oct_unop_, name) (octave_base_value& a) \
235  { \
236  OCTAVE_CAST_BASE_VALUE (CONCAT2 (octave_, t)&, v, a); \
237  v.method (); \
238  }
239 
240 #define DEFBINOPX(name, t1, t2) \
241  static octave_value \
242  CONCAT2 (oct_binop_, name) (const octave_base_value&, \
243  const octave_base_value&)
244 
245 #define DEFBINOP(name, t1, t2) \
246  static octave_value \
247  CONCAT2 (oct_binop_, name) (const octave_base_value& a1, \
248  const octave_base_value& a2)
249 
250 #define DEFBINOP_OP(name, t1, t2, op) \
251  static octave_value \
252  CONCAT2 (oct_binop_, name) (const octave_base_value& a1, \
253  const octave_base_value& a2) \
254  { \
255  OCTAVE_CAST_BASE_VALUE (const CONCAT2 (octave_, t1)&, v1, a1); \
256  OCTAVE_CAST_BASE_VALUE (const CONCAT2 (octave_, t2)&, v2, a2); \
257  \
258  return octave_value \
259  (v1.CONCAT2 (t1, _value) () op v2.CONCAT2 (t2, _value) ()); \
260  }
261 
262 #define DEFCMPLXCMPOP_OP(name, t1, t2, op) \
263  static octave_value \
264  CONCAT2 (oct_binop_, name) (const octave_base_value& a1, \
265  const octave_base_value& a2) \
266  { \
267  OCTAVE_CAST_BASE_VALUE (const CONCAT2 (octave_, t1)&, v1, a1); \
268  OCTAVE_CAST_BASE_VALUE (const CONCAT2 (octave_, t2)&, v2, a2); \
269  \
270  warn_complex_cmp (); \
271  \
272  return octave_value \
273  (v1.CONCAT2 (t1, _value) () op v2.CONCAT2 (t2, _value) ()); \
274  }
275 
276 #define DEFSCALARBOOLOP_OP(name, t1, t2, op) \
277  static octave_value \
278  CONCAT2 (oct_binop_, name) (const octave_base_value& a1, \
279  const octave_base_value& a2) \
280  { \
281  OCTAVE_CAST_BASE_VALUE (const CONCAT2 (octave_, t1)&, v1, a1); \
282  OCTAVE_CAST_BASE_VALUE (const CONCAT2 (octave_, t2)&, v2, a2); \
283  \
284  if (octave::math::isnan (v1.CONCAT2 (t1, _value) ()) || octave::math::isnan (v2.CONCAT2 (t2, _value) ())) \
285  octave::err_nan_to_logical_conversion (); \
286  \
287  return octave_value \
288  (v1.CONCAT2 (t1, _value) () op v2.CONCAT2 (t2, _value) ()); \
289  }
290 
291 #define DEFNDBINOP_OP(name, t1, t2, e1, e2, op) \
292  static octave_value \
293  CONCAT2 (oct_binop_, name) (const octave_base_value& a1, \
294  const octave_base_value& a2) \
295  { \
296  OCTAVE_CAST_BASE_VALUE (const CONCAT2 (octave_, t1)&, v1, a1); \
297  OCTAVE_CAST_BASE_VALUE (const CONCAT2 (octave_, t2)&, v2, a2); \
298  \
299  return octave_value \
300  (v1.CONCAT2 (e1, _value) () op v2.CONCAT2 (e2, _value) ()); \
301  }
302 
303 // FIXME: in some cases, the constructor isn't necessary.
304 
305 #define DEFBINOP_FN(name, t1, t2, f) \
306  static octave_value \
307  CONCAT2 (oct_binop_, name) (const octave_base_value& a1, \
308  const octave_base_value& a2) \
309  { \
310  OCTAVE_CAST_BASE_VALUE (const CONCAT2 (octave_, t1)&, v1, a1); \
311  OCTAVE_CAST_BASE_VALUE (const CONCAT2 (octave_, t2)&, v2, a2); \
312  \
313  return octave_value (f (v1.CONCAT2 (t1, _value) (), v2.CONCAT2 (t2, _value) ())); \
314  }
315 
316 #define DEFNDBINOP_FN(name, t1, t2, e1, e2, f) \
317  static octave_value \
318  CONCAT2 (oct_binop_, name) (const octave_base_value& a1, \
319  const octave_base_value& a2) \
320  { \
321  OCTAVE_CAST_BASE_VALUE (const CONCAT2 (octave_, t1)&, v1, a1); \
322  OCTAVE_CAST_BASE_VALUE (const CONCAT2 (octave_, t2)&, v2, a2); \
323  \
324  return octave_value (f (v1.CONCAT2 (e1, _value) (), v2.CONCAT2 (e2, _value) ())); \
325  }
326 
327 #define DEFNDCMPLXCMPOP_FN(name, t1, t2, e1, e2, f) \
328  static octave_value \
329  CONCAT2 (oct_binop_, name) (const octave_base_value& a1, \
330  const octave_base_value& a2) \
331  { \
332  OCTAVE_CAST_BASE_VALUE (const CONCAT2 (octave_, t1)&, v1, a1); \
333  OCTAVE_CAST_BASE_VALUE (const CONCAT2 (octave_, t2)&, v2, a2); \
334  \
335  return octave_value (f (v1.CONCAT2 (e1, _value) (), v2.CONCAT2 (e2, _value) ())); \
336  }
337 
338 #define DEFCATOPX(name, t1, t2) \
339  static octave_value \
340  CONCAT2 (oct_catop_, name) (const octave_base_value&, \
341  const octave_base_value&, \
342  const Array<octave_idx_type>& ra_idx)
343 
344 #define DEFCATOP(name, t1, t2) \
345  static octave_value \
346  CONCAT2 (oct_catop_, name) (const octave_base_value& a1, \
347  const octave_base_value& a2, \
348  const Array<octave_idx_type>& ra_idx)
349 
350 // FIXME: in some cases, the constructor isn't necessary.
351 
352 #define DEFCATOP_FN(name, t1, t2, f) \
353  static octave_value \
354  CONCAT2 (oct_catop_, name) (const octave_base_value& a1, \
355  const octave_base_value& a2, \
356  const Array<octave_idx_type>& ra_idx) \
357  { \
358  OCTAVE_CAST_BASE_VALUE (const CONCAT2 (octave_, t1)&, v1, a1); \
359  OCTAVE_CAST_BASE_VALUE (const CONCAT2 (octave_, t2)&, v2, a2); \
360  \
361  return octave_value (v1.CONCAT2 (t1, _value) () . f (v2.CONCAT2 (t2, _value) (), ra_idx)); \
362  }
363 
364 #define DEFNDCATOP_FN(name, t1, t2, e1, e2, f) \
365  static octave_value \
366  CONCAT2 (oct_catop_, name) (const octave_base_value& a1, \
367  const octave_base_value& a2, \
368  const Array<octave_idx_type>& ra_idx) \
369  { \
370  OCTAVE_CAST_BASE_VALUE (const CONCAT2 (octave_, t1)&, v1, a1); \
371  OCTAVE_CAST_BASE_VALUE (const CONCAT2 (octave_, t2)&, v2, a2); \
372  \
373  return octave_value (v1.CONCAT2 (e1, _value) () . f (v2.CONCAT2 (e2, _value) (), ra_idx)); \
374  }
375 
376 #define DEFNDCHARCATOP_FN(name, t1, t2, f) \
377  static octave_value \
378  CONCAT2 (oct_catop_, name) (const octave_base_value& a1, \
379  const octave_base_value& a2, \
380  const Array<octave_idx_type>& ra_idx) \
381  { \
382  OCTAVE_CAST_BASE_VALUE (const CONCAT2 (octave_, t1)&, v1, a1); \
383  OCTAVE_CAST_BASE_VALUE (const CONCAT2 (octave_, t2)&, v2, a2); \
384  \
385  return octave_value (v1.char_array_value () . f (v2.char_array_value (), ra_idx), \
386  ((a1.is_sq_string () || a2.is_sq_string ()) \
387  ? '\'' : '"')); \
388  }
389 
390 // For compatibility, the second arg is always converted to the type
391 // of the first. Hmm.
392 
393 #define DEFNDCATOP_FN2(name, t1, t2, tc1, tc2, e1, e2, f) \
394  static octave_value \
395  CONCAT2 (oct_catop_, name) (const octave_base_value& a1, \
396  const octave_base_value& a2, \
397  const Array<octave_idx_type>& ra_idx) \
398  { \
399  OCTAVE_CAST_BASE_VALUE (const CONCAT2 (octave_, t1)&, v1, a1); \
400  OCTAVE_CAST_BASE_VALUE (const CONCAT2 (octave_, t2)&, v2, a2); \
401  \
402  return octave_value (tc1 (v1.CONCAT2 (e1, _value) ()) . f (tc2 (v2.CONCAT2 (e2, _value) ()), ra_idx)); \
403  }
404 
405 #endif
type_info
Definition: ov-typeinfo.h:45
OCTAVE_BEGIN_NAMESPACE
OCTAVE_BEGIN_NAMESPACE(octave) static octave_value daspk_fcn