GNU Octave  4.2.1
A high-level interpreted language, primarily intended for numerical computations, mostly compatible with Matlab
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
op-int.h
Go to the documentation of this file.
1 /*
2 
3 Copyright (C) 1996-2017 John W. Eaton
4 
5 This file is part of Octave.
6 
7 Octave is free software; you can redistribute it and/or modify it
8 under the terms of the GNU General Public License as published by the
9 Free Software Foundation; either version 3 of the License, or (at your
10 option) any later version.
11 
12 Octave is distributed in the hope that it will be useful, but WITHOUT
13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15 for more details.
16 
17 You should have received a copy of the GNU General Public License
18 along with Octave; see the file COPYING. If not, see
19 <http://www.gnu.org/licenses/>.
20 
21 */
22 
23 #if ! defined (octave_op_int_h)
24 #define octave_op_int_h 1
25 
26 #include "octave-config.h"
27 
28 #include "quit.h"
29 #include "bsxfun.h"
30 
31 #define DEFINTBINOP_OP(name, t1, t2, op, t3) \
32  static octave_value \
33  CONCAT2 (oct_binop_, name) (const octave_base_value& a1, \
34  const octave_base_value& a2) \
35  { \
36  const octave_ ## t1& v1 = dynamic_cast<const octave_ ## t1&> (a1); \
37  const octave_ ## t2& v2 = dynamic_cast<const octave_ ## t2&> (a2); \
38  octave_value retval = octave_value \
39  (v1.t1 ## _value () op v2.t2 ## _value ()); \
40  return retval; \
41  }
42 
43 #define DEFINTNDBINOP_OP(name, t1, t2, e1, e2, op, t3) \
44  static octave_value \
45  CONCAT2 (oct_binop_, name) (const octave_base_value& a1, \
46  const octave_base_value& a2) \
47  { \
48  const octave_ ## t1& v1 = dynamic_cast<const octave_ ## t1&> (a1); \
49  const octave_ ## t2& v2 = dynamic_cast<const octave_ ## t2&> (a2); \
50  octave_value retval = octave_value \
51  (v1.e1 ## _value () op v2.e2 ## _value ()); \
52  return retval; \
53  }
54 
55 #define DEFINTBINOP_FN(name, t1, t2, f, t3, op) \
56  static octave_value \
57  CONCAT2 (oct_binop_, name) (const octave_base_value& a1, \
58  const octave_base_value& a2) \
59  { \
60  const octave_ ## t1& v1 = dynamic_cast<const octave_ ## t1&> (a1); \
61  const octave_ ## t2& v2 = dynamic_cast<const octave_ ## t2&> (a2); \
62  octave_value retval = octave_value (f (v1.t1 ## _value (), v2.t2 ## _value ())); \
63  return retval; \
64  }
65 
66 #define DEFINTNDBINOP_FN(name, t1, t2, e1, e2, f, t3, op) \
67  static octave_value \
68  CONCAT2 (oct_binop_, name) (const octave_base_value& a1, \
69  const octave_base_value& a2) \
70  { \
71  const octave_ ## t1& v1 = dynamic_cast<const octave_ ## t1&> (a1); \
72  const octave_ ## t2& v2 = dynamic_cast<const octave_ ## t2&> (a2); \
73  octave_value retval = octave_value (f (v1.e1 ## _value (), v2.e2 ## _value ())); \
74  return retval; \
75  }
76 
77 #define OCTAVE_CONCAT_FN2(T1, T2) \
78  DEFNDCATOP_FN2 (T1 ## _ ## T2 ## _s_s, T1 ## _scalar, T2 ## _scalar, , T1 ## NDArray, T1 ## _array, T2 ## _array, concat) \
79  DEFNDCATOP_FN2 (T1 ## _ ## T2 ## _s_m, T1 ## _scalar, T2 ## _matrix, , T1 ## NDArray, T1 ## _array, T2 ## _array, concat) \
80  DEFNDCATOP_FN2 (T1 ## _ ## T2 ## _m_s, T1 ## _matrix, T2 ## _scalar, , T1 ## NDArray, T1 ## _array, T2 ## _array, concat) \
81  DEFNDCATOP_FN2 (T1 ## _ ## T2 ## _m_m, T1 ## _matrix, T2 ## _matrix, , T1 ## NDArray, T1 ## _array, T2 ## _array, concat)
82 
83 #define OCTAVE_INSTALL_CONCAT_FN2(T1, T2) \
84  INSTALL_CATOP (octave_ ## T1 ## _scalar, octave_ ## T2 ## _scalar, T1 ## _ ## T2 ## _s_s) \
85  INSTALL_CATOP (octave_ ## T1 ## _scalar, octave_ ## T2 ## _matrix, T1 ## _ ## T2 ## _s_m) \
86  INSTALL_CATOP (octave_ ## T1 ## _matrix, octave_ ## T2 ## _scalar, T1 ## _ ## T2 ## _m_s) \
87  INSTALL_CATOP (octave_ ## T1 ## _matrix, octave_ ## T2 ## _matrix, T1 ## _ ## T2 ## _m_m)
88 
89 #define OCTAVE_DOUBLE_INT_CONCAT_FN(TYPE) \
90  DEFNDCATOP_FN2 (double ## _ ## TYPE ## _s_s, scalar, TYPE ## _scalar, TYPE ## NDArray, , array, TYPE ## _array, concat) \
91  DEFNDCATOP_FN2 (double ## _ ## TYPE ## _s_m, scalar, TYPE ## _matrix, TYPE ## NDArray, , array, TYPE ## _array, concat) \
92  DEFNDCATOP_FN2 (double ## _ ## TYPE ## _m_s, matrix, TYPE ## _scalar, TYPE ## NDArray, , array, TYPE ## _array, concat) \
93  DEFNDCATOP_FN2 (double ## _ ## TYPE ## _m_m, matrix, TYPE ## _matrix, TYPE ## NDArray, , array, TYPE ## _array, concat)
94 
95 #define OCTAVE_INSTALL_DOUBLE_INT_CONCAT_FN(TYPE) \
96  INSTALL_CATOP (octave_scalar, octave_ ## TYPE ## _scalar, double ## _ ## TYPE ## _s_s) \
97  INSTALL_CATOP (octave_scalar, octave_ ## TYPE ## _matrix, double ## _ ## TYPE ## _s_m) \
98  INSTALL_CATOP (octave_matrix, octave_ ## TYPE ## _scalar, double ## _ ## TYPE ## _m_s) \
99  INSTALL_CATOP (octave_matrix, octave_ ## TYPE ## _matrix, double ## _ ## TYPE ## _m_m)
100 
101 #define OCTAVE_INT_DOUBLE_CONCAT_FN(TYPE) \
102  DEFNDCATOP_FN2 (TYPE ## _ ## double ## _s_s, TYPE ## _scalar, scalar, , TYPE ## NDArray, TYPE ## _array, array, concat) \
103  DEFNDCATOP_FN2 (TYPE ## _ ## double ## _s_m, TYPE ## _scalar, matrix, , TYPE ## NDArray, TYPE ## _array, array, concat) \
104  DEFNDCATOP_FN2 (TYPE ## _ ## double ## _m_s, TYPE ## _matrix, scalar, , TYPE ## NDArray, TYPE ## _array, array, concat) \
105  DEFNDCATOP_FN2 (TYPE ## _ ## double ## _m_m, TYPE ## _matrix, matrix, , TYPE ## NDArray, TYPE ## _array, array, concat)
106 
107 #define OCTAVE_INSTALL_INT_DOUBLE_CONCAT_FN(TYPE) \
108  INSTALL_CATOP (octave_ ## TYPE ## _scalar, octave_scalar, TYPE ## _ ## double ## _s_s) \
109  INSTALL_CATOP (octave_ ## TYPE ## _scalar, octave_matrix, TYPE ## _ ## double ## _s_m) \
110  INSTALL_CATOP (octave_ ## TYPE ## _matrix, octave_scalar, TYPE ## _ ## double ## _m_s) \
111  INSTALL_CATOP (octave_ ## TYPE ## _matrix, octave_matrix, TYPE ## _ ## double ## _m_m)
112 
113 #define OCTAVE_FLOAT_INT_CONCAT_FN(TYPE) \
114  DEFNDCATOP_FN2 (float ## _ ## TYPE ## _s_s, float_scalar, TYPE ## _scalar, TYPE ## NDArray, , float_array, TYPE ## _array, concat) \
115  DEFNDCATOP_FN2 (float ## _ ## TYPE ## _s_m, float_scalar, TYPE ## _matrix, TYPE ## NDArray, , float_array, TYPE ## _array, concat) \
116  DEFNDCATOP_FN2 (float ## _ ## TYPE ## _m_s, float_matrix, TYPE ## _scalar, TYPE ## NDArray, , float_array, TYPE ## _array, concat) \
117  DEFNDCATOP_FN2 (float ## _ ## TYPE ## _m_m, float_matrix, TYPE ## _matrix, TYPE ## NDArray, , float_array, TYPE ## _array, concat)
118 
119 #define OCTAVE_INSTALL_FLOAT_INT_CONCAT_FN(TYPE) \
120  INSTALL_CATOP (octave_float_scalar, octave_ ## TYPE ## _scalar, float ## _ ## TYPE ## _s_s) \
121  INSTALL_CATOP (octave_float_scalar, octave_ ## TYPE ## _matrix, float ## _ ## TYPE ## _s_m) \
122  INSTALL_CATOP (octave_float_matrix, octave_ ## TYPE ## _scalar, float ## _ ## TYPE ## _m_s) \
123  INSTALL_CATOP (octave_float_matrix, octave_ ## TYPE ## _matrix, float ## _ ## TYPE ## _m_m)
124 
125 #define OCTAVE_INT_FLOAT_CONCAT_FN(TYPE) \
126  DEFNDCATOP_FN2 (TYPE ## _ ## float ## _s_s, TYPE ## _scalar, float_scalar, , TYPE ## NDArray, TYPE ## _array, float_array, concat) \
127  DEFNDCATOP_FN2 (TYPE ## _ ## float ## _s_m, TYPE ## _scalar, float_matrix, , TYPE ## NDArray, TYPE ## _array, float_array, concat) \
128  DEFNDCATOP_FN2 (TYPE ## _ ## float ## _m_s, TYPE ## _matrix, float_scalar, , TYPE ## NDArray, TYPE ## _array, float_array, concat) \
129  DEFNDCATOP_FN2 (TYPE ## _ ## float ## _m_m, TYPE ## _matrix, float_matrix, , TYPE ## NDArray, TYPE ## _array, float_array, concat)
130 
131 #define OCTAVE_INSTALL_INT_FLOAT_CONCAT_FN(TYPE) \
132  INSTALL_CATOP (octave_ ## TYPE ## _scalar, octave_float_scalar, TYPE ## _ ## float ## _s_s) \
133  INSTALL_CATOP (octave_ ## TYPE ## _scalar, octave_float_matrix, TYPE ## _ ## float ## _s_m) \
134  INSTALL_CATOP (octave_ ## TYPE ## _matrix, octave_float_scalar, TYPE ## _ ## float ## _m_s) \
135  INSTALL_CATOP (octave_ ## TYPE ## _matrix, octave_float_matrix, TYPE ## _ ## float ## _m_m)
136 
137 // For compatibility, concatenation with a character always returns a
138 // character.
139 
140 #define OCTAVE_CHAR_INT_CONCAT_FN(TYPE) \
141  DEFNDCHARCATOP_FN (char ## _ ## TYPE ## _m_s, char_matrix, TYPE ## _scalar, concat) \
142  DEFNDCHARCATOP_FN (char ## _ ## TYPE ## _m_m, char_matrix, TYPE ## _matrix, concat)
143 
144 #define OCTAVE_INSTALL_CHAR_INT_CONCAT_FN(TYPE) \
145  INSTALL_CATOP (octave_char_matrix_str, octave_ ## TYPE ## _scalar, char ## _ ## TYPE ## _m_s) \
146  INSTALL_CATOP (octave_char_matrix_str, octave_ ## TYPE ## _matrix, char ## _ ## TYPE ## _m_m) \
147  INSTALL_CATOP (octave_char_matrix_sq_str, octave_ ## TYPE ## _scalar, char ## _ ## TYPE ## _m_s) \
148  INSTALL_CATOP (octave_char_matrix_sq_str, octave_ ## TYPE ## _matrix, char ## _ ## TYPE ## _m_m)
149 
150 #define OCTAVE_INT_CHAR_CONCAT_FN(TYPE) \
151  DEFNDCHARCATOP_FN (TYPE ## _ ## char ## _s_m, TYPE ## _scalar, char_matrix, concat) \
152  DEFNDCHARCATOP_FN (TYPE ## _ ## char ## _m_m, TYPE ## _matrix, char_matrix, concat)
153 
154 #define OCTAVE_INSTALL_INT_CHAR_CONCAT_FN(TYPE) \
155  INSTALL_CATOP (octave_ ## TYPE ## _scalar, octave_char_matrix_str, TYPE ## _ ## char ## _s_m) \
156  INSTALL_CATOP (octave_ ## TYPE ## _matrix, octave_char_matrix_str, TYPE ## _ ## char ## _m_m) \
157  INSTALL_CATOP (octave_ ## TYPE ## _scalar, octave_char_matrix_sq_str, TYPE ## _ ## char ## _s_m) \
158  INSTALL_CATOP (octave_ ## TYPE ## _matrix, octave_char_matrix_sq_str, TYPE ## _ ## char ## _m_m)
159 
160 #define OCTAVE_CONCAT_FN(TYPE) \
161  DEFNDCATOP_FN (TYPE ## _s_s, TYPE ## _scalar, TYPE ## _scalar, TYPE ## _array, TYPE ## _array, concat) \
162  DEFNDCATOP_FN (TYPE ## _s_m, TYPE ## _scalar, TYPE ## _matrix, TYPE ## _array, TYPE ## _array, concat) \
163  DEFNDCATOP_FN (TYPE ## _m_s, TYPE ## _matrix, TYPE ## _scalar, TYPE ## _array, TYPE ## _array, concat) \
164  DEFNDCATOP_FN (TYPE ## _m_m, TYPE ## _matrix, TYPE ## _matrix, TYPE ## _array, TYPE ## _array, concat)
165 
166 #define OCTAVE_INSTALL_CONCAT_FN(TYPE) \
167  INSTALL_CATOP (octave_ ## TYPE ## _scalar, octave_ ## TYPE ## _scalar, TYPE ## _s_s) \
168  INSTALL_CATOP (octave_ ## TYPE ## _scalar, octave_ ## TYPE ## _matrix, TYPE ## _s_m) \
169  INSTALL_CATOP (octave_ ## TYPE ## _matrix, octave_ ## TYPE ## _scalar, TYPE ## _m_s) \
170  INSTALL_CATOP (octave_ ## TYPE ## _matrix, octave_ ## TYPE ## _matrix, TYPE ## _m_m)
171 
172 // scalar unary ops.
173 #define OCTAVE_S_INT_UNOPS(TYPE) \
174  \
175  DEFUNOP_OP (s_not, TYPE ## _scalar, !) \
176  DEFUNOP_OP (s_uplus, TYPE ## _scalar, /* no-op */) \
177  DEFUNOP (s_uminus, TYPE ## _scalar) \
178  { \
179  const octave_ ## TYPE ## _scalar & v = dynamic_cast<const octave_ ## TYPE ## _scalar &> (a); \
180  octave_value retval = octave_value (- v. TYPE ## _scalar_value ()); \
181  return retval; \
182  } \
183  DEFUNOP_OP (s_transpose, TYPE ## _scalar, /* no-op */) \
184  DEFUNOP_OP (s_hermitian, TYPE ## _scalar, /* no-op */) \
185  \
186  DEFNCUNOP_METHOD (s_incr, TYPE ## _scalar, increment) \
187  DEFNCUNOP_METHOD (s_decr, TYPE ## _scalar, decrement)
188 
189 // scalar by scalar ops.
190 #define OCTAVE_SS_INT_ARITH_OPS(PFX, T1, T2, T3) \
191  \
192  DEFINTBINOP_OP (PFX ## _add, T1 ## scalar, T2 ## scalar, +, T3) \
193  DEFINTBINOP_OP (PFX ## _sub, T1 ## scalar, T2 ## scalar, -, T3) \
194  DEFINTBINOP_OP (PFX ## _mul, T1 ## scalar, T2 ## scalar, *, T3) \
195  \
196  DEFBINOP (PFX ## _div, T1 ## scalar, T2 ## scalar) \
197  { \
198  const octave_ ## T1 ## scalar& v1 = dynamic_cast<const octave_ ## T1 ## scalar&> (a1); \
199  const octave_ ## T2 ## scalar& v2 = dynamic_cast<const octave_ ## T2 ## scalar&> (a2); \
200  \
201  if (! v2.T2 ## scalar_value ()) \
202  warn_divide_by_zero (); \
203  \
204  octave_value retval = octave_value (v1.T1 ## scalar_value () / v2.T2 ## scalar_value ()); \
205  return retval; \
206  } \
207  \
208  DEFINTBINOP_FN (PFX ## _pow, T1 ## scalar, T2 ## scalar, xpow, T3, ^) \
209  \
210  DEFBINOP (PFX ## _ldiv, T1 ## scalar, T2 ## scalar) \
211  { \
212  const octave_ ## T1 ## scalar& v1 = dynamic_cast<const octave_ ## T1 ## scalar&> (a1); \
213  const octave_ ## T2 ## scalar& v2 = dynamic_cast<const octave_ ## T2 ## scalar&> (a2); \
214  \
215  if (! v1.T1 ## scalar_value ()) \
216  warn_divide_by_zero (); \
217  \
218  octave_value retval = octave_value (v2.T2 ## scalar_value () / v1.T1 ## scalar_value ()); \
219  return retval; \
220  } \
221  \
222  DEFINTBINOP_OP (PFX ## _el_mul, T1 ## scalar, T2 ## scalar, *, T3) \
223  \
224  DEFBINOP (PFX ## _el_div, T1 ## scalar, T2 ## scalar) \
225  { \
226  const octave_ ## T1 ## scalar& v1 = dynamic_cast<const octave_ ## T1 ## scalar&> (a1); \
227  const octave_ ## T2 ## scalar& v2 = dynamic_cast<const octave_ ## T2 ## scalar&> (a2); \
228  \
229  if (! v2.T2 ## scalar_value ()) \
230  warn_divide_by_zero (); \
231  \
232  octave_value retval = octave_value (v1.T1 ## scalar_value () / v2.T2 ## scalar_value ()); \
233  return retval; \
234  } \
235  \
236  DEFINTBINOP_FN (PFX ## _el_pow, T1 ## scalar, T2 ## scalar, xpow, T3, .^) \
237  \
238  DEFBINOP (PFX ## _el_ldiv, T1 ## scalar, T2 ## scalar) \
239  { \
240  const octave_ ## T1 ## scalar& v1 = dynamic_cast<const octave_ ## T1 ## scalar&> (a1); \
241  const octave_ ## T2 ## scalar& v2 = dynamic_cast<const octave_ ## T2 ## scalar&> (a2); \
242  \
243  if (! v1.T1 ## scalar_value ()) \
244  warn_divide_by_zero (); \
245  \
246  octave_value retval = octave_value (v2.T2 ## scalar_value () / v1.T1 ## scalar_value ()); \
247  return retval; \
248  }
249 
250 #define OCTAVE_SS_INT_BOOL_OPS(PFX, T1, T2, Z1, Z2) \
251  DEFBINOP (PFX ## _el_and, T2, T2) \
252  { \
253  const octave_ ## T1 ## scalar& v1 = dynamic_cast<const octave_ ## T1 ## scalar&> (a1); \
254  const octave_ ## T2 ## scalar& v2 = dynamic_cast<const octave_ ## T2 ## scalar&> (a2); \
255  \
256  return v1.T1 ## scalar_value () != Z1 && v2.T2 ## scalar_value () != Z2; \
257  } \
258  \
259  DEFBINOP (PFX ## _el_or, T1, T2) \
260  { \
261  const octave_ ## T1 ## scalar& v1 = dynamic_cast<const octave_ ## T1 ## scalar&> (a1); \
262  const octave_ ## T2 ## scalar& v2 = dynamic_cast<const octave_ ## T2 ## scalar&> (a2); \
263  \
264  return v1.T1 ## scalar_value () != Z1 || v2.T2 ## scalar_value () != Z2; \
265  }
266 
267 #define OCTAVE_SS_INT_CMP_OPS(PFX, T1, T2) \
268  DEFBINOP_OP (PFX ## _lt, T1 ## scalar, T2 ## scalar, <) \
269  DEFBINOP_OP (PFX ## _le, T1 ## scalar, T2 ## scalar, <=) \
270  DEFBINOP_OP (PFX ## _eq, T1 ## scalar, T2 ## scalar, ==) \
271  DEFBINOP_OP (PFX ## _ge, T1 ## scalar, T2 ## scalar, >=) \
272  DEFBINOP_OP (PFX ## _gt, T1 ## scalar, T2 ## scalar, >) \
273  DEFBINOP_OP (PFX ## _ne, T1 ## scalar, T2 ## scalar, !=)
274 
275 #define OCTAVE_SS_POW_OPS(T1, T2) \
276  octave_value \
277  xpow (const octave_ ## T1& a, const octave_ ## T2& b) \
278  { \
279  return pow (a, b); \
280  } \
281  \
282  octave_value \
283  xpow (const octave_ ## T1& a, double b) \
284  { \
285  return pow (a, b); \
286  } \
287  \
288  octave_value \
289  xpow (double a, const octave_ ## T1& b) \
290  { \
291  return pow (a, b); \
292  } \
293  \
294  octave_value \
295  xpow (const octave_ ## T1& a, float b) \
296  { \
297  return powf (a, b); \
298  } \
299  \
300  octave_value \
301  xpow (float a, const octave_ ## T1& b) \
302  { \
303  return powf (a, b); \
304  }
305 
306 #define OCTAVE_SS_INT_OPS(TYPE) \
307  OCTAVE_S_INT_UNOPS (TYPE) \
308  OCTAVE_SS_POW_OPS (TYPE, TYPE) \
309  OCTAVE_SS_INT_ARITH_OPS (ss, TYPE ## _, TYPE ## _, TYPE) \
310  OCTAVE_SS_INT_ARITH_OPS (ssx, TYPE ## _, , TYPE) \
311  OCTAVE_SS_INT_ARITH_OPS (sxs, , TYPE ## _, TYPE) \
312  OCTAVE_SS_INT_ARITH_OPS (ssfx, TYPE ## _, float_, TYPE) \
313  OCTAVE_SS_INT_ARITH_OPS (sfxs, float_, TYPE ## _, TYPE) \
314  OCTAVE_SS_INT_CMP_OPS (ss, TYPE ## _, TYPE ## _) \
315  OCTAVE_SS_INT_CMP_OPS (sx, TYPE ## _, ) \
316  OCTAVE_SS_INT_CMP_OPS (xs, , TYPE ## _) \
317  OCTAVE_SS_INT_CMP_OPS (sfx, TYPE ## _, float_) \
318  OCTAVE_SS_INT_CMP_OPS (fxs, float_, TYPE ## _) \
319  OCTAVE_SS_INT_BOOL_OPS (ss, TYPE ## _, TYPE ## _, octave_ ## TYPE (0), octave_ ## TYPE (0)) \
320  OCTAVE_SS_INT_BOOL_OPS (sx, TYPE ## _, , octave_ ## TYPE (0), 0) \
321  OCTAVE_SS_INT_BOOL_OPS (xs, , TYPE ## _, 0, octave_ ## TYPE (0)) \
322  OCTAVE_SS_INT_BOOL_OPS (sfx, TYPE ## _, float_, octave_ ## TYPE (0), 0) \
323  OCTAVE_SS_INT_BOOL_OPS (fxs, float_, TYPE ## _, 0, octave_ ## TYPE (0))
324 
325 // scalar by matrix ops.
326 #define OCTAVE_SM_INT_ARITH_OPS(PFX, TS, TM, TI) \
327  \
328  DEFINTNDBINOP_OP (PFX ## _add, TS ## scalar, TM ## matrix, TS ## scalar, TM ## array, +, TI) \
329  DEFINTNDBINOP_OP (PFX ## _sub, TS ## scalar, TM ## matrix, TS ## scalar, TM ## array, -, TI) \
330  DEFINTNDBINOP_OP (PFX ## _mul, TS ## scalar, TM ## matrix, TS ## scalar, TM ## array, *, TI) \
331  \
332  /* DEFBINOP (PFX ## _div, TS ## scalar, TM ## matrix) */ \
333  /* { */ \
334  /* const octave_ ## TS ## scalar& v1 = dynamic_cast<const octave_ ## TS ## scalar&> (a1); */ \
335  /* const octave_ ## TM ## matrix& v2 = dynamic_cast<const octave_ ## TM ## matrix&> (a2); */ \
336  /* */ \
337  /* Matrix m1 = v1.TM ## matrix_value (); */ \
338  /* Matrix m2 = v2.TM ## matrix_value (); */ \
339  /* */ \
340  /* return octave_value (xdiv (m1, m2)); */ \
341  /* } */ \
342  \
343  /* DEFBINOP_FN (PFX ## _pow, TS ## scalar, TM ## matrix, xpow) */ \
344  \
345  DEFBINOP (PFX ## _ldiv, TS ## scalar, TM ## matrix) \
346  { \
347  const octave_ ## TS ## scalar& v1 = dynamic_cast<const octave_ ## TS ## scalar&> (a1); \
348  const octave_ ## TM ## matrix& v2 = dynamic_cast<const octave_ ## TM ## matrix&> (a2); \
349  \
350  if (! v1.TS ## scalar_value ()) \
351  warn_divide_by_zero (); \
352  \
353  octave_value retval = octave_value (v2.TS ## scalar_value () / v1.TS ## scalar_value ()); \
354  return retval; \
355  } \
356  \
357  DEFINTNDBINOP_OP (PFX ## _el_mul, TS ## scalar, TM ## matrix, TS ## scalar, TM ## array, *, TI) \
358  DEFBINOP (PFX ## _el_div, TS ## scalar, TM ## matrix) \
359  { \
360  const octave_ ## TS ## scalar& v1 = dynamic_cast<const octave_ ## TS ## scalar&> (a1); \
361  const octave_ ## TM ## matrix& v2 = dynamic_cast<const octave_ ## TM ## matrix&> (a2); \
362  \
363  octave_value retval = octave_value (v1.TS ## scalar_value () / v2.TM ## array_value ()); \
364  return retval; \
365  } \
366  \
367  DEFINTNDBINOP_FN (PFX ## _el_pow, TS ## scalar, TM ## matrix, TS ## scalar, TM ## array, elem_xpow, TI, .^) \
368  \
369  DEFBINOP (PFX ## _el_ldiv, TS ## scalar, TM ## matrix) \
370  { \
371  const octave_ ## TS ## scalar& v1 = dynamic_cast<const octave_ ## TS ## scalar&> (a1); \
372  const octave_ ## TM ## matrix& v2 = dynamic_cast<const octave_ ## TM ## matrix&> (a2); \
373  \
374  if (! v1.TS ## scalar_value ()) \
375  warn_divide_by_zero (); \
376  \
377  octave_value retval = octave_value (v2.TM ## array_value () / v1.TS ## scalar_value ()); \
378  return retval; \
379  }
380 
381 #define OCTAVE_SM_INT_CMP_OPS(PFX, TS, TM) \
382  DEFNDBINOP_FN (PFX ## _lt, TS ## scalar, TM ## matrix, TS ## scalar, TM ## array, mx_el_lt) \
383  DEFNDBINOP_FN (PFX ## _le, TS ## scalar, TM ## matrix, TS ## scalar, TM ## array, mx_el_le) \
384  DEFNDBINOP_FN (PFX ## _eq, TS ## scalar, TM ## matrix, TS ## scalar, TM ## array, mx_el_eq) \
385  DEFNDBINOP_FN (PFX ## _ge, TS ## scalar, TM ## matrix, TS ## scalar, TM ## array, mx_el_ge) \
386  DEFNDBINOP_FN (PFX ## _gt, TS ## scalar, TM ## matrix, TS ## scalar, TM ## array, mx_el_gt) \
387  DEFNDBINOP_FN (PFX ## _ne, TS ## scalar, TM ## matrix, TS ## scalar, TM ## array, mx_el_ne)
388 
389 #define OCTAVE_SM_INT_BOOL_OPS(PFX, TS, TM) \
390  DEFNDBINOP_FN (PFX ## _el_and, TS ## scalar, TM ## matrix, TS ## scalar, TM ## array, mx_el_and) \
391  DEFNDBINOP_FN (PFX ## _el_or, TS ## scalar, TM ## matrix, TS ## scalar, TM ## array, mx_el_or) \
392  DEFNDBINOP_FN (PFX ## _el_and_not, TS ## scalar, TM ## matrix, TS ## scalar, TM ## array, mx_el_and_not) \
393  DEFNDBINOP_FN (PFX ## _el_or_not, TS ## scalar, TM ## matrix, TS ## scalar, TM ## array, mx_el_or_not)
394 
395 #define OCTAVE_SM_POW_OPS(T1, T2) \
396  octave_value \
397  elem_xpow (const octave_ ## T1& a, const T2 ## NDArray& b) \
398  { \
399  T2 ## NDArray result (b.dims ()); \
400  for (int i = 0; i < b.numel (); i++) \
401  { \
402  OCTAVE_QUIT; \
403  result (i) = pow (a, b(i)); \
404  } \
405  return octave_value (result); \
406  } \
407  \
408  octave_value \
409  elem_xpow (const octave_ ## T1& a, const NDArray& b) \
410  { \
411  T1 ## NDArray result (b.dims ()); \
412  for (int i = 0; i < b.numel (); i++) \
413  { \
414  OCTAVE_QUIT; \
415  result (i) = pow (a, b(i)); \
416  } \
417  return octave_value (result); \
418  } \
419  \
420  octave_value \
421  elem_xpow (double a, const T2 ## NDArray& b) \
422  { \
423  T2 ## NDArray result (b.dims ()); \
424  for (int i = 0; i < b.numel (); i++) \
425  { \
426  OCTAVE_QUIT; \
427  result (i) = pow (a, b(i)); \
428  } \
429  return octave_value (result); \
430  } \
431  \
432  octave_value \
433  elem_xpow (const octave_ ## T1& a, const FloatNDArray& b) \
434  { \
435  T1 ## NDArray result (b.dims ()); \
436  for (int i = 0; i < b.numel (); i++) \
437  { \
438  OCTAVE_QUIT; \
439  result (i) = powf (a, b(i)); \
440  } \
441  return octave_value (result); \
442  } \
443  \
444  octave_value \
445  elem_xpow (float a, const T2 ## NDArray& b) \
446  { \
447  T2 ## NDArray result (b.dims ()); \
448  for (int i = 0; i < b.numel (); i++) \
449  { \
450  OCTAVE_QUIT; \
451  result (i) = powf (a, b(i)); \
452  } \
453  return octave_value (result); \
454  }
455 
456 #define OCTAVE_SM_CONV(TS, TM) \
457  DEFCONV (TS ## s_ ## TM ## m_conv, TM ## scalar, TM ## matrix) \
458  { \
459  const octave_ ## TS ## scalar& v = dynamic_cast<const octave_ ## TS ## scalar&> (a); \
460  \
461  return new octave_ ## TM ## matrix (v.TM ## array_value ()); \
462  }
463 
464 #define OCTAVE_SM_INT_OPS(TYPE) \
465  OCTAVE_SM_POW_OPS (TYPE, TYPE) \
466  OCTAVE_SM_INT_ARITH_OPS (sm, TYPE ## _, TYPE ## _, TYPE) \
467  OCTAVE_SM_INT_ARITH_OPS (smx, TYPE ## _, , TYPE) \
468  OCTAVE_SM_INT_ARITH_OPS (sxm, , TYPE ## _, TYPE) \
469  OCTAVE_SM_INT_ARITH_OPS (smfx, TYPE ## _, float_, TYPE) \
470  OCTAVE_SM_INT_ARITH_OPS (sfxm, float_, TYPE ## _, TYPE) \
471  OCTAVE_SM_INT_CMP_OPS (sm, TYPE ## _, TYPE ## _) \
472  OCTAVE_SM_INT_CMP_OPS (xm, , TYPE ## _) \
473  OCTAVE_SM_INT_CMP_OPS (smx, TYPE ## _, ) \
474  OCTAVE_SM_INT_CMP_OPS (fxm, float_, TYPE ## _) \
475  OCTAVE_SM_INT_CMP_OPS (smfx, TYPE ## _, float_) \
476  OCTAVE_SM_INT_BOOL_OPS (sm, TYPE ## _, TYPE ## _) \
477  OCTAVE_SM_INT_BOOL_OPS (xm, , TYPE ## _) \
478  OCTAVE_SM_INT_BOOL_OPS (smx, TYPE ## _, ) \
479  OCTAVE_SM_INT_BOOL_OPS (fxm, float_, TYPE ## _) \
480  OCTAVE_SM_INT_BOOL_OPS (smfx, TYPE ## _, float_) \
481  OCTAVE_SM_CONV (TYPE ## _, TYPE ## _) \
482  OCTAVE_SM_CONV (TYPE ## _, complex_) \
483  OCTAVE_SM_CONV (TYPE ## _, float_complex_)
484 
485 // matrix by scalar ops.
486 #define OCTAVE_MS_INT_ARITH_OPS(PFX, TM, TS, TI) \
487  \
488  DEFINTNDBINOP_OP (PFX ## _add, TM ## matrix, TS ## scalar, TM ## array, TS ## scalar, +, TI) \
489  DEFINTNDBINOP_OP (PFX ## _sub, TM ## matrix, TS ## scalar, TM ## array, TS ## scalar, -, TI) \
490  DEFINTNDBINOP_OP (PFX ## _mul, TM ## matrix, TS ## scalar, TM ## array, TS ## scalar, *, TI) \
491  \
492  DEFBINOP (PFX ## _div, TM ## matrix, TS ## scalar) \
493  { \
494  const octave_ ## TM ## matrix& v1 = dynamic_cast<const octave_ ## TM ## matrix&> (a1); \
495  const octave_ ## TS ## scalar& v2 = dynamic_cast<const octave_ ## TS ## scalar&> (a2); \
496  \
497  if (! v2.TS ## scalar_value ()) \
498  warn_divide_by_zero (); \
499  \
500  octave_value retval = octave_value (v1.TM ## array_value () / v2.TS ## scalar_value ()); \
501  return retval; \
502  } \
503  \
504  /* DEFBINOP_FN (PFX ## _pow, TM ## matrix, TS ## scalar, xpow) */ \
505  \
506  /* DEFBINOP (PFX ## _ldiv, TM ## matrix, TS ## scalar) */ \
507  /* { */ \
508  /* const octave_ ## TM ## matrix& v1 = dynamic_cast<const octave_ ## TM ## matrix&> (a1); */ \
509  /* const octave_ ## TS ## scalar& v2 = dynamic_cast<const octave_ ## TS ## scalar&> (a2); */ \
510  /* */ \
511  /* Matrix m1 = v1.TM ## matrix_value (); */ \
512  /* Matrix m2 = v2.TM ## matrix_value (); */ \
513  /* */ \
514  /* return octave_value (xleftdiv (m1, m2)); */ \
515  /* } */ \
516  \
517  DEFINTNDBINOP_OP (PFX ## _el_mul, TM ## matrix, TS ## scalar, TM ## array, TS ## scalar, *, TI) \
518  \
519  DEFBINOP (PFX ## _el_div, TM ## matrix, TS ## scalar) \
520  { \
521  const octave_ ## TM ## matrix& v1 = dynamic_cast<const octave_ ## TM ## matrix&> (a1); \
522  const octave_ ## TS ## scalar& v2 = dynamic_cast<const octave_ ## TS ## scalar&> (a2); \
523  \
524  if (! v2.TS ## scalar_value ()) \
525  warn_divide_by_zero (); \
526  \
527  octave_value retval = octave_value (v1.TM ## array_value () / v2.TS ## scalar_value ()); \
528  return retval; \
529  } \
530  \
531  DEFINTNDBINOP_FN (PFX ## _el_pow, TM ## matrix, TS ## scalar, TM ## array, TS ## scalar, elem_xpow, TI, .^) \
532  \
533  DEFBINOP (PFX ## _el_ldiv, TM ## matrix, TS ## scalar) \
534  { \
535  const octave_ ## TM ## matrix& v1 = dynamic_cast<const octave_ ## TM ## matrix&> (a1); \
536  const octave_ ## TS ## scalar& v2 = dynamic_cast<const octave_ ## TS ## scalar&> (a2); \
537  \
538  octave_value retval = v2.TS ## scalar_value () / v1.TM ## array_value (); \
539  return retval; \
540  }
541 
542 #define OCTAVE_MS_INT_CMP_OPS(PFX, TM, TS) \
543  DEFNDBINOP_FN (PFX ## _lt, TM ## matrix, TS ## scalar, TM ## array, TS ## scalar, mx_el_lt) \
544  DEFNDBINOP_FN (PFX ## _le, TM ## matrix, TS ## scalar, TM ## array, TS ## scalar, mx_el_le) \
545  DEFNDBINOP_FN (PFX ## _eq, TM ## matrix, TS ## scalar, TM ## array, TS ## scalar, mx_el_eq) \
546  DEFNDBINOP_FN (PFX ## _ge, TM ## matrix, TS ## scalar, TM ## array, TS ## scalar, mx_el_ge) \
547  DEFNDBINOP_FN (PFX ## _gt, TM ## matrix, TS ## scalar, TM ## array, TS ## scalar, mx_el_gt) \
548  DEFNDBINOP_FN (PFX ## _ne, TM ## matrix, TS ## scalar, TM ## array, TS ## scalar, mx_el_ne)
549 
550 #define OCTAVE_MS_INT_BOOL_OPS(PFX, TM, TS) \
551  DEFNDBINOP_FN (PFX ## _el_and, TM ## matrix, TS ## scalar, TM ## array, TS ## scalar, mx_el_and) \
552  DEFNDBINOP_FN (PFX ## _el_or, TM ## matrix, TS ## scalar, TM ## array, TS ## scalar, mx_el_or) \
553  DEFNDBINOP_FN (PFX ## _el_not_and, TM ## matrix, TS ## scalar, TM ## array, TS ## scalar, mx_el_not_and) \
554  DEFNDBINOP_FN (PFX ## _el_not_or, TM ## matrix, TS ## scalar, TM ## array, TS ## scalar, mx_el_not_or)
555 
556 #define OCTAVE_MS_INT_ASSIGN_OPS(PFX, TM, TS, TE) \
557  DEFNDASSIGNOP_FN (PFX ## _assign, TM ## matrix, TS ## scalar, TM ## scalar, assign)
558 
559 #define OCTAVE_MS_INT_ASSIGNEQ_OPS(PFX, TM) \
560  DEFNDASSIGNOP_OP (PFX ## _assign_add, TM ## matrix, TM ## scalar, TM ## scalar, +=) \
561  DEFNDASSIGNOP_OP (PFX ## _assign_sub, TM ## matrix, TM ## scalar, TM ## scalar, -=) \
562  DEFNDASSIGNOP_OP (PFX ## _assign_mul, TM ## matrix, TM ## scalar, TM ## scalar, *=) \
563  DEFNDASSIGNOP_OP (PFX ## _assign_div, TM ## matrix, TM ## scalar, TM ## scalar, /=)
564 
565 #define OCTAVE_MS_POW_OPS(T1, T2) \
566  octave_value elem_xpow (T1 ## NDArray a, octave_ ## T2 b) \
567  { \
568  T1 ## NDArray result (a.dims ()); \
569  for (int i = 0; i < a.numel (); i++) \
570  { \
571  OCTAVE_QUIT; \
572  result (i) = pow (a(i), b); \
573  } \
574  return octave_value (result); \
575  } \
576  \
577  octave_value elem_xpow (T1 ## NDArray a, double b) \
578  { \
579  T1 ## NDArray result (a.dims ()); \
580  for (int i = 0; i < a.numel (); i++) \
581  { \
582  OCTAVE_QUIT; \
583  result (i) = pow (a(i), b); \
584  } \
585  return octave_value (result); \
586  } \
587  \
588  octave_value elem_xpow (NDArray a, octave_ ## T2 b) \
589  { \
590  T2 ## NDArray result (a.dims ()); \
591  for (int i = 0; i < a.numel (); i++) \
592  { \
593  OCTAVE_QUIT; \
594  result (i) = pow (a(i), b); \
595  } \
596  return octave_value (result); \
597  } \
598  \
599  octave_value elem_xpow (T1 ## NDArray a, float b) \
600  { \
601  T1 ## NDArray result (a.dims ()); \
602  for (int i = 0; i < a.numel (); i++) \
603  { \
604  OCTAVE_QUIT; \
605  result (i) = powf (a(i), b); \
606  } \
607  return octave_value (result); \
608  } \
609  \
610  octave_value elem_xpow (FloatNDArray a, octave_ ## T2 b) \
611  { \
612  T2 ## NDArray result (a.dims ()); \
613  for (int i = 0; i < a.numel (); i++) \
614  { \
615  OCTAVE_QUIT; \
616  result (i) = powf (a(i), b); \
617  } \
618  return octave_value (result); \
619  }
620 
621 #define OCTAVE_MS_INT_OPS(TYPE) \
622  OCTAVE_MS_POW_OPS (TYPE, TYPE) \
623  OCTAVE_MS_INT_ARITH_OPS (ms, TYPE ## _, TYPE ## _, TYPE) \
624  OCTAVE_MS_INT_ARITH_OPS (msx, TYPE ## _, , TYPE) \
625  OCTAVE_MS_INT_ARITH_OPS (mxs, , TYPE ## _, TYPE) \
626  OCTAVE_MS_INT_ARITH_OPS (msfx, TYPE ## _, float_, TYPE) \
627  OCTAVE_MS_INT_ARITH_OPS (mfxs, float_, TYPE ## _, TYPE) \
628  OCTAVE_MS_INT_CMP_OPS (ms, TYPE ## _, TYPE ## _) \
629  OCTAVE_MS_INT_CMP_OPS (mx, TYPE ## _, ) \
630  OCTAVE_MS_INT_CMP_OPS (mxs, , TYPE ## _) \
631  OCTAVE_MS_INT_CMP_OPS (mfx, TYPE ## _, float_) \
632  OCTAVE_MS_INT_CMP_OPS (mfxs, float_, TYPE ## _) \
633  OCTAVE_MS_INT_BOOL_OPS (ms, TYPE ## _, TYPE ## _) \
634  OCTAVE_MS_INT_BOOL_OPS (mx, TYPE ## _, ) \
635  OCTAVE_MS_INT_BOOL_OPS (mxs, , TYPE ## _) \
636  OCTAVE_MS_INT_BOOL_OPS (mfx, TYPE ## _, float_) \
637  OCTAVE_MS_INT_BOOL_OPS (mfxs, float_, TYPE ## _) \
638  OCTAVE_MS_INT_ASSIGN_OPS (ms, TYPE ## _, TYPE ## _, TYPE ## _) \
639  OCTAVE_MS_INT_ASSIGNEQ_OPS (mse, TYPE ## _) \
640  OCTAVE_MS_INT_ASSIGN_OPS (mx, TYPE ## _, , ) \
641  OCTAVE_MS_INT_ASSIGN_OPS (mfx, TYPE ## _, float_, float_)
642 
643 // matrix unary ops.
644 #define OCTAVE_M_INT_UNOPS(TYPE) \
645  \
646  DEFNDUNOP_OP (m_not, TYPE ## _matrix, TYPE ## _array, !) \
647  DEFNDUNOP_OP (m_uplus, TYPE ## _matrix, TYPE ## _array, /* no-op */) \
648  DEFUNOP (m_uminus, TYPE ## _matrix) \
649  { \
650  const octave_ ## TYPE ## _matrix & v = dynamic_cast<const octave_ ## TYPE ## _matrix &> (a); \
651  octave_value retval = octave_value (- v. TYPE ## _array_value ()); \
652  return retval; \
653  } \
654  \
655  DEFUNOP (m_transpose, TYPE ## _matrix) \
656  { \
657  const octave_ ## TYPE ## _matrix& v = dynamic_cast<const octave_ ## TYPE ## _matrix&> (a); \
658  \
659  if (v.ndims () > 2) \
660  error ("transpose not defined for N-D objects"); \
661  \
662  return octave_value (v.TYPE ## _array_value ().transpose ()); \
663  } \
664  \
665  DEFNCUNOP_METHOD (m_incr, TYPE ## _matrix, increment) \
666  DEFNCUNOP_METHOD (m_decr, TYPE ## _matrix, decrement) \
667  DEFNCUNOP_METHOD (m_changesign, TYPE ## _matrix, changesign)
668 
669 // matrix by matrix ops.
670 #define OCTAVE_MM_INT_ARITH_OPS(PFX, T1, T2, T3) \
671  \
672  DEFINTNDBINOP_OP (PFX ## _add, T1 ## matrix, T2 ## matrix, T1 ## array, T2 ## array, +, T3) \
673  DEFINTNDBINOP_OP (PFX ## _sub, T1 ## matrix, T2 ## matrix, T1 ## array, T2 ## array, -, T3) \
674  \
675  /* DEFBINOP_OP (PFX ## _mul, T1 ## matrix, T2 ## matrix, *) */ \
676  /* DEFBINOP_FN (PFX ## _div, T1 ## matrix, T2 ## matrix, xdiv) */ \
677  \
678  DEFBINOPX (PFX ## _pow, T1 ## matrix, T2 ## matrix) \
679  { \
680  error ("can't do A ^ B for A and B both matrices"); \
681  } \
682  \
683  /* DEFBINOP_FN (PFX ## _ldiv, T1 ## matrix, T2 ## matrix, xleftdiv) */ \
684  \
685  DEFINTNDBINOP_FN (PFX ## _el_mul, T1 ## matrix, T2 ## matrix, T1 ## array, T2 ## array, product, T3, .*) \
686  \
687  DEFINTNDBINOP_FN (PFX ## _el_div, T1 ## matrix, T2 ## matrix, T1 ## array, T2 ## array, quotient, T3, ./) \
688  \
689  DEFINTNDBINOP_FN (PFX ## _el_pow, T1 ## matrix, T2 ## matrix, T1 ## array, T2 ## array, elem_xpow, T3, .^) \
690  \
691  DEFBINOP (PFX ## _el_ldiv, T1 ## matrix, T2 ## matrix) \
692  { \
693  const octave_ ## T1 ## matrix& v1 = dynamic_cast<const octave_ ## T1 ## matrix&> (a1); \
694  const octave_ ## T2 ## matrix& v2 = dynamic_cast<const octave_ ## T2 ## matrix&> (a2); \
695  \
696  octave_value retval = octave_value (quotient (v2.T2 ## array_value (), v1.T1 ## array_value ())); \
697  return retval; \
698  }
699 
700 #define OCTAVE_MM_INT_CMP_OPS(PFX, T1, T2) \
701  DEFNDBINOP_FN (PFX ## _lt, T1 ## matrix, T2 ## matrix, T1 ## array, T2 ## array, mx_el_lt) \
702  DEFNDBINOP_FN (PFX ## _le, T1 ## matrix, T2 ## matrix, T1 ## array, T2 ## array, mx_el_le) \
703  DEFNDBINOP_FN (PFX ## _eq, T1 ## matrix, T2 ## matrix, T1 ## array, T2 ## array, mx_el_eq) \
704  DEFNDBINOP_FN (PFX ## _ge, T1 ## matrix, T2 ## matrix, T1 ## array, T2 ## array, mx_el_ge) \
705  DEFNDBINOP_FN (PFX ## _gt, T1 ## matrix, T2 ## matrix, T1 ## array, T2 ## array, mx_el_gt) \
706  DEFNDBINOP_FN (PFX ## _ne, T1 ## matrix, T2 ## matrix, T1 ## array, T2 ## array, mx_el_ne)
707 
708 #define OCTAVE_MM_INT_BOOL_OPS(PFX, T1, T2) \
709  DEFNDBINOP_FN (PFX ## _el_and, T1 ## matrix, T2 ## matrix, T1 ## array, T2 ## array, mx_el_and) \
710  DEFNDBINOP_FN (PFX ## _el_or, T1 ## matrix, T2 ## matrix, T1 ## array, T2 ## array, mx_el_or) \
711  DEFNDBINOP_FN (PFX ## _el_not_and, T1 ## matrix, T2 ## matrix, T1 ## array, T2 ## array, mx_el_not_and) \
712  DEFNDBINOP_FN (PFX ## _el_not_or, T1 ## matrix, T2 ## matrix, T1 ## array, T2 ## array, mx_el_not_or) \
713  DEFNDBINOP_FN (PFX ## _el_and_not, T1 ## matrix, T2 ## matrix, T1 ## array, T2 ## array, mx_el_and_not) \
714  DEFNDBINOP_FN (PFX ## _el_or_not, T1 ## matrix, T2 ## matrix, T1 ## array, T2 ## array, mx_el_or_not)
715 
716 #define OCTAVE_MM_INT_ASSIGN_OPS(PFX, TLHS, TRHS, TE) \
717  DEFNDASSIGNOP_FN (PFX ## _assign, TLHS ## matrix, TRHS ## matrix, TLHS ## array, assign)
718 
719 #define OCTAVE_MM_INT_ASSIGNEQ_OPS(PFX, TM) \
720  DEFNDASSIGNOP_OP (PFX ## _assign_add, TM ## matrix, TM ## matrix, TM ## array, +=) \
721  DEFNDASSIGNOP_OP (PFX ## _assign_sub, TM ## matrix, TM ## matrix, TM ## array, -=) \
722  DEFNDASSIGNOP_FNOP (PFX ## _assign_el_mul, TM ## matrix, TM ## matrix, TM ## array, product_eq) \
723  DEFNDASSIGNOP_FNOP (PFX ## _assign_el_div, TM ## matrix, TM ## matrix, TM ## array, quotient_eq)
724 
725 #define OCTAVE_MM_POW_OPS(T1, T2) \
726  octave_value \
727  elem_xpow (const T1 ## NDArray& a, const T2 ## NDArray& b) \
728  { \
729  dim_vector a_dims = a.dims (); \
730  dim_vector b_dims = b.dims (); \
731  if (a_dims != b_dims) \
732  { \
733  if (! is_valid_bsxfun ("operator .^", a_dims, b_dims)) \
734  octave::err_nonconformant ("operator .^", a_dims, b_dims); \
735  \
736  return bsxfun_pow (a, b); \
737  } \
738  T1 ## NDArray result (a_dims); \
739  for (int i = 0; i < a.numel (); i++) \
740  { \
741  OCTAVE_QUIT; \
742  result (i) = pow (a(i), b(i)); \
743  } \
744  return octave_value (result); \
745  } \
746  \
747  octave_value \
748  elem_xpow (const T1 ## NDArray& a, const NDArray& b) \
749  { \
750  dim_vector a_dims = a.dims (); \
751  dim_vector b_dims = b.dims (); \
752  if (a_dims != b_dims) \
753  { \
754  if (! is_valid_bsxfun ("operator .^", a_dims, b_dims)) \
755  octave::err_nonconformant ("operator .^", a_dims, b_dims); \
756  \
757  return bsxfun_pow (a, b); \
758  } \
759  T1 ## NDArray result (a_dims); \
760  for (int i = 0; i < a.numel (); i++) \
761  { \
762  OCTAVE_QUIT; \
763  result (i) = pow (a(i), b(i)); \
764  } \
765  return octave_value (result); \
766  } \
767  \
768  octave_value \
769  elem_xpow (const NDArray& a, const T2 ## NDArray& b) \
770  { \
771  dim_vector a_dims = a.dims (); \
772  dim_vector b_dims = b.dims (); \
773  if (a_dims != b_dims) \
774  { \
775  if (! is_valid_bsxfun ("operator .^", a_dims, b_dims)) \
776  octave::err_nonconformant ("operator .^", a_dims, b_dims); \
777  \
778  return bsxfun_pow (a, b); \
779  } \
780  T2 ## NDArray result (a_dims); \
781  for (int i = 0; i < a.numel (); i++) \
782  { \
783  OCTAVE_QUIT; \
784  result (i) = pow (a(i), b(i)); \
785  } \
786  return octave_value (result); \
787  } \
788  \
789  octave_value \
790  elem_xpow (const T1 ## NDArray& a, const FloatNDArray& b) \
791  { \
792  dim_vector a_dims = a.dims (); \
793  dim_vector b_dims = b.dims (); \
794  if (a_dims != b_dims) \
795  { \
796  if (! is_valid_bsxfun ("operator .^", a_dims, b_dims)) \
797  octave::err_nonconformant ("operator .^", a_dims, b_dims); \
798  \
799  return bsxfun_pow (a, b); \
800  } \
801  T1 ## NDArray result (a_dims); \
802  for (int i = 0; i < a.numel (); i++) \
803  { \
804  OCTAVE_QUIT; \
805  result (i) = powf (a(i), b(i)); \
806  } \
807  return octave_value (result); \
808  } \
809  \
810  octave_value \
811  elem_xpow (const FloatNDArray& a, const T2 ## NDArray& b) \
812  { \
813  dim_vector a_dims = a.dims (); \
814  dim_vector b_dims = b.dims (); \
815  if (a_dims != b_dims) \
816  { \
817  if (! is_valid_bsxfun ("operator .^", a_dims, b_dims)) \
818  octave::err_nonconformant ("operator .^", a_dims, b_dims); \
819  \
820  return bsxfun_pow (a, b); \
821  } \
822  T2 ## NDArray result (a_dims); \
823  for (int i = 0; i < a.numel (); i++) \
824  { \
825  OCTAVE_QUIT; \
826  result (i) = powf (a(i), b(i)); \
827  } \
828  return octave_value (result); \
829  }
830 
831 #define OCTAVE_MM_CONV(T1, T2) \
832  DEFCONV (T1 ## m_ ## T2 ## m_conv, T1 ## matrix, T2 ## matrix) \
833  { \
834  const octave_ ## T1 ## matrix& v = dynamic_cast<const octave_ ## T1 ## matrix&> (a); \
835  \
836  return new octave_ ## T2 ## matrix (v.T2 ## array_value ()); \
837  }
838 
839 #define OCTAVE_MM_INT_OPS(TYPE) \
840  OCTAVE_M_INT_UNOPS (TYPE) \
841  OCTAVE_MM_POW_OPS (TYPE, TYPE) \
842  OCTAVE_MM_INT_ARITH_OPS (mm, TYPE ## _, TYPE ## _, TYPE) \
843  OCTAVE_MM_INT_ARITH_OPS (mmx, TYPE ## _, , TYPE) \
844  OCTAVE_MM_INT_ARITH_OPS (mxm, , TYPE ## _, TYPE) \
845  OCTAVE_MM_INT_ARITH_OPS (mmfx, TYPE ## _, float_, TYPE) \
846  OCTAVE_MM_INT_ARITH_OPS (mfxm, float_, TYPE ## _, TYPE) \
847  OCTAVE_MM_INT_CMP_OPS (mm, TYPE ## _, TYPE ## _) \
848  OCTAVE_MM_INT_CMP_OPS (mmx, TYPE ## _, ) \
849  OCTAVE_MM_INT_CMP_OPS (mfxm, float_, TYPE ## _) \
850  OCTAVE_MM_INT_CMP_OPS (mmfx, TYPE ## _, float_) \
851  OCTAVE_MM_INT_CMP_OPS (mxm, , TYPE ## _) \
852  OCTAVE_MM_INT_BOOL_OPS (mm, TYPE ## _, TYPE ## _) \
853  OCTAVE_MM_INT_BOOL_OPS (mmx, TYPE ## _, ) \
854  OCTAVE_MM_INT_BOOL_OPS (mxm, , TYPE ## _) \
855  OCTAVE_MM_INT_BOOL_OPS (mmfx, TYPE ## _, float_) \
856  OCTAVE_MM_INT_BOOL_OPS (mfxm, float_, TYPE ## _) \
857  OCTAVE_MM_INT_ASSIGN_OPS (mm, TYPE ## _, TYPE ## _, TYPE ## _) \
858  OCTAVE_MM_INT_ASSIGNEQ_OPS (mme, TYPE ## _) \
859  OCTAVE_MM_INT_ASSIGN_OPS (mmx, TYPE ## _, , ) \
860  OCTAVE_MM_INT_ASSIGN_OPS (mmfx, TYPE ## _, float_, float_) \
861  OCTAVE_MM_CONV(TYPE ## _, complex_) \
862  OCTAVE_MM_CONV(TYPE ## _, float_complex_)
863 
864 #define OCTAVE_RE_INT_ASSIGN_OPS(TYPE) \
865  DEFNDASSIGNOP_FN (TYPE ## ms_assign, matrix, TYPE ## _scalar, array, assign) \
866  DEFNDASSIGNOP_FN (TYPE ## mm_assign, matrix, TYPE ## _matrix, array, assign)
867 
868 #define OCTAVE_FLT_RE_INT_ASSIGN_OPS(TYPE) \
869  DEFNDASSIGNOP_FN (TYPE ## fms_assign, float_matrix, TYPE ## _scalar, float_array, assign) \
870  DEFNDASSIGNOP_FN (TYPE ## fmm_assign, float_matrix, TYPE ## _matrix, float_array, assign)
871 
872 #define OCTAVE_CX_INT_ASSIGN_OPS(TYPE) \
873  DEFNDASSIGNOP_FN (TYPE ## cms_assign, complex_matrix, TYPE ## _scalar, complex_array, assign) \
874  DEFNDASSIGNOP_FN (TYPE ## cmm_assign, complex_matrix, TYPE ## _matrix, complex_array, assign)
875 
876 #define OCTAVE_FLT_CX_INT_ASSIGN_OPS(TYPE) \
877  DEFNDASSIGNOP_FN (TYPE ## fcms_assign, float_complex_matrix, TYPE ## _scalar, float_complex_array, assign) \
878  DEFNDASSIGNOP_FN (TYPE ## fcmm_assign, float_complex_matrix, TYPE ## _matrix, float_complex_array, assign)
879 
880 #define OCTAVE_INT_NULL_ASSIGN_OPS(TYPE) \
881  DEFNULLASSIGNOP_FN (TYPE ## null_assign, TYPE ## _matrix, delete_elements)
882 
883 #define OCTAVE_INT_OPS(TYPE) \
884  OCTAVE_SS_INT_OPS (TYPE) \
885  OCTAVE_SM_INT_OPS (TYPE) \
886  OCTAVE_MS_INT_OPS (TYPE) \
887  OCTAVE_MM_INT_OPS (TYPE) \
888  OCTAVE_CONCAT_FN (TYPE) \
889  OCTAVE_RE_INT_ASSIGN_OPS (TYPE) \
890  OCTAVE_FLT_RE_INT_ASSIGN_OPS (TYPE) \
891  OCTAVE_CX_INT_ASSIGN_OPS (TYPE) \
892  OCTAVE_FLT_CX_INT_ASSIGN_OPS (TYPE) \
893  OCTAVE_INT_NULL_ASSIGN_OPS(TYPE)
894 
895 #define OCTAVE_INSTALL_S_INT_UNOPS(TYPE) \
896  INSTALL_UNOP (op_not, octave_ ## TYPE ## _scalar, s_not); \
897  INSTALL_UNOP (op_uplus, octave_ ## TYPE ## _scalar, s_uplus); \
898  INSTALL_UNOP (op_uminus, octave_ ## TYPE ## _scalar, s_uminus); \
899  INSTALL_UNOP (op_transpose, octave_ ## TYPE ## _scalar, s_transpose); \
900  INSTALL_UNOP (op_hermitian, octave_ ## TYPE ## _scalar, s_hermitian); \
901  \
902  INSTALL_NCUNOP (op_incr, octave_ ## TYPE ## _scalar, s_incr); \
903  INSTALL_NCUNOP (op_decr, octave_ ## TYPE ## _scalar, s_decr);
904 
905 #define OCTAVE_INSTALL_SS_INT_ARITH_OPS(PFX, T1, T2) \
906  INSTALL_BINOP (op_add, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _add); \
907  INSTALL_BINOP (op_sub, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _sub); \
908  INSTALL_BINOP (op_mul, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _mul); \
909  INSTALL_BINOP (op_div, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _div); \
910  INSTALL_BINOP (op_pow, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _pow); \
911  INSTALL_BINOP (op_ldiv, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _ldiv); \
912  INSTALL_BINOP (op_el_mul, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _el_mul); \
913  INSTALL_BINOP (op_el_div, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _el_div); \
914  INSTALL_BINOP (op_el_pow, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _el_pow); \
915  INSTALL_BINOP (op_el_ldiv, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _el_ldiv);
916 
917 #define OCTAVE_INSTALL_SS_INT_CMP_OPS(PFX, T1, T2) \
918  INSTALL_BINOP (op_lt, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _lt); \
919  INSTALL_BINOP (op_le, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _le); \
920  INSTALL_BINOP (op_eq, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _eq); \
921  INSTALL_BINOP (op_ge, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _ge); \
922  INSTALL_BINOP (op_gt, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _gt); \
923  INSTALL_BINOP (op_ne, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _ne);
924 
925 #define OCTAVE_INSTALL_SS_INT_BOOL_OPS(PFX, T1, T2) \
926  INSTALL_BINOP (op_el_and, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _el_and); \
927  INSTALL_BINOP (op_el_or, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _el_or);
928 
929 #define OCTAVE_INSTALL_SS_INT_OPS(TYPE) \
930  OCTAVE_INSTALL_S_INT_UNOPS (TYPE) \
931  OCTAVE_INSTALL_SS_INT_ARITH_OPS (ss, TYPE ## _, TYPE ## _) \
932  OCTAVE_INSTALL_SS_INT_ARITH_OPS (ssx, TYPE ## _, ) \
933  OCTAVE_INSTALL_SS_INT_ARITH_OPS (sxs, , TYPE ## _) \
934  OCTAVE_INSTALL_SS_INT_ARITH_OPS (ssfx, TYPE ## _, float_) \
935  OCTAVE_INSTALL_SS_INT_ARITH_OPS (sfxs, float_, TYPE ## _) \
936  OCTAVE_INSTALL_SS_INT_CMP_OPS (ss, TYPE ## _, TYPE ## _) \
937  OCTAVE_INSTALL_SS_INT_CMP_OPS (sx, TYPE ## _, ) \
938  OCTAVE_INSTALL_SS_INT_CMP_OPS (xs, , TYPE ## _) \
939  OCTAVE_INSTALL_SS_INT_CMP_OPS (sfx, TYPE ## _, float_) \
940  OCTAVE_INSTALL_SS_INT_CMP_OPS (fxs, float_, TYPE ## _) \
941  OCTAVE_INSTALL_SS_INT_BOOL_OPS (ss, TYPE ## _, TYPE ## _) \
942  OCTAVE_INSTALL_SS_INT_BOOL_OPS (sx, TYPE ## _, ) \
943  OCTAVE_INSTALL_SS_INT_BOOL_OPS (xs, , TYPE ## _) \
944  OCTAVE_INSTALL_SS_INT_BOOL_OPS (sfx, TYPE ## _, float_) \
945  OCTAVE_INSTALL_SS_INT_BOOL_OPS (fxs, float_, TYPE ## _) \
946  INSTALL_ASSIGNCONV (octave_ ## TYPE ## _scalar, octave_ ## TYPE ## _scalar, octave_ ## TYPE ## _matrix) \
947  INSTALL_ASSIGNCONV (octave_ ## TYPE ## _scalar, octave_scalar, octave_ ## TYPE ## _matrix) \
948  INSTALL_ASSIGNCONV (octave_ ## TYPE ## _scalar, octave_float_scalar, octave_ ## TYPE ## _matrix) \
949  INSTALL_ASSIGNCONV (octave_ ## TYPE ## _scalar, octave_complex_scalar, octave_complex_matrix) \
950  INSTALL_ASSIGNCONV (octave_ ## TYPE ## _scalar, octave_float_complex_scalar, octave_float_complex_matrix)
951 
952 #define OCTAVE_INSTALL_SM_INT_ARITH_OPS(PFX, T1, T2) \
953  INSTALL_BINOP (op_add, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _add); \
954  INSTALL_BINOP (op_sub, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _sub); \
955  INSTALL_BINOP (op_mul, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _mul); \
956  /* INSTALL_BINOP (op_div, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _div); */ \
957  /* INSTALL_BINOP (op_pow, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _pow); */ \
958  INSTALL_BINOP (op_ldiv, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _ldiv); \
959  INSTALL_BINOP (op_el_mul, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _el_mul); \
960  INSTALL_BINOP (op_el_div, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _el_div); \
961  INSTALL_BINOP (op_el_pow, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _el_pow); \
962  INSTALL_BINOP (op_el_ldiv, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _el_ldiv);
963 
964 #define OCTAVE_INSTALL_SM_INT_CMP_OPS(PFX, T1, T2) \
965  INSTALL_BINOP (op_lt, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _lt); \
966  INSTALL_BINOP (op_le, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _le); \
967  INSTALL_BINOP (op_eq, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _eq); \
968  INSTALL_BINOP (op_ge, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _ge); \
969  INSTALL_BINOP (op_gt, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _gt); \
970  INSTALL_BINOP (op_ne, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _ne);
971 
972 #define OCTAVE_INSTALL_SM_INT_BOOL_OPS(PFX, T1, T2) \
973  INSTALL_BINOP (op_el_and, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _el_and); \
974  INSTALL_BINOP (op_el_or, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _el_or); \
975  INSTALL_BINOP (op_el_and_not, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _el_and_not); \
976  INSTALL_BINOP (op_el_or_not, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _el_or_not);
977 
978 #define OCTAVE_INSTALL_SM_INT_OPS(TYPE) \
979  OCTAVE_INSTALL_SM_INT_ARITH_OPS (sm, TYPE ## _, TYPE ## _) \
980  OCTAVE_INSTALL_SM_INT_ARITH_OPS (smx, TYPE ## _, ) \
981  OCTAVE_INSTALL_SM_INT_ARITH_OPS (sxm, , TYPE ## _) \
982  OCTAVE_INSTALL_SM_INT_ARITH_OPS (smfx, TYPE ## _, float_) \
983  OCTAVE_INSTALL_SM_INT_ARITH_OPS (sfxm, float_, TYPE ## _) \
984  OCTAVE_INSTALL_SM_INT_CMP_OPS (sm, TYPE ## _, TYPE ## _) \
985  OCTAVE_INSTALL_SM_INT_CMP_OPS (xm, , TYPE ## _) \
986  OCTAVE_INSTALL_SM_INT_CMP_OPS (smx, TYPE ## _, ) \
987  OCTAVE_INSTALL_SM_INT_CMP_OPS (fxm, float_, TYPE ## _) \
988  OCTAVE_INSTALL_SM_INT_CMP_OPS (smfx, TYPE ## _, float_) \
989  OCTAVE_INSTALL_SM_INT_BOOL_OPS (sm, TYPE ## _, TYPE ## _) \
990  OCTAVE_INSTALL_SM_INT_BOOL_OPS (xm, , TYPE ## _) \
991  OCTAVE_INSTALL_SM_INT_BOOL_OPS (smx, TYPE ## _, ) \
992  OCTAVE_INSTALL_SM_INT_BOOL_OPS (fxm, float_, TYPE ## _) \
993  OCTAVE_INSTALL_SM_INT_BOOL_OPS (smfx, TYPE ## _, float_) \
994  INSTALL_WIDENOP (octave_ ## TYPE ## _scalar, octave_ ## TYPE ## _matrix, TYPE ## _s_ ## TYPE ## _m_conv) \
995  INSTALL_WIDENOP (octave_ ## TYPE ## _scalar, octave_complex_matrix, TYPE ## _s_complex_m_conv) \
996  INSTALL_WIDENOP (octave_ ## TYPE ## _scalar, octave_float_complex_matrix, TYPE ## _s_float_complex_m_conv) \
997  INSTALL_ASSIGNCONV (octave_ ## TYPE ## _scalar, octave_ ## TYPE ## _matrix, octave_ ## TYPE ## _matrix) \
998  INSTALL_ASSIGNCONV (octave_ ## TYPE ## _scalar, octave_matrix, octave_ ## TYPE ## _matrix) \
999  INSTALL_ASSIGNCONV (octave_ ## TYPE ## _scalar, octave_float_matrix, octave_ ## TYPE ## _matrix) \
1000  INSTALL_ASSIGNCONV (octave_ ## TYPE ## _scalar, octave_complex_matrix, octave_complex_matrix) \
1001  INSTALL_ASSIGNCONV (octave_ ## TYPE ## _scalar, octave_float_complex_matrix, octave_float_complex_matrix)
1002 
1003 #define OCTAVE_INSTALL_MS_INT_ARITH_OPS(PFX, T1, T2) \
1004  INSTALL_BINOP (op_add, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _add); \
1005  INSTALL_BINOP (op_sub, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _sub); \
1006  INSTALL_BINOP (op_mul, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _mul); \
1007  INSTALL_BINOP (op_div, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _div); \
1008  /* INSTALL_BINOP (op_pow, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _pow); */ \
1009  /* INSTALL_BINOP (op_ldiv, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _ldiv); */ \
1010  \
1011  INSTALL_BINOP (op_el_mul, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _el_mul); \
1012  INSTALL_BINOP (op_el_div, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _el_div); \
1013  INSTALL_BINOP (op_el_pow, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _el_pow); \
1014  INSTALL_BINOP (op_el_ldiv, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _el_ldiv);
1015 
1016 #define OCTAVE_INSTALL_MS_INT_CMP_OPS(PFX, T1, T2) \
1017  INSTALL_BINOP (op_lt, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _lt); \
1018  INSTALL_BINOP (op_le, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _le); \
1019  INSTALL_BINOP (op_eq, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _eq); \
1020  INSTALL_BINOP (op_ge, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _ge); \
1021  INSTALL_BINOP (op_gt, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _gt); \
1022  INSTALL_BINOP (op_ne, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _ne);
1023 
1024 #define OCTAVE_INSTALL_MS_INT_BOOL_OPS(PFX, T1, T2) \
1025  INSTALL_BINOP (op_el_and, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _el_and); \
1026  INSTALL_BINOP (op_el_or, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _el_or); \
1027  INSTALL_BINOP (op_el_not_and, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _el_not_and); \
1028  INSTALL_BINOP (op_el_not_or, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _el_not_or);
1029 
1030 #define OCTAVE_INSTALL_MS_INT_ASSIGN_OPS(PFX, TLHS, TRHS) \
1031  INSTALL_ASSIGNOP (op_asn_eq, octave_ ## TLHS ## matrix, octave_ ## TRHS ## scalar, PFX ## _assign)
1032 
1033 #define OCTAVE_INSTALL_MS_INT_ASSIGNEQ_OPS(PFX, TLHS, TRHS) \
1034  INSTALL_ASSIGNOP (op_add_eq, octave_ ## TLHS ## matrix, octave_ ## TRHS ## scalar, PFX ## _assign_add) \
1035  INSTALL_ASSIGNOP (op_sub_eq, octave_ ## TLHS ## matrix, octave_ ## TRHS ## scalar, PFX ## _assign_sub) \
1036  INSTALL_ASSIGNOP (op_mul_eq, octave_ ## TLHS ## matrix, octave_ ## TRHS ## scalar, PFX ## _assign_mul) \
1037  INSTALL_ASSIGNOP (op_div_eq, octave_ ## TLHS ## matrix, octave_ ## TRHS ## scalar, PFX ## _assign_div)
1038 
1039 #define OCTAVE_INSTALL_MS_INT_OPS(TYPE) \
1040  OCTAVE_INSTALL_MS_INT_ARITH_OPS (ms, TYPE ## _, TYPE ## _) \
1041  OCTAVE_INSTALL_MS_INT_ARITH_OPS (msx, TYPE ## _, ) \
1042  OCTAVE_INSTALL_MS_INT_ARITH_OPS (mxs, , TYPE ## _) \
1043  OCTAVE_INSTALL_MS_INT_ARITH_OPS (msfx, TYPE ## _, float_) \
1044  OCTAVE_INSTALL_MS_INT_ARITH_OPS (mfxs, float_, TYPE ## _) \
1045  OCTAVE_INSTALL_MS_INT_CMP_OPS (ms, TYPE ## _, TYPE ## _) \
1046  OCTAVE_INSTALL_MS_INT_CMP_OPS (mx, TYPE ## _, ) \
1047  OCTAVE_INSTALL_MS_INT_CMP_OPS (mxs, , TYPE ## _) \
1048  OCTAVE_INSTALL_MS_INT_CMP_OPS (mfx, TYPE ## _, float_) \
1049  OCTAVE_INSTALL_MS_INT_CMP_OPS (mfxs, float_, TYPE ## _) \
1050  OCTAVE_INSTALL_MS_INT_BOOL_OPS (ms, TYPE ## _, TYPE ## _) \
1051  OCTAVE_INSTALL_MS_INT_BOOL_OPS (mx, TYPE ## _, ) \
1052  OCTAVE_INSTALL_MS_INT_BOOL_OPS (mxs, , TYPE ## _) \
1053  OCTAVE_INSTALL_MS_INT_BOOL_OPS (mfx, TYPE ## _, float_) \
1054  OCTAVE_INSTALL_MS_INT_BOOL_OPS (mfxs, float_, TYPE ## _) \
1055  OCTAVE_INSTALL_MS_INT_ASSIGN_OPS (ms, TYPE ## _, TYPE ## _) \
1056  OCTAVE_INSTALL_MS_INT_ASSIGNEQ_OPS (mse, TYPE ## _, TYPE ## _) \
1057  OCTAVE_INSTALL_MS_INT_ASSIGN_OPS (mx, TYPE ## _, ) \
1058  OCTAVE_INSTALL_MS_INT_ASSIGN_OPS (mfx, TYPE ## _, float_) \
1059  INSTALL_ASSIGNCONV (octave_ ## TYPE ## _matrix, octave_complex_scalar, octave_complex_matrix) \
1060  INSTALL_ASSIGNCONV (octave_ ## TYPE ## _matrix, octave_float_complex_scalar, octave_float_complex_matrix)
1061 
1062 #define OCTAVE_INSTALL_M_INT_UNOPS(TYPE) \
1063  INSTALL_UNOP (op_not, octave_ ## TYPE ## _matrix, m_not); \
1064  INSTALL_UNOP (op_uplus, octave_ ## TYPE ## _matrix, m_uplus); \
1065  INSTALL_UNOP (op_uminus, octave_ ## TYPE ## _matrix, m_uminus); \
1066  INSTALL_UNOP (op_transpose, octave_ ## TYPE ## _matrix, m_transpose); \
1067  INSTALL_UNOP (op_hermitian, octave_ ## TYPE ## _matrix, m_transpose); \
1068  \
1069  INSTALL_NCUNOP (op_incr, octave_ ## TYPE ## _matrix, m_incr); \
1070  INSTALL_NCUNOP (op_decr, octave_ ## TYPE ## _matrix, m_decr); \
1071  INSTALL_NCUNOP (op_uminus, octave_ ## TYPE ## _matrix, m_changesign);
1072 
1073 #define OCTAVE_INSTALL_MM_INT_ARITH_OPS(PFX, T1, T2) \
1074  INSTALL_BINOP (op_add, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _add); \
1075  INSTALL_BINOP (op_sub, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _sub); \
1076  /* INSTALL_BINOP (op_mul, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _mul); */ \
1077  /* INSTALL_BINOP (op_div, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _div); */ \
1078  INSTALL_BINOP (op_pow, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _pow); \
1079  /* INSTALL_BINOP (op_ldiv, octave_ ## T1 ## _matrix, octave_ ## T2 ## _matrix, mm_ldiv); */ \
1080  INSTALL_BINOP (op_el_mul, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _el_mul); \
1081  INSTALL_BINOP (op_el_div, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _el_div); \
1082  INSTALL_BINOP (op_el_pow, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _el_pow); \
1083  INSTALL_BINOP (op_el_ldiv, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _el_ldiv);
1084 
1085 #define OCTAVE_INSTALL_MM_INT_CMP_OPS(PFX, T1, T2) \
1086  INSTALL_BINOP (op_lt, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _lt); \
1087  INSTALL_BINOP (op_le, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _le); \
1088  INSTALL_BINOP (op_eq, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _eq); \
1089  INSTALL_BINOP (op_ge, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _ge); \
1090  INSTALL_BINOP (op_gt, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _gt); \
1091  INSTALL_BINOP (op_ne, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _ne);
1092 
1093 #define OCTAVE_INSTALL_MM_INT_BOOL_OPS(PFX, T1, T2) \
1094  INSTALL_BINOP (op_el_and, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _el_and); \
1095  INSTALL_BINOP (op_el_or, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _el_or); \
1096  INSTALL_BINOP (op_el_not_and, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _el_not_and); \
1097  INSTALL_BINOP (op_el_not_or, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _el_not_or); \
1098  INSTALL_BINOP (op_el_and_not, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _el_and_not); \
1099  INSTALL_BINOP (op_el_or_not, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _el_or_not);
1100 
1101 #define OCTAVE_INSTALL_MM_INT_ASSIGN_OPS(PFX, TLHS, TRHS) \
1102  INSTALL_ASSIGNOP (op_asn_eq, octave_ ## TLHS ## matrix, octave_ ## TRHS ## matrix, PFX ## _assign)
1103 
1104 #define OCTAVE_INSTALL_MM_INT_ASSIGNEQ_OPS(PFX, TLHS, TRHS) \
1105  INSTALL_ASSIGNOP (op_add_eq, octave_ ## TLHS ## matrix, octave_ ## TRHS ## matrix, PFX ## _assign_add) \
1106  INSTALL_ASSIGNOP (op_sub_eq, octave_ ## TLHS ## matrix, octave_ ## TRHS ## matrix, PFX ## _assign_sub) \
1107  INSTALL_ASSIGNOP (op_el_mul_eq, octave_ ## TLHS ## matrix, octave_ ## TRHS ## matrix, PFX ## _assign_el_mul) \
1108  INSTALL_ASSIGNOP (op_el_div_eq, octave_ ## TLHS ## matrix, octave_ ## TRHS ## matrix, PFX ## _assign_el_div)
1109 
1110 #define OCTAVE_INSTALL_MM_INT_OPS(TYPE) \
1111  OCTAVE_INSTALL_M_INT_UNOPS (TYPE) \
1112  OCTAVE_INSTALL_MM_INT_ARITH_OPS (mm, TYPE ##_, TYPE ## _) \
1113  OCTAVE_INSTALL_MM_INT_ARITH_OPS (mmx, TYPE ##_, ) \
1114  OCTAVE_INSTALL_MM_INT_ARITH_OPS (mxm, , TYPE ##_) \
1115  OCTAVE_INSTALL_MM_INT_ARITH_OPS (mmfx, TYPE ##_, float_) \
1116  OCTAVE_INSTALL_MM_INT_ARITH_OPS (mfxm, float_, TYPE ##_) \
1117  OCTAVE_INSTALL_MM_INT_CMP_OPS (mm, TYPE ## _, TYPE ## _) \
1118  OCTAVE_INSTALL_MM_INT_CMP_OPS (mmx, TYPE ## _, ) \
1119  OCTAVE_INSTALL_MM_INT_CMP_OPS (mxm, , TYPE ## _) \
1120  OCTAVE_INSTALL_MM_INT_CMP_OPS (mmfx, TYPE ## _, float_) \
1121  OCTAVE_INSTALL_MM_INT_CMP_OPS (mfxm, float_, TYPE ## _) \
1122  OCTAVE_INSTALL_MM_INT_BOOL_OPS (mm, TYPE ## _, TYPE ## _) \
1123  OCTAVE_INSTALL_MM_INT_BOOL_OPS (mmx, TYPE ## _, ) \
1124  OCTAVE_INSTALL_MM_INT_BOOL_OPS (mxm, , TYPE ## _) \
1125  OCTAVE_INSTALL_MM_INT_BOOL_OPS (mmfx, TYPE ## _, float_) \
1126  OCTAVE_INSTALL_MM_INT_BOOL_OPS (mfxm, float_, TYPE ## _) \
1127  OCTAVE_INSTALL_MM_INT_ASSIGN_OPS (mm, TYPE ## _, TYPE ## _) \
1128  OCTAVE_INSTALL_MM_INT_ASSIGNEQ_OPS (mme, TYPE ## _, TYPE ## _) \
1129  OCTAVE_INSTALL_MM_INT_ASSIGN_OPS (mmx, TYPE ## _, ) \
1130  OCTAVE_INSTALL_MM_INT_ASSIGN_OPS (mmfx, TYPE ## _, float_) \
1131  INSTALL_WIDENOP (octave_ ## TYPE ## _matrix, octave_complex_matrix, TYPE ## _m_complex_m_conv) \
1132  INSTALL_WIDENOP (octave_ ## TYPE ## _matrix, octave_float_complex_matrix, TYPE ## _m_float_complex_m_conv) \
1133  INSTALL_ASSIGNCONV (octave_ ## TYPE ## _matrix, octave_complex_matrix, octave_complex_matrix) \
1134  INSTALL_ASSIGNCONV (octave_ ## TYPE ## _matrix, octave_float_complex_matrix, octave_float_complex_matrix)
1135 
1136 #define OCTAVE_INSTALL_RE_INT_ASSIGN_OPS(TYPE) \
1137  INSTALL_ASSIGNOP (op_asn_eq, octave_matrix, octave_ ## TYPE ## _scalar, TYPE ## ms_assign) \
1138  INSTALL_ASSIGNOP (op_asn_eq, octave_matrix, octave_ ## TYPE ## _matrix, TYPE ## mm_assign) \
1139  INSTALL_ASSIGNCONV (octave_scalar, octave_ ## TYPE ## _scalar, octave_matrix) \
1140  INSTALL_ASSIGNCONV (octave_matrix, octave_ ## TYPE ## _matrix, octave_matrix)
1141 
1142 #define OCTAVE_INSTALL_FLT_RE_INT_ASSIGN_OPS(TYPE) \
1143  INSTALL_ASSIGNOP (op_asn_eq, octave_float_matrix, octave_ ## TYPE ## _scalar, TYPE ## fms_assign) \
1144  INSTALL_ASSIGNOP (op_asn_eq, octave_float_matrix, octave_ ## TYPE ## _matrix, TYPE ## fmm_assign) \
1145  INSTALL_ASSIGNCONV (octave_float_scalar, octave_ ## TYPE ## _scalar, octave_float_matrix) \
1146  INSTALL_ASSIGNCONV (octave_float_matrix, octave_ ## TYPE ## _matrix, octave_float_matrix)
1147 
1148 #define OCTAVE_INSTALL_CX_INT_ASSIGN_OPS(TYPE) \
1149  INSTALL_ASSIGNOP (op_asn_eq, octave_complex_matrix, octave_ ## TYPE ## _scalar, TYPE ## cms_assign) \
1150  INSTALL_ASSIGNOP (op_asn_eq, octave_complex_matrix, octave_ ## TYPE ## _matrix, TYPE ## cmm_assign) \
1151  INSTALL_ASSIGNCONV (octave_complex_scalar, octave_ ## TYPE ## _scalar, octave_complex_matrix) \
1152  INSTALL_ASSIGNCONV (octave_complex_matrix, octave_ ## TYPE ## _matrix, octave_complex_matrix)
1153 
1154 #define OCTAVE_INSTALL_FLT_CX_INT_ASSIGN_OPS(TYPE) \
1155  INSTALL_ASSIGNOP (op_asn_eq, octave_float_complex_matrix, octave_ ## TYPE ## _scalar, TYPE ## fcms_assign) \
1156  INSTALL_ASSIGNOP (op_asn_eq, octave_float_complex_matrix, octave_ ## TYPE ## _matrix, TYPE ## fcmm_assign) \
1157  INSTALL_ASSIGNCONV (octave_float_complex_scalar, octave_ ## TYPE ## _scalar, octave_complex_matrix) \
1158  INSTALL_ASSIGNCONV (octave_float_complex_matrix, octave_ ## TYPE ## _matrix, octave_complex_matrix)
1159 
1160 #define OCTAVE_INSTALL_INT_NULL_ASSIGN_OPS(TYPE) \
1161  INSTALL_ASSIGNOP (op_asn_eq, octave_ ## TYPE ## _matrix, octave_null_matrix, TYPE ## null_assign) \
1162  INSTALL_ASSIGNOP (op_asn_eq, octave_ ## TYPE ## _matrix, octave_null_str, TYPE ## null_assign) \
1163  INSTALL_ASSIGNOP (op_asn_eq, octave_ ## TYPE ## _matrix, octave_null_sq_str, TYPE ## null_assign) \
1164  INSTALL_ASSIGNCONV (octave_ ## TYPE ## _scalar, octave_null_matrix, octave_ ## TYPE ## _matrix) \
1165  INSTALL_ASSIGNCONV (octave_## TYPE ## _scalar, octave_null_str, octave_ ## TYPE ## _matrix) \
1166  INSTALL_ASSIGNCONV (octave_## TYPE ## _scalar, octave_null_sq_str, octave_ ## TYPE ## _matrix)
1167 
1168 #define OCTAVE_INSTALL_INT_OPS(TYPE) \
1169  OCTAVE_INSTALL_SS_INT_OPS (TYPE) \
1170  OCTAVE_INSTALL_SM_INT_OPS (TYPE) \
1171  OCTAVE_INSTALL_MS_INT_OPS (TYPE) \
1172  OCTAVE_INSTALL_MM_INT_OPS (TYPE) \
1173  OCTAVE_INSTALL_CONCAT_FN (TYPE) \
1174  OCTAVE_INSTALL_RE_INT_ASSIGN_OPS (TYPE) \
1175  OCTAVE_INSTALL_FLT_RE_INT_ASSIGN_OPS (TYPE) \
1176  OCTAVE_INSTALL_CX_INT_ASSIGN_OPS (TYPE) \
1177  OCTAVE_INSTALL_FLT_CX_INT_ASSIGN_OPS (TYPE) \
1178  OCTAVE_INSTALL_INT_NULL_ASSIGN_OPS(TYPE)
1179 
1180 #define OCTAVE_INSTALL_SM_INT_ASSIGNCONV(TLHS, TRHS) \
1181  INSTALL_ASSIGNCONV (octave_ ## TLHS ## _scalar, octave_ ## TRHS ## _scalar, octave_ ## TLHS ## _matrix) \
1182  INSTALL_ASSIGNCONV (octave_ ## TLHS ## _scalar, octave_ ## TRHS ## _matrix, octave_ ## TLHS ## _matrix)
1183 
1184 #define OCTAVE_MIXED_INT_CMP_OPS(T1, T2) \
1185  OCTAVE_SS_INT_CMP_OPS (T1 ## _ ## T2 ## _ss, T1 ## _, T2 ## _) \
1186  OCTAVE_SM_INT_CMP_OPS (T1 ## _ ## T2 ## _sm, T1 ## _, T2 ## _) \
1187  OCTAVE_MS_INT_CMP_OPS (T1 ## _ ## T2 ## _ms, T1 ## _, T2 ## _) \
1188  OCTAVE_MM_INT_CMP_OPS (T1 ## _ ## T2 ## _mm, T1 ## _, T2 ## _)
1189 
1190 #define OCTAVE_INSTALL_MIXED_INT_CMP_OPS(T1, T2) \
1191  OCTAVE_INSTALL_SS_INT_CMP_OPS (T1 ## _ ## T2 ## _ss, T1 ## _, T2 ## _) \
1192  OCTAVE_INSTALL_SM_INT_CMP_OPS (T1 ## _ ## T2 ## _sm, T1 ## _, T2 ## _) \
1193  OCTAVE_INSTALL_MS_INT_CMP_OPS (T1 ## _ ## T2 ## _ms, T1 ## _, T2 ## _) \
1194  OCTAVE_INSTALL_MM_INT_CMP_OPS (T1 ## _ ## T2 ## _mm, T1 ## _, T2 ## _)
1195 
1196 #endif
Generated on Wed May 10 2017 15:42:53 for GNU Octave by   doxygen 1.8.8