Mercurial > octave
view libinterp/operators/op-int.h @ 30564:796f54d4ddbf stable
update Octave Project Developers copyright for the new year
In files that have the "Octave Project Developers" copyright notice,
update for 2021.
In all .txi and .texi files except gpl.txi and gpl.texi in the
doc/liboctave and doc/interpreter directories, change the copyright
to "Octave Project Developers", the same as used for other source
files. Update copyright notices for 2022 (not done since 2019). For
gpl.txi and gpl.texi, change the copyright notice to be "Free Software
Foundation, Inc." and leave the date at 2007 only because this file
only contains the text of the GPL, not anything created by the Octave
Project Developers.
Add Paul Thomas to contributors.in.
author | John W. Eaton <jwe@octave.org> |
---|---|
date | Tue, 28 Dec 2021 18:22:40 -0500 |
parents | b113fd9687ee |
children | 597f3ee61a48 |
line wrap: on
line source
//////////////////////////////////////////////////////////////////////// // // Copyright (C) 1996-2022 The Octave Project Developers // // See the file COPYRIGHT.md in the top-level directory of this // distribution or <https://octave.org/copyright/>. // // This file is part of Octave. // // Octave is free software: you can redistribute it and/or modify it // under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // Octave is distributed in the hope that it will be useful, but // WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with Octave; see the file COPYING. If not, see // <https://www.gnu.org/licenses/>. // //////////////////////////////////////////////////////////////////////// #if ! defined (octave_op_int_h) #define octave_op_int_h 1 #include "octave-config.h" #include "quit.h" #include "bsxfun.h" #define DEFINTBINOP_OP(name, t1, t2, op, t3) \ static octave_value \ CONCAT2 (oct_binop_, name) (const octave_base_value& a1, \ const octave_base_value& a2) \ { \ const octave_ ## t1& v1 = dynamic_cast<const octave_ ## t1&> (a1); \ const octave_ ## t2& v2 = dynamic_cast<const octave_ ## t2&> (a2); \ octave_value retval = octave_value \ (v1.t1 ## _value () op v2.t2 ## _value ()); \ return retval; \ } #define DEFINTNDBINOP_OP(name, t1, t2, e1, e2, op, t3) \ static octave_value \ CONCAT2 (oct_binop_, name) (const octave_base_value& a1, \ const octave_base_value& a2) \ { \ const octave_ ## t1& v1 = dynamic_cast<const octave_ ## t1&> (a1); \ const octave_ ## t2& v2 = dynamic_cast<const octave_ ## t2&> (a2); \ octave_value retval = octave_value \ (v1.e1 ## _value () op v2.e2 ## _value ()); \ return retval; \ } #define DEFINTBINOP_FN(name, t1, t2, f, t3, op) \ static octave_value \ CONCAT2 (oct_binop_, name) (const octave_base_value& a1, \ const octave_base_value& a2) \ { \ const octave_ ## t1& v1 = dynamic_cast<const octave_ ## t1&> (a1); \ const octave_ ## t2& v2 = dynamic_cast<const octave_ ## t2&> (a2); \ octave_value retval = octave_value (f (v1.t1 ## _value (), v2.t2 ## _value ())); \ return retval; \ } #define DEFINTNDBINOP_FN(name, t1, t2, e1, e2, f, t3, op) \ static octave_value \ CONCAT2 (oct_binop_, name) (const octave_base_value& a1, \ const octave_base_value& a2) \ { \ const octave_ ## t1& v1 = dynamic_cast<const octave_ ## t1&> (a1); \ const octave_ ## t2& v2 = dynamic_cast<const octave_ ## t2&> (a2); \ octave_value retval = octave_value (f (v1.e1 ## _value (), v2.e2 ## _value ())); \ return retval; \ } #define OCTAVE_CONCAT_FN2(T1, T2) \ DEFNDCATOP_FN2 (T1 ## _ ## T2 ## _s_s, T1 ## _scalar, T2 ## _scalar, , T1 ## NDArray, T1 ## _array, T2 ## _array, concat) \ DEFNDCATOP_FN2 (T1 ## _ ## T2 ## _s_m, T1 ## _scalar, T2 ## _matrix, , T1 ## NDArray, T1 ## _array, T2 ## _array, concat) \ DEFNDCATOP_FN2 (T1 ## _ ## T2 ## _m_s, T1 ## _matrix, T2 ## _scalar, , T1 ## NDArray, T1 ## _array, T2 ## _array, concat) \ DEFNDCATOP_FN2 (T1 ## _ ## T2 ## _m_m, T1 ## _matrix, T2 ## _matrix, , T1 ## NDArray, T1 ## _array, T2 ## _array, concat) #define OCTAVE_INSTALL_CONCAT_FN2(T1, T2) \ INSTALL_CATOP_TI (ti, octave_ ## T1 ## _scalar, octave_ ## T2 ## _scalar, T1 ## _ ## T2 ## _s_s) \ INSTALL_CATOP_TI (ti, octave_ ## T1 ## _scalar, octave_ ## T2 ## _matrix, T1 ## _ ## T2 ## _s_m) \ INSTALL_CATOP_TI (ti, octave_ ## T1 ## _matrix, octave_ ## T2 ## _scalar, T1 ## _ ## T2 ## _m_s) \ INSTALL_CATOP_TI (ti, octave_ ## T1 ## _matrix, octave_ ## T2 ## _matrix, T1 ## _ ## T2 ## _m_m) #define OCTAVE_DOUBLE_INT_CONCAT_FN(TYPE) \ DEFNDCATOP_FN2 (double ## _ ## TYPE ## _s_s, scalar, TYPE ## _scalar, TYPE ## NDArray, , array, TYPE ## _array, concat) \ DEFNDCATOP_FN2 (double ## _ ## TYPE ## _s_m, scalar, TYPE ## _matrix, TYPE ## NDArray, , array, TYPE ## _array, concat) \ DEFNDCATOP_FN2 (double ## _ ## TYPE ## _m_s, matrix, TYPE ## _scalar, TYPE ## NDArray, , array, TYPE ## _array, concat) \ DEFNDCATOP_FN2 (double ## _ ## TYPE ## _m_m, matrix, TYPE ## _matrix, TYPE ## NDArray, , array, TYPE ## _array, concat) #define OCTAVE_INSTALL_DOUBLE_INT_CONCAT_FN(TYPE) \ INSTALL_CATOP_TI (ti, octave_scalar, octave_ ## TYPE ## _scalar, double ## _ ## TYPE ## _s_s) \ INSTALL_CATOP_TI (ti, octave_scalar, octave_ ## TYPE ## _matrix, double ## _ ## TYPE ## _s_m) \ INSTALL_CATOP_TI (ti, octave_matrix, octave_ ## TYPE ## _scalar, double ## _ ## TYPE ## _m_s) \ INSTALL_CATOP_TI (ti, octave_matrix, octave_ ## TYPE ## _matrix, double ## _ ## TYPE ## _m_m) #define OCTAVE_INT_DOUBLE_CONCAT_FN(TYPE) \ DEFNDCATOP_FN2 (TYPE ## _ ## double ## _s_s, TYPE ## _scalar, scalar, , TYPE ## NDArray, TYPE ## _array, array, concat) \ DEFNDCATOP_FN2 (TYPE ## _ ## double ## _s_m, TYPE ## _scalar, matrix, , TYPE ## NDArray, TYPE ## _array, array, concat) \ DEFNDCATOP_FN2 (TYPE ## _ ## double ## _m_s, TYPE ## _matrix, scalar, , TYPE ## NDArray, TYPE ## _array, array, concat) \ DEFNDCATOP_FN2 (TYPE ## _ ## double ## _m_m, TYPE ## _matrix, matrix, , TYPE ## NDArray, TYPE ## _array, array, concat) #define OCTAVE_INSTALL_INT_DOUBLE_CONCAT_FN(TYPE) \ INSTALL_CATOP_TI (ti, octave_ ## TYPE ## _scalar, octave_scalar, TYPE ## _ ## double ## _s_s) \ INSTALL_CATOP_TI (ti, octave_ ## TYPE ## _scalar, octave_matrix, TYPE ## _ ## double ## _s_m) \ INSTALL_CATOP_TI (ti, octave_ ## TYPE ## _matrix, octave_scalar, TYPE ## _ ## double ## _m_s) \ INSTALL_CATOP_TI (ti, octave_ ## TYPE ## _matrix, octave_matrix, TYPE ## _ ## double ## _m_m) #define OCTAVE_FLOAT_INT_CONCAT_FN(TYPE) \ DEFNDCATOP_FN2 (float ## _ ## TYPE ## _s_s, float_scalar, TYPE ## _scalar, TYPE ## NDArray, , float_array, TYPE ## _array, concat) \ DEFNDCATOP_FN2 (float ## _ ## TYPE ## _s_m, float_scalar, TYPE ## _matrix, TYPE ## NDArray, , float_array, TYPE ## _array, concat) \ DEFNDCATOP_FN2 (float ## _ ## TYPE ## _m_s, float_matrix, TYPE ## _scalar, TYPE ## NDArray, , float_array, TYPE ## _array, concat) \ DEFNDCATOP_FN2 (float ## _ ## TYPE ## _m_m, float_matrix, TYPE ## _matrix, TYPE ## NDArray, , float_array, TYPE ## _array, concat) #define OCTAVE_INSTALL_FLOAT_INT_CONCAT_FN(TYPE) \ INSTALL_CATOP_TI (ti, octave_float_scalar, octave_ ## TYPE ## _scalar, float ## _ ## TYPE ## _s_s) \ INSTALL_CATOP_TI (ti, octave_float_scalar, octave_ ## TYPE ## _matrix, float ## _ ## TYPE ## _s_m) \ INSTALL_CATOP_TI (ti, octave_float_matrix, octave_ ## TYPE ## _scalar, float ## _ ## TYPE ## _m_s) \ INSTALL_CATOP_TI (ti, octave_float_matrix, octave_ ## TYPE ## _matrix, float ## _ ## TYPE ## _m_m) #define OCTAVE_INT_FLOAT_CONCAT_FN(TYPE) \ DEFNDCATOP_FN2 (TYPE ## _ ## float ## _s_s, TYPE ## _scalar, float_scalar, , TYPE ## NDArray, TYPE ## _array, float_array, concat) \ DEFNDCATOP_FN2 (TYPE ## _ ## float ## _s_m, TYPE ## _scalar, float_matrix, , TYPE ## NDArray, TYPE ## _array, float_array, concat) \ DEFNDCATOP_FN2 (TYPE ## _ ## float ## _m_s, TYPE ## _matrix, float_scalar, , TYPE ## NDArray, TYPE ## _array, float_array, concat) \ DEFNDCATOP_FN2 (TYPE ## _ ## float ## _m_m, TYPE ## _matrix, float_matrix, , TYPE ## NDArray, TYPE ## _array, float_array, concat) #define OCTAVE_INSTALL_INT_FLOAT_CONCAT_FN(TYPE) \ INSTALL_CATOP_TI (ti, octave_ ## TYPE ## _scalar, octave_float_scalar, TYPE ## _ ## float ## _s_s) \ INSTALL_CATOP_TI (ti, octave_ ## TYPE ## _scalar, octave_float_matrix, TYPE ## _ ## float ## _s_m) \ INSTALL_CATOP_TI (ti, octave_ ## TYPE ## _matrix, octave_float_scalar, TYPE ## _ ## float ## _m_s) \ INSTALL_CATOP_TI (ti, octave_ ## TYPE ## _matrix, octave_float_matrix, TYPE ## _ ## float ## _m_m) // For compatibility, concatenation with a character always returns a // character. #define OCTAVE_CHAR_INT_CONCAT_FN(TYPE) \ DEFNDCHARCATOP_FN (char ## _ ## TYPE ## _m_s, char_matrix, TYPE ## _scalar, concat) \ DEFNDCHARCATOP_FN (char ## _ ## TYPE ## _m_m, char_matrix, TYPE ## _matrix, concat) #define OCTAVE_INSTALL_CHAR_INT_CONCAT_FN(TYPE) \ INSTALL_CATOP_TI (ti, octave_char_matrix_str, octave_ ## TYPE ## _scalar, char ## _ ## TYPE ## _m_s) \ INSTALL_CATOP_TI (ti, octave_char_matrix_str, octave_ ## TYPE ## _matrix, char ## _ ## TYPE ## _m_m) \ INSTALL_CATOP_TI (ti, octave_char_matrix_sq_str, octave_ ## TYPE ## _scalar, char ## _ ## TYPE ## _m_s) \ INSTALL_CATOP_TI (ti, octave_char_matrix_sq_str, octave_ ## TYPE ## _matrix, char ## _ ## TYPE ## _m_m) #define OCTAVE_INT_CHAR_CONCAT_FN(TYPE) \ DEFNDCHARCATOP_FN (TYPE ## _ ## char ## _s_m, TYPE ## _scalar, char_matrix, concat) \ DEFNDCHARCATOP_FN (TYPE ## _ ## char ## _m_m, TYPE ## _matrix, char_matrix, concat) #define OCTAVE_INSTALL_INT_CHAR_CONCAT_FN(TYPE) \ INSTALL_CATOP_TI (ti, octave_ ## TYPE ## _scalar, octave_char_matrix_str, TYPE ## _ ## char ## _s_m) \ INSTALL_CATOP_TI (ti, octave_ ## TYPE ## _matrix, octave_char_matrix_str, TYPE ## _ ## char ## _m_m) \ INSTALL_CATOP_TI (ti, octave_ ## TYPE ## _scalar, octave_char_matrix_sq_str, TYPE ## _ ## char ## _s_m) \ INSTALL_CATOP_TI (ti, octave_ ## TYPE ## _matrix, octave_char_matrix_sq_str, TYPE ## _ ## char ## _m_m) #define OCTAVE_CONCAT_FN(TYPE) \ DEFNDCATOP_FN (TYPE ## _s_s, TYPE ## _scalar, TYPE ## _scalar, TYPE ## _array, TYPE ## _array, concat) \ DEFNDCATOP_FN (TYPE ## _s_m, TYPE ## _scalar, TYPE ## _matrix, TYPE ## _array, TYPE ## _array, concat) \ DEFNDCATOP_FN (TYPE ## _m_s, TYPE ## _matrix, TYPE ## _scalar, TYPE ## _array, TYPE ## _array, concat) \ DEFNDCATOP_FN (TYPE ## _m_m, TYPE ## _matrix, TYPE ## _matrix, TYPE ## _array, TYPE ## _array, concat) #define OCTAVE_INSTALL_CONCAT_FN(TYPE) \ INSTALL_CATOP_TI (ti, octave_ ## TYPE ## _scalar, octave_ ## TYPE ## _scalar, TYPE ## _s_s) \ INSTALL_CATOP_TI (ti, octave_ ## TYPE ## _scalar, octave_ ## TYPE ## _matrix, TYPE ## _s_m) \ INSTALL_CATOP_TI (ti, octave_ ## TYPE ## _matrix, octave_ ## TYPE ## _scalar, TYPE ## _m_s) \ INSTALL_CATOP_TI (ti, octave_ ## TYPE ## _matrix, octave_ ## TYPE ## _matrix, TYPE ## _m_m) // scalar unary ops. #define OCTAVE_S_INT_UNOPS(TYPE) \ \ DEFUNOP_OP (s_not, TYPE ## _scalar, !) \ DEFUNOP_OP (s_uplus, TYPE ## _scalar, /* no-op */) \ DEFUNOP (s_uminus, TYPE ## _scalar) \ { \ const octave_ ## TYPE ## _scalar & v = dynamic_cast<const octave_ ## TYPE ## _scalar &> (a); \ octave_value retval = octave_value (- v. TYPE ## _scalar_value ()); \ return retval; \ } \ DEFUNOP_OP (s_transpose, TYPE ## _scalar, /* no-op */) \ DEFUNOP_OP (s_hermitian, TYPE ## _scalar, /* no-op */) \ \ DEFNCUNOP_METHOD (s_incr, TYPE ## _scalar, increment) \ DEFNCUNOP_METHOD (s_decr, TYPE ## _scalar, decrement) // scalar by scalar ops. #define OCTAVE_SS_INT_ARITH_OPS(PFX, T1, T2, T3) \ \ DEFINTBINOP_OP (PFX ## _add, T1 ## scalar, T2 ## scalar, +, T3) \ DEFINTBINOP_OP (PFX ## _sub, T1 ## scalar, T2 ## scalar, -, T3) \ DEFINTBINOP_OP (PFX ## _mul, T1 ## scalar, T2 ## scalar, *, T3) \ \ DEFBINOP (PFX ## _div, T1 ## scalar, T2 ## scalar) \ { \ const octave_ ## T1 ## scalar& v1 = dynamic_cast<const octave_ ## T1 ## scalar&> (a1); \ const octave_ ## T2 ## scalar& v2 = dynamic_cast<const octave_ ## T2 ## scalar&> (a2); \ \ return octave_value (v1.T1 ## scalar_value () / v2.T2 ## scalar_value ()); \ } \ \ DEFINTBINOP_FN (PFX ## _pow, T1 ## scalar, T2 ## scalar, xpow, T3, ^) \ \ DEFBINOP (PFX ## _ldiv, T1 ## scalar, T2 ## scalar) \ { \ const octave_ ## T1 ## scalar& v1 = dynamic_cast<const octave_ ## T1 ## scalar&> (a1); \ const octave_ ## T2 ## scalar& v2 = dynamic_cast<const octave_ ## T2 ## scalar&> (a2); \ \ return octave_value (v2.T2 ## scalar_value () / v1.T1 ## scalar_value ()); \ } \ \ DEFINTBINOP_OP (PFX ## _el_mul, T1 ## scalar, T2 ## scalar, *, T3) \ \ DEFBINOP (PFX ## _el_div, T1 ## scalar, T2 ## scalar) \ { \ const octave_ ## T1 ## scalar& v1 = dynamic_cast<const octave_ ## T1 ## scalar&> (a1); \ const octave_ ## T2 ## scalar& v2 = dynamic_cast<const octave_ ## T2 ## scalar&> (a2); \ \ return octave_value (v1.T1 ## scalar_value () / v2.T2 ## scalar_value ()); \ } \ \ DEFINTBINOP_FN (PFX ## _el_pow, T1 ## scalar, T2 ## scalar, xpow, T3, .^) \ \ DEFBINOP (PFX ## _el_ldiv, T1 ## scalar, T2 ## scalar) \ { \ const octave_ ## T1 ## scalar& v1 = dynamic_cast<const octave_ ## T1 ## scalar&> (a1); \ const octave_ ## T2 ## scalar& v2 = dynamic_cast<const octave_ ## T2 ## scalar&> (a2); \ \ return octave_value (v2.T2 ## scalar_value () / v1.T1 ## scalar_value ()); \ } #define OCTAVE_SS_INT_BOOL_OPS(PFX, T1, T2, Z1, Z2) \ DEFBINOP (PFX ## _el_and, T2, T2) \ { \ const octave_ ## T1 ## scalar& v1 = dynamic_cast<const octave_ ## T1 ## scalar&> (a1); \ const octave_ ## T2 ## scalar& v2 = dynamic_cast<const octave_ ## T2 ## scalar&> (a2); \ \ return v1.T1 ## scalar_value () != Z1 && v2.T2 ## scalar_value () != Z2; \ } \ \ DEFBINOP (PFX ## _el_or, T1, T2) \ { \ const octave_ ## T1 ## scalar& v1 = dynamic_cast<const octave_ ## T1 ## scalar&> (a1); \ const octave_ ## T2 ## scalar& v2 = dynamic_cast<const octave_ ## T2 ## scalar&> (a2); \ \ return v1.T1 ## scalar_value () != Z1 || v2.T2 ## scalar_value () != Z2; \ } #define OCTAVE_SS_INT_CMP_OPS(PFX, T1, T2) \ DEFBINOP_OP (PFX ## _lt, T1 ## scalar, T2 ## scalar, <) \ DEFBINOP_OP (PFX ## _le, T1 ## scalar, T2 ## scalar, <=) \ DEFBINOP_OP (PFX ## _eq, T1 ## scalar, T2 ## scalar, ==) \ DEFBINOP_OP (PFX ## _ge, T1 ## scalar, T2 ## scalar, >=) \ DEFBINOP_OP (PFX ## _gt, T1 ## scalar, T2 ## scalar, >) \ DEFBINOP_OP (PFX ## _ne, T1 ## scalar, T2 ## scalar, !=) #define OCTAVE_SS_POW_OPS(T1, T2) \ static octave_value \ xpow (const octave_ ## T1& a, const octave_ ## T2& b) \ { \ return pow (a, b); \ } \ \ static octave_value \ xpow (const octave_ ## T1& a, double b) \ { \ return pow (a, b); \ } \ \ static octave_value \ xpow (double a, const octave_ ## T1& b) \ { \ return pow (a, b); \ } \ \ static octave_value \ xpow (const octave_ ## T1& a, float b) \ { \ return powf (a, b); \ } \ \ static octave_value \ xpow (float a, const octave_ ## T1& b) \ { \ return powf (a, b); \ } #define OCTAVE_SS_INT_OPS(TYPE) \ OCTAVE_S_INT_UNOPS (TYPE) \ OCTAVE_SS_POW_OPS (TYPE, TYPE) \ OCTAVE_SS_INT_ARITH_OPS (ss, TYPE ## _, TYPE ## _, TYPE) \ OCTAVE_SS_INT_ARITH_OPS (ssx, TYPE ## _, , TYPE) \ OCTAVE_SS_INT_ARITH_OPS (sxs, , TYPE ## _, TYPE) \ OCTAVE_SS_INT_ARITH_OPS (ssfx, TYPE ## _, float_, TYPE) \ OCTAVE_SS_INT_ARITH_OPS (sfxs, float_, TYPE ## _, TYPE) \ OCTAVE_SS_INT_CMP_OPS (ss, TYPE ## _, TYPE ## _) \ OCTAVE_SS_INT_CMP_OPS (sx, TYPE ## _, ) \ OCTAVE_SS_INT_CMP_OPS (xs, , TYPE ## _) \ OCTAVE_SS_INT_CMP_OPS (sfx, TYPE ## _, float_) \ OCTAVE_SS_INT_CMP_OPS (fxs, float_, TYPE ## _) \ OCTAVE_SS_INT_BOOL_OPS (ss, TYPE ## _, TYPE ## _, octave_ ## TYPE (0), octave_ ## TYPE (0)) \ OCTAVE_SS_INT_BOOL_OPS (sx, TYPE ## _, , octave_ ## TYPE (0), 0) \ OCTAVE_SS_INT_BOOL_OPS (xs, , TYPE ## _, 0, octave_ ## TYPE (0)) \ OCTAVE_SS_INT_BOOL_OPS (sfx, TYPE ## _, float_, octave_ ## TYPE (0), 0) \ OCTAVE_SS_INT_BOOL_OPS (fxs, float_, TYPE ## _, 0, octave_ ## TYPE (0)) // scalar by matrix ops. #define OCTAVE_SM_INT_ARITH_OPS(PFX, TS, TM, TI) \ \ DEFINTNDBINOP_OP (PFX ## _add, TS ## scalar, TM ## matrix, TS ## scalar, TM ## array, +, TI) \ DEFINTNDBINOP_OP (PFX ## _sub, TS ## scalar, TM ## matrix, TS ## scalar, TM ## array, -, TI) \ DEFINTNDBINOP_OP (PFX ## _mul, TS ## scalar, TM ## matrix, TS ## scalar, TM ## array, *, TI) \ \ /* DEFBINOP (PFX ## _div, TS ## scalar, TM ## matrix) */ \ /* { */ \ /* const octave_ ## TS ## scalar& v1 = dynamic_cast<const octave_ ## TS ## scalar&> (a1); */ \ /* const octave_ ## TM ## matrix& v2 = dynamic_cast<const octave_ ## TM ## matrix&> (a2); */ \ /* */ \ /* Matrix m1 = v1.TM ## matrix_value (); */ \ /* Matrix m2 = v2.TM ## matrix_value (); */ \ /* */ \ /* return octave_value (xdiv (m1, m2)); */ \ /* } */ \ \ /* DEFBINOP_FN (PFX ## _pow, TS ## scalar, TM ## matrix, xpow) */ \ \ DEFBINOP (PFX ## _ldiv, TS ## scalar, TM ## matrix) \ { \ const octave_ ## TS ## scalar& v1 = dynamic_cast<const octave_ ## TS ## scalar&> (a1); \ const octave_ ## TM ## matrix& v2 = dynamic_cast<const octave_ ## TM ## matrix&> (a2); \ \ return octave_value (v2.TM ## array_value () / v1.TS ## scalar_value ()); \ } \ \ DEFINTNDBINOP_OP (PFX ## _el_mul, TS ## scalar, TM ## matrix, TS ## scalar, TM ## array, *, TI) \ DEFBINOP (PFX ## _el_div, TS ## scalar, TM ## matrix) \ { \ const octave_ ## TS ## scalar& v1 = dynamic_cast<const octave_ ## TS ## scalar&> (a1); \ const octave_ ## TM ## matrix& v2 = dynamic_cast<const octave_ ## TM ## matrix&> (a2); \ \ octave_value retval = octave_value (v1.TS ## scalar_value () / v2.TM ## array_value ()); \ return retval; \ } \ \ DEFINTNDBINOP_FN (PFX ## _el_pow, TS ## scalar, TM ## matrix, TS ## scalar, TM ## array, elem_xpow, TI, .^) \ \ DEFBINOP (PFX ## _el_ldiv, TS ## scalar, TM ## matrix) \ { \ const octave_ ## TS ## scalar& v1 = dynamic_cast<const octave_ ## TS ## scalar&> (a1); \ const octave_ ## TM ## matrix& v2 = dynamic_cast<const octave_ ## TM ## matrix&> (a2); \ \ return octave_value (v2.TM ## array_value () / v1.TS ## scalar_value ()); \ } #define OCTAVE_SM_INT_CMP_OPS(PFX, TS, TM) \ DEFNDBINOP_FN (PFX ## _lt, TS ## scalar, TM ## matrix, TS ## scalar, TM ## array, mx_el_lt) \ DEFNDBINOP_FN (PFX ## _le, TS ## scalar, TM ## matrix, TS ## scalar, TM ## array, mx_el_le) \ DEFNDBINOP_FN (PFX ## _eq, TS ## scalar, TM ## matrix, TS ## scalar, TM ## array, mx_el_eq) \ DEFNDBINOP_FN (PFX ## _ge, TS ## scalar, TM ## matrix, TS ## scalar, TM ## array, mx_el_ge) \ DEFNDBINOP_FN (PFX ## _gt, TS ## scalar, TM ## matrix, TS ## scalar, TM ## array, mx_el_gt) \ DEFNDBINOP_FN (PFX ## _ne, TS ## scalar, TM ## matrix, TS ## scalar, TM ## array, mx_el_ne) #define OCTAVE_SM_INT_BOOL_OPS(PFX, TS, TM) \ DEFNDBINOP_FN (PFX ## _el_and, TS ## scalar, TM ## matrix, TS ## scalar, TM ## array, mx_el_and) \ DEFNDBINOP_FN (PFX ## _el_or, TS ## scalar, TM ## matrix, TS ## scalar, TM ## array, mx_el_or) \ DEFNDBINOP_FN (PFX ## _el_and_not, TS ## scalar, TM ## matrix, TS ## scalar, TM ## array, mx_el_and_not) \ DEFNDBINOP_FN (PFX ## _el_or_not, TS ## scalar, TM ## matrix, TS ## scalar, TM ## array, mx_el_or_not) #define OCTAVE_SM_POW_OPS(T1, T2) \ static octave_value \ elem_xpow (const octave_ ## T1& a, const T2 ## NDArray& b) \ { \ T2 ## NDArray result (b.dims ()); \ for (int i = 0; i < b.numel (); i++) \ { \ octave_quit (); \ result (i) = pow (a, b(i)); \ } \ return octave_value (result); \ } \ \ static octave_value \ elem_xpow (const octave_ ## T1& a, const NDArray& b) \ { \ T1 ## NDArray result (b.dims ()); \ for (int i = 0; i < b.numel (); i++) \ { \ octave_quit (); \ result (i) = pow (a, b(i)); \ } \ return octave_value (result); \ } \ \ static octave_value \ elem_xpow (double a, const T2 ## NDArray& b) \ { \ T2 ## NDArray result (b.dims ()); \ for (int i = 0; i < b.numel (); i++) \ { \ octave_quit (); \ result (i) = pow (a, b(i)); \ } \ return octave_value (result); \ } \ \ static octave_value \ elem_xpow (const octave_ ## T1& a, const FloatNDArray& b) \ { \ T1 ## NDArray result (b.dims ()); \ for (int i = 0; i < b.numel (); i++) \ { \ octave_quit (); \ result (i) = powf (a, b(i)); \ } \ return octave_value (result); \ } \ \ static octave_value \ elem_xpow (float a, const T2 ## NDArray& b) \ { \ T2 ## NDArray result (b.dims ()); \ for (int i = 0; i < b.numel (); i++) \ { \ octave_quit (); \ result (i) = powf (a, b(i)); \ } \ return octave_value (result); \ } #define OCTAVE_SM_CONV(TS, TM) \ DEFCONV (TS ## s_ ## TM ## m_conv, TM ## scalar, TM ## matrix) \ { \ const octave_ ## TS ## scalar& v = dynamic_cast<const octave_ ## TS ## scalar&> (a); \ \ return new octave_ ## TM ## matrix (v.TM ## array_value ()); \ } #define OCTAVE_SM_INT_OPS(TYPE) \ OCTAVE_SM_POW_OPS (TYPE, TYPE) \ OCTAVE_SM_INT_ARITH_OPS (sm, TYPE ## _, TYPE ## _, TYPE) \ OCTAVE_SM_INT_ARITH_OPS (smx, TYPE ## _, , TYPE) \ OCTAVE_SM_INT_ARITH_OPS (sxm, , TYPE ## _, TYPE) \ OCTAVE_SM_INT_ARITH_OPS (smfx, TYPE ## _, float_, TYPE) \ OCTAVE_SM_INT_ARITH_OPS (sfxm, float_, TYPE ## _, TYPE) \ OCTAVE_SM_INT_CMP_OPS (sm, TYPE ## _, TYPE ## _) \ OCTAVE_SM_INT_CMP_OPS (xm, , TYPE ## _) \ OCTAVE_SM_INT_CMP_OPS (smx, TYPE ## _, ) \ OCTAVE_SM_INT_CMP_OPS (fxm, float_, TYPE ## _) \ OCTAVE_SM_INT_CMP_OPS (smfx, TYPE ## _, float_) \ OCTAVE_SM_INT_BOOL_OPS (sm, TYPE ## _, TYPE ## _) \ OCTAVE_SM_INT_BOOL_OPS (xm, , TYPE ## _) \ OCTAVE_SM_INT_BOOL_OPS (smx, TYPE ## _, ) \ OCTAVE_SM_INT_BOOL_OPS (fxm, float_, TYPE ## _) \ OCTAVE_SM_INT_BOOL_OPS (smfx, TYPE ## _, float_) \ OCTAVE_SM_CONV (TYPE ## _, TYPE ## _) \ OCTAVE_SM_CONV (TYPE ## _, complex_) \ OCTAVE_SM_CONV (TYPE ## _, float_complex_) // matrix by scalar ops. #define OCTAVE_MS_INT_ARITH_OPS(PFX, TM, TS, TI) \ \ DEFINTNDBINOP_OP (PFX ## _add, TM ## matrix, TS ## scalar, TM ## array, TS ## scalar, +, TI) \ DEFINTNDBINOP_OP (PFX ## _sub, TM ## matrix, TS ## scalar, TM ## array, TS ## scalar, -, TI) \ DEFINTNDBINOP_OP (PFX ## _mul, TM ## matrix, TS ## scalar, TM ## array, TS ## scalar, *, TI) \ \ DEFBINOP (PFX ## _div, TM ## matrix, TS ## scalar) \ { \ const octave_ ## TM ## matrix& v1 = dynamic_cast<const octave_ ## TM ## matrix&> (a1); \ const octave_ ## TS ## scalar& v2 = dynamic_cast<const octave_ ## TS ## scalar&> (a2); \ \ return octave_value (v1.TM ## array_value () / v2.TS ## scalar_value ()); \ } \ \ /* DEFBINOP_FN (PFX ## _pow, TM ## matrix, TS ## scalar, xpow) */ \ \ /* DEFBINOP (PFX ## _ldiv, TM ## matrix, TS ## scalar) */ \ /* { */ \ /* const octave_ ## TM ## matrix& v1 = dynamic_cast<const octave_ ## TM ## matrix&> (a1); */ \ /* const octave_ ## TS ## scalar& v2 = dynamic_cast<const octave_ ## TS ## scalar&> (a2); */ \ /* */ \ /* Matrix m1 = v1.TM ## matrix_value (); */ \ /* Matrix m2 = v2.TM ## matrix_value (); */ \ /* */ \ /* return octave_value (xleftdiv (m1, m2)); */ \ /* } */ \ \ DEFINTNDBINOP_OP (PFX ## _el_mul, TM ## matrix, TS ## scalar, TM ## array, TS ## scalar, *, TI) \ \ DEFBINOP (PFX ## _el_div, TM ## matrix, TS ## scalar) \ { \ const octave_ ## TM ## matrix& v1 = dynamic_cast<const octave_ ## TM ## matrix&> (a1); \ const octave_ ## TS ## scalar& v2 = dynamic_cast<const octave_ ## TS ## scalar&> (a2); \ \ return octave_value (v1.TM ## array_value () / v2.TS ## scalar_value ()); \ } \ \ DEFINTNDBINOP_FN (PFX ## _el_pow, TM ## matrix, TS ## scalar, TM ## array, TS ## scalar, elem_xpow, TI, .^) \ \ DEFBINOP (PFX ## _el_ldiv, TM ## matrix, TS ## scalar) \ { \ const octave_ ## TM ## matrix& v1 = dynamic_cast<const octave_ ## TM ## matrix&> (a1); \ const octave_ ## TS ## scalar& v2 = dynamic_cast<const octave_ ## TS ## scalar&> (a2); \ \ octave_value retval = v2.TS ## scalar_value () / v1.TM ## array_value (); \ return retval; \ } #define OCTAVE_MS_INT_CMP_OPS(PFX, TM, TS) \ DEFNDBINOP_FN (PFX ## _lt, TM ## matrix, TS ## scalar, TM ## array, TS ## scalar, mx_el_lt) \ DEFNDBINOP_FN (PFX ## _le, TM ## matrix, TS ## scalar, TM ## array, TS ## scalar, mx_el_le) \ DEFNDBINOP_FN (PFX ## _eq, TM ## matrix, TS ## scalar, TM ## array, TS ## scalar, mx_el_eq) \ DEFNDBINOP_FN (PFX ## _ge, TM ## matrix, TS ## scalar, TM ## array, TS ## scalar, mx_el_ge) \ DEFNDBINOP_FN (PFX ## _gt, TM ## matrix, TS ## scalar, TM ## array, TS ## scalar, mx_el_gt) \ DEFNDBINOP_FN (PFX ## _ne, TM ## matrix, TS ## scalar, TM ## array, TS ## scalar, mx_el_ne) #define OCTAVE_MS_INT_BOOL_OPS(PFX, TM, TS) \ DEFNDBINOP_FN (PFX ## _el_and, TM ## matrix, TS ## scalar, TM ## array, TS ## scalar, mx_el_and) \ DEFNDBINOP_FN (PFX ## _el_or, TM ## matrix, TS ## scalar, TM ## array, TS ## scalar, mx_el_or) \ DEFNDBINOP_FN (PFX ## _el_not_and, TM ## matrix, TS ## scalar, TM ## array, TS ## scalar, mx_el_not_and) \ DEFNDBINOP_FN (PFX ## _el_not_or, TM ## matrix, TS ## scalar, TM ## array, TS ## scalar, mx_el_not_or) #define OCTAVE_MS_INT_ASSIGN_OPS(PFX, TM, TS, TE) \ DEFNDASSIGNOP_FN (PFX ## _assign, TM ## matrix, TS ## scalar, TM ## scalar, assign) #define OCTAVE_MS_INT_ASSIGNEQ_OPS(PFX, TM) \ DEFNDASSIGNOP_OP (PFX ## _assign_add, TM ## matrix, TM ## scalar, TM ## scalar, +=) \ DEFNDASSIGNOP_OP (PFX ## _assign_sub, TM ## matrix, TM ## scalar, TM ## scalar, -=) \ DEFNDASSIGNOP_OP (PFX ## _assign_mul, TM ## matrix, TM ## scalar, TM ## scalar, *=) \ DEFNDASSIGNOP_OP (PFX ## _assign_div, TM ## matrix, TM ## scalar, TM ## scalar, /=) #define OCTAVE_MS_POW_OPS(T1, T2) \ static octave_value \ elem_xpow (T1 ## NDArray a, octave_ ## T2 b) \ { \ T1 ## NDArray result (a.dims ()); \ for (int i = 0; i < a.numel (); i++) \ { \ octave_quit (); \ result (i) = pow (a(i), b); \ } \ return octave_value (result); \ } \ \ static octave_value \ elem_xpow (T1 ## NDArray a, double b) \ { \ T1 ## NDArray result (a.dims ()); \ for (int i = 0; i < a.numel (); i++) \ { \ octave_quit (); \ result (i) = pow (a(i), b); \ } \ return octave_value (result); \ } \ \ static octave_value \ elem_xpow (NDArray a, octave_ ## T2 b) \ { \ T2 ## NDArray result (a.dims ()); \ for (int i = 0; i < a.numel (); i++) \ { \ octave_quit (); \ result (i) = pow (a(i), b); \ } \ return octave_value (result); \ } \ \ static octave_value \ elem_xpow (T1 ## NDArray a, float b) \ { \ T1 ## NDArray result (a.dims ()); \ for (int i = 0; i < a.numel (); i++) \ { \ octave_quit (); \ result (i) = powf (a(i), b); \ } \ return octave_value (result); \ } \ \ static octave_value \ elem_xpow (FloatNDArray a, octave_ ## T2 b) \ { \ T2 ## NDArray result (a.dims ()); \ for (int i = 0; i < a.numel (); i++) \ { \ octave_quit (); \ result (i) = powf (a(i), b); \ } \ return octave_value (result); \ } #define OCTAVE_MS_INT_OPS(TYPE) \ OCTAVE_MS_POW_OPS (TYPE, TYPE) \ OCTAVE_MS_INT_ARITH_OPS (ms, TYPE ## _, TYPE ## _, TYPE) \ OCTAVE_MS_INT_ARITH_OPS (msx, TYPE ## _, , TYPE) \ OCTAVE_MS_INT_ARITH_OPS (mxs, , TYPE ## _, TYPE) \ OCTAVE_MS_INT_ARITH_OPS (msfx, TYPE ## _, float_, TYPE) \ OCTAVE_MS_INT_ARITH_OPS (mfxs, float_, TYPE ## _, TYPE) \ OCTAVE_MS_INT_CMP_OPS (ms, TYPE ## _, TYPE ## _) \ OCTAVE_MS_INT_CMP_OPS (mx, TYPE ## _, ) \ OCTAVE_MS_INT_CMP_OPS (mxs, , TYPE ## _) \ OCTAVE_MS_INT_CMP_OPS (mfx, TYPE ## _, float_) \ OCTAVE_MS_INT_CMP_OPS (mfxs, float_, TYPE ## _) \ OCTAVE_MS_INT_BOOL_OPS (ms, TYPE ## _, TYPE ## _) \ OCTAVE_MS_INT_BOOL_OPS (mx, TYPE ## _, ) \ OCTAVE_MS_INT_BOOL_OPS (mxs, , TYPE ## _) \ OCTAVE_MS_INT_BOOL_OPS (mfx, TYPE ## _, float_) \ OCTAVE_MS_INT_BOOL_OPS (mfxs, float_, TYPE ## _) \ OCTAVE_MS_INT_ASSIGN_OPS (ms, TYPE ## _, TYPE ## _, TYPE ## _) \ OCTAVE_MS_INT_ASSIGNEQ_OPS (mse, TYPE ## _) \ OCTAVE_MS_INT_ASSIGN_OPS (mx, TYPE ## _, , ) \ OCTAVE_MS_INT_ASSIGN_OPS (mfx, TYPE ## _, float_, float_) // matrix unary ops. #define OCTAVE_M_INT_UNOPS(TYPE) \ \ DEFNDUNOP_OP (m_not, TYPE ## _matrix, TYPE ## _array, !) \ DEFNDUNOP_OP (m_uplus, TYPE ## _matrix, TYPE ## _array, /* no-op */) \ DEFUNOP (m_uminus, TYPE ## _matrix) \ { \ const octave_ ## TYPE ## _matrix & v = dynamic_cast<const octave_ ## TYPE ## _matrix &> (a); \ octave_value retval = octave_value (- v. TYPE ## _array_value ()); \ return retval; \ } \ \ DEFUNOP (m_transpose, TYPE ## _matrix) \ { \ const octave_ ## TYPE ## _matrix& v = dynamic_cast<const octave_ ## TYPE ## _matrix&> (a); \ \ if (v.ndims () > 2) \ error ("transpose not defined for N-D objects"); \ \ return octave_value (v.TYPE ## _array_value ().transpose ()); \ } \ \ DEFNCUNOP_METHOD (m_incr, TYPE ## _matrix, increment) \ DEFNCUNOP_METHOD (m_decr, TYPE ## _matrix, decrement) \ DEFNCUNOP_METHOD (m_changesign, TYPE ## _matrix, changesign) // matrix by matrix ops. #define OCTAVE_MM_INT_ARITH_OPS(PFX, T1, T2, T3) \ \ DEFINTNDBINOP_OP (PFX ## _add, T1 ## matrix, T2 ## matrix, T1 ## array, T2 ## array, +, T3) \ DEFINTNDBINOP_OP (PFX ## _sub, T1 ## matrix, T2 ## matrix, T1 ## array, T2 ## array, -, T3) \ \ /* DEFBINOP_OP (PFX ## _mul, T1 ## matrix, T2 ## matrix, *) */ \ /* DEFBINOP_FN (PFX ## _div, T1 ## matrix, T2 ## matrix, xdiv) */ \ \ DEFBINOPX (PFX ## _pow, T1 ## matrix, T2 ## matrix) \ { \ error ("can't do A ^ B for A and B both matrices"); \ } \ \ /* DEFBINOP_FN (PFX ## _ldiv, T1 ## matrix, T2 ## matrix, xleftdiv) */ \ \ DEFINTNDBINOP_FN (PFX ## _el_mul, T1 ## matrix, T2 ## matrix, T1 ## array, T2 ## array, product, T3, .*) \ \ DEFINTNDBINOP_FN (PFX ## _el_div, T1 ## matrix, T2 ## matrix, T1 ## array, T2 ## array, quotient, T3, ./) \ \ DEFINTNDBINOP_FN (PFX ## _el_pow, T1 ## matrix, T2 ## matrix, T1 ## array, T2 ## array, elem_xpow, T3, .^) \ \ DEFBINOP (PFX ## _el_ldiv, T1 ## matrix, T2 ## matrix) \ { \ const octave_ ## T1 ## matrix& v1 = dynamic_cast<const octave_ ## T1 ## matrix&> (a1); \ const octave_ ## T2 ## matrix& v2 = dynamic_cast<const octave_ ## T2 ## matrix&> (a2); \ \ octave_value retval = octave_value (quotient (v2.T2 ## array_value (), v1.T1 ## array_value ())); \ return retval; \ } #define OCTAVE_MM_INT_CMP_OPS(PFX, T1, T2) \ DEFNDBINOP_FN (PFX ## _lt, T1 ## matrix, T2 ## matrix, T1 ## array, T2 ## array, mx_el_lt) \ DEFNDBINOP_FN (PFX ## _le, T1 ## matrix, T2 ## matrix, T1 ## array, T2 ## array, mx_el_le) \ DEFNDBINOP_FN (PFX ## _eq, T1 ## matrix, T2 ## matrix, T1 ## array, T2 ## array, mx_el_eq) \ DEFNDBINOP_FN (PFX ## _ge, T1 ## matrix, T2 ## matrix, T1 ## array, T2 ## array, mx_el_ge) \ DEFNDBINOP_FN (PFX ## _gt, T1 ## matrix, T2 ## matrix, T1 ## array, T2 ## array, mx_el_gt) \ DEFNDBINOP_FN (PFX ## _ne, T1 ## matrix, T2 ## matrix, T1 ## array, T2 ## array, mx_el_ne) #define OCTAVE_MM_INT_BOOL_OPS(PFX, T1, T2) \ DEFNDBINOP_FN (PFX ## _el_and, T1 ## matrix, T2 ## matrix, T1 ## array, T2 ## array, mx_el_and) \ DEFNDBINOP_FN (PFX ## _el_or, T1 ## matrix, T2 ## matrix, T1 ## array, T2 ## array, mx_el_or) \ DEFNDBINOP_FN (PFX ## _el_not_and, T1 ## matrix, T2 ## matrix, T1 ## array, T2 ## array, mx_el_not_and) \ DEFNDBINOP_FN (PFX ## _el_not_or, T1 ## matrix, T2 ## matrix, T1 ## array, T2 ## array, mx_el_not_or) \ DEFNDBINOP_FN (PFX ## _el_and_not, T1 ## matrix, T2 ## matrix, T1 ## array, T2 ## array, mx_el_and_not) \ DEFNDBINOP_FN (PFX ## _el_or_not, T1 ## matrix, T2 ## matrix, T1 ## array, T2 ## array, mx_el_or_not) #define OCTAVE_MM_INT_ASSIGN_OPS(PFX, TLHS, TRHS, TE) \ DEFNDASSIGNOP_FN (PFX ## _assign, TLHS ## matrix, TRHS ## matrix, TLHS ## array, assign) #define OCTAVE_MM_INT_ASSIGNEQ_OPS(PFX, TM) \ DEFNDASSIGNOP_OP (PFX ## _assign_add, TM ## matrix, TM ## matrix, TM ## array, +=) \ DEFNDASSIGNOP_OP (PFX ## _assign_sub, TM ## matrix, TM ## matrix, TM ## array, -=) \ DEFNDASSIGNOP_FNOP (PFX ## _assign_el_mul, TM ## matrix, TM ## matrix, TM ## array, product_eq) \ DEFNDASSIGNOP_FNOP (PFX ## _assign_el_div, TM ## matrix, TM ## matrix, TM ## array, quotient_eq) #define OCTAVE_MM_POW_OPS(T1, T2) \ static octave_value \ elem_xpow (const T1 ## NDArray& a, const T2 ## NDArray& b) \ { \ dim_vector a_dims = a.dims (); \ dim_vector b_dims = b.dims (); \ if (a_dims != b_dims) \ { \ if (! is_valid_bsxfun ("operator .^", a_dims, b_dims)) \ octave::err_nonconformant ("operator .^", a_dims, b_dims); \ \ return bsxfun_pow (a, b); \ } \ T1 ## NDArray result (a_dims); \ for (int i = 0; i < a.numel (); i++) \ { \ octave_quit (); \ result (i) = pow (a(i), b(i)); \ } \ return octave_value (result); \ } \ \ static octave_value \ elem_xpow (const T1 ## NDArray& a, const NDArray& b) \ { \ dim_vector a_dims = a.dims (); \ dim_vector b_dims = b.dims (); \ if (a_dims != b_dims) \ { \ if (! is_valid_bsxfun ("operator .^", a_dims, b_dims)) \ octave::err_nonconformant ("operator .^", a_dims, b_dims); \ \ return bsxfun_pow (a, b); \ } \ T1 ## NDArray result (a_dims); \ for (int i = 0; i < a.numel (); i++) \ { \ octave_quit (); \ result (i) = pow (a(i), b(i)); \ } \ return octave_value (result); \ } \ \ static octave_value \ elem_xpow (const NDArray& a, const T2 ## NDArray& b) \ { \ dim_vector a_dims = a.dims (); \ dim_vector b_dims = b.dims (); \ if (a_dims != b_dims) \ { \ if (! is_valid_bsxfun ("operator .^", a_dims, b_dims)) \ octave::err_nonconformant ("operator .^", a_dims, b_dims); \ \ return bsxfun_pow (a, b); \ } \ T2 ## NDArray result (a_dims); \ for (int i = 0; i < a.numel (); i++) \ { \ octave_quit (); \ result (i) = pow (a(i), b(i)); \ } \ return octave_value (result); \ } \ \ static octave_value \ elem_xpow (const T1 ## NDArray& a, const FloatNDArray& b) \ { \ dim_vector a_dims = a.dims (); \ dim_vector b_dims = b.dims (); \ if (a_dims != b_dims) \ { \ if (! is_valid_bsxfun ("operator .^", a_dims, b_dims)) \ octave::err_nonconformant ("operator .^", a_dims, b_dims); \ \ return bsxfun_pow (a, b); \ } \ T1 ## NDArray result (a_dims); \ for (int i = 0; i < a.numel (); i++) \ { \ octave_quit (); \ result (i) = powf (a(i), b(i)); \ } \ return octave_value (result); \ } \ \ static octave_value \ elem_xpow (const FloatNDArray& a, const T2 ## NDArray& b) \ { \ dim_vector a_dims = a.dims (); \ dim_vector b_dims = b.dims (); \ if (a_dims != b_dims) \ { \ if (! is_valid_bsxfun ("operator .^", a_dims, b_dims)) \ octave::err_nonconformant ("operator .^", a_dims, b_dims); \ \ return bsxfun_pow (a, b); \ } \ T2 ## NDArray result (a_dims); \ for (int i = 0; i < a.numel (); i++) \ { \ octave_quit (); \ result (i) = powf (a(i), b(i)); \ } \ return octave_value (result); \ } #define OCTAVE_MM_CONV(T1, T2) \ DEFCONV (T1 ## m_ ## T2 ## m_conv, T1 ## matrix, T2 ## matrix) \ { \ const octave_ ## T1 ## matrix& v = dynamic_cast<const octave_ ## T1 ## matrix&> (a); \ \ return new octave_ ## T2 ## matrix (v.T2 ## array_value ()); \ } #define OCTAVE_MM_INT_OPS(TYPE) \ OCTAVE_M_INT_UNOPS (TYPE) \ OCTAVE_MM_POW_OPS (TYPE, TYPE) \ OCTAVE_MM_INT_ARITH_OPS (mm, TYPE ## _, TYPE ## _, TYPE) \ OCTAVE_MM_INT_ARITH_OPS (mmx, TYPE ## _, , TYPE) \ OCTAVE_MM_INT_ARITH_OPS (mxm, , TYPE ## _, TYPE) \ OCTAVE_MM_INT_ARITH_OPS (mmfx, TYPE ## _, float_, TYPE) \ OCTAVE_MM_INT_ARITH_OPS (mfxm, float_, TYPE ## _, TYPE) \ OCTAVE_MM_INT_CMP_OPS (mm, TYPE ## _, TYPE ## _) \ OCTAVE_MM_INT_CMP_OPS (mmx, TYPE ## _, ) \ OCTAVE_MM_INT_CMP_OPS (mfxm, float_, TYPE ## _) \ OCTAVE_MM_INT_CMP_OPS (mmfx, TYPE ## _, float_) \ OCTAVE_MM_INT_CMP_OPS (mxm, , TYPE ## _) \ OCTAVE_MM_INT_BOOL_OPS (mm, TYPE ## _, TYPE ## _) \ OCTAVE_MM_INT_BOOL_OPS (mmx, TYPE ## _, ) \ OCTAVE_MM_INT_BOOL_OPS (mxm, , TYPE ## _) \ OCTAVE_MM_INT_BOOL_OPS (mmfx, TYPE ## _, float_) \ OCTAVE_MM_INT_BOOL_OPS (mfxm, float_, TYPE ## _) \ OCTAVE_MM_INT_ASSIGN_OPS (mm, TYPE ## _, TYPE ## _, TYPE ## _) \ OCTAVE_MM_INT_ASSIGNEQ_OPS (mme, TYPE ## _) \ OCTAVE_MM_INT_ASSIGN_OPS (mmx, TYPE ## _, , ) \ OCTAVE_MM_INT_ASSIGN_OPS (mmfx, TYPE ## _, float_, float_) \ OCTAVE_MM_CONV(TYPE ## _, complex_) \ OCTAVE_MM_CONV(TYPE ## _, float_complex_) #define OCTAVE_RE_INT_ASSIGN_OPS(TYPE) \ DEFNDASSIGNOP_FN (TYPE ## ms_assign, matrix, TYPE ## _scalar, array, assign) \ DEFNDASSIGNOP_FN (TYPE ## mm_assign, matrix, TYPE ## _matrix, array, assign) #define OCTAVE_FLT_RE_INT_ASSIGN_OPS(TYPE) \ DEFNDASSIGNOP_FN (TYPE ## fms_assign, float_matrix, TYPE ## _scalar, float_array, assign) \ DEFNDASSIGNOP_FN (TYPE ## fmm_assign, float_matrix, TYPE ## _matrix, float_array, assign) #define OCTAVE_CX_INT_ASSIGN_OPS(TYPE) \ DEFNDASSIGNOP_FN (TYPE ## cms_assign, complex_matrix, TYPE ## _scalar, complex_array, assign) \ DEFNDASSIGNOP_FN (TYPE ## cmm_assign, complex_matrix, TYPE ## _matrix, complex_array, assign) #define OCTAVE_FLT_CX_INT_ASSIGN_OPS(TYPE) \ DEFNDASSIGNOP_FN (TYPE ## fcms_assign, float_complex_matrix, TYPE ## _scalar, float_complex_array, assign) \ DEFNDASSIGNOP_FN (TYPE ## fcmm_assign, float_complex_matrix, TYPE ## _matrix, float_complex_array, assign) #define OCTAVE_INT_NULL_ASSIGN_OPS(TYPE) \ DEFNULLASSIGNOP_FN (TYPE ## null_assign, TYPE ## _matrix, delete_elements) #define OCTAVE_INT_OPS(TYPE) \ OCTAVE_SS_INT_OPS (TYPE) \ OCTAVE_SM_INT_OPS (TYPE) \ OCTAVE_MS_INT_OPS (TYPE) \ OCTAVE_MM_INT_OPS (TYPE) \ OCTAVE_CONCAT_FN (TYPE) \ OCTAVE_RE_INT_ASSIGN_OPS (TYPE) \ OCTAVE_FLT_RE_INT_ASSIGN_OPS (TYPE) \ OCTAVE_CX_INT_ASSIGN_OPS (TYPE) \ OCTAVE_FLT_CX_INT_ASSIGN_OPS (TYPE) \ OCTAVE_INT_NULL_ASSIGN_OPS(TYPE) #define OCTAVE_INSTALL_S_INT_UNOPS(TYPE) \ INSTALL_UNOP_TI (ti, op_not, octave_ ## TYPE ## _scalar, s_not); \ INSTALL_UNOP_TI (ti, op_uplus, octave_ ## TYPE ## _scalar, s_uplus); \ INSTALL_UNOP_TI (ti, op_uminus, octave_ ## TYPE ## _scalar, s_uminus); \ INSTALL_UNOP_TI (ti, op_transpose, octave_ ## TYPE ## _scalar, s_transpose); \ INSTALL_UNOP_TI (ti, op_hermitian, octave_ ## TYPE ## _scalar, s_hermitian); \ \ INSTALL_NCUNOP_TI (ti, op_incr, octave_ ## TYPE ## _scalar, s_incr); \ INSTALL_NCUNOP_TI (ti, op_decr, octave_ ## TYPE ## _scalar, s_decr); #define OCTAVE_INSTALL_SS_INT_ARITH_OPS(PFX, T1, T2) \ INSTALL_BINOP_TI (ti, op_add, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _add); \ INSTALL_BINOP_TI (ti, op_sub, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _sub); \ INSTALL_BINOP_TI (ti, op_mul, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _mul); \ INSTALL_BINOP_TI (ti, op_div, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _div); \ INSTALL_BINOP_TI (ti, op_pow, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _pow); \ INSTALL_BINOP_TI (ti, op_ldiv, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _ldiv); \ INSTALL_BINOP_TI (ti, op_el_mul, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _el_mul); \ INSTALL_BINOP_TI (ti, op_el_div, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _el_div); \ INSTALL_BINOP_TI (ti, op_el_pow, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _el_pow); \ INSTALL_BINOP_TI (ti, op_el_ldiv, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _el_ldiv); #define OCTAVE_INSTALL_SS_INT_CMP_OPS(PFX, T1, T2) \ INSTALL_BINOP_TI (ti, op_lt, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _lt); \ INSTALL_BINOP_TI (ti, op_le, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _le); \ INSTALL_BINOP_TI (ti, op_eq, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _eq); \ INSTALL_BINOP_TI (ti, op_ge, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _ge); \ INSTALL_BINOP_TI (ti, op_gt, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _gt); \ INSTALL_BINOP_TI (ti, op_ne, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _ne); #define OCTAVE_INSTALL_SS_INT_BOOL_OPS(PFX, T1, T2) \ INSTALL_BINOP_TI (ti, op_el_and, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _el_and); \ INSTALL_BINOP_TI (ti, op_el_or, octave_ ## T1 ## scalar, octave_ ## T2 ## scalar, PFX ## _el_or); #define OCTAVE_INSTALL_SS_INT_OPS(TYPE) \ OCTAVE_INSTALL_S_INT_UNOPS (TYPE) \ OCTAVE_INSTALL_SS_INT_ARITH_OPS (ss, TYPE ## _, TYPE ## _) \ OCTAVE_INSTALL_SS_INT_ARITH_OPS (ssx, TYPE ## _, ) \ OCTAVE_INSTALL_SS_INT_ARITH_OPS (sxs, , TYPE ## _) \ OCTAVE_INSTALL_SS_INT_ARITH_OPS (ssfx, TYPE ## _, float_) \ OCTAVE_INSTALL_SS_INT_ARITH_OPS (sfxs, float_, TYPE ## _) \ OCTAVE_INSTALL_SS_INT_CMP_OPS (ss, TYPE ## _, TYPE ## _) \ OCTAVE_INSTALL_SS_INT_CMP_OPS (sx, TYPE ## _, ) \ OCTAVE_INSTALL_SS_INT_CMP_OPS (xs, , TYPE ## _) \ OCTAVE_INSTALL_SS_INT_CMP_OPS (sfx, TYPE ## _, float_) \ OCTAVE_INSTALL_SS_INT_CMP_OPS (fxs, float_, TYPE ## _) \ OCTAVE_INSTALL_SS_INT_BOOL_OPS (ss, TYPE ## _, TYPE ## _) \ OCTAVE_INSTALL_SS_INT_BOOL_OPS (sx, TYPE ## _, ) \ OCTAVE_INSTALL_SS_INT_BOOL_OPS (xs, , TYPE ## _) \ OCTAVE_INSTALL_SS_INT_BOOL_OPS (sfx, TYPE ## _, float_) \ OCTAVE_INSTALL_SS_INT_BOOL_OPS (fxs, float_, TYPE ## _) \ INSTALL_ASSIGNCONV_TI (ti, octave_ ## TYPE ## _scalar, octave_ ## TYPE ## _scalar, octave_ ## TYPE ## _matrix) \ INSTALL_ASSIGNCONV_TI (ti, octave_ ## TYPE ## _scalar, octave_scalar, octave_ ## TYPE ## _matrix) \ INSTALL_ASSIGNCONV_TI (ti, octave_ ## TYPE ## _scalar, octave_float_scalar, octave_ ## TYPE ## _matrix) \ INSTALL_ASSIGNCONV_TI (ti, octave_ ## TYPE ## _scalar, octave_complex_scalar, octave_complex_matrix) \ INSTALL_ASSIGNCONV_TI (ti, octave_ ## TYPE ## _scalar, octave_float_complex_scalar, octave_float_complex_matrix) #define OCTAVE_INSTALL_SM_INT_ARITH_OPS(PFX, T1, T2) \ INSTALL_BINOP_TI (ti, op_add, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _add); \ INSTALL_BINOP_TI (ti, op_sub, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _sub); \ INSTALL_BINOP_TI (ti, op_mul, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _mul); \ /* INSTALL_BINOP_TI (ti, op_div, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _div); */ \ /* INSTALL_BINOP_TI (ti, op_pow, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _pow); */ \ INSTALL_BINOP_TI (ti, op_ldiv, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _ldiv); \ INSTALL_BINOP_TI (ti, op_el_mul, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _el_mul); \ INSTALL_BINOP_TI (ti, op_el_div, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _el_div); \ INSTALL_BINOP_TI (ti, op_el_pow, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _el_pow); \ INSTALL_BINOP_TI (ti, op_el_ldiv, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _el_ldiv); #define OCTAVE_INSTALL_SM_INT_CMP_OPS(PFX, T1, T2) \ INSTALL_BINOP_TI (ti, op_lt, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _lt); \ INSTALL_BINOP_TI (ti, op_le, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _le); \ INSTALL_BINOP_TI (ti, op_eq, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _eq); \ INSTALL_BINOP_TI (ti, op_ge, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _ge); \ INSTALL_BINOP_TI (ti, op_gt, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _gt); \ INSTALL_BINOP_TI (ti, op_ne, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _ne); #define OCTAVE_INSTALL_SM_INT_BOOL_OPS(PFX, T1, T2) \ INSTALL_BINOP_TI (ti, op_el_and, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _el_and); \ INSTALL_BINOP_TI (ti, op_el_or, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _el_or); \ INSTALL_BINOP_TI (ti, op_el_and_not, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _el_and_not); \ INSTALL_BINOP_TI (ti, op_el_or_not, octave_ ## T1 ## scalar, octave_ ## T2 ## matrix, PFX ## _el_or_not); #define OCTAVE_INSTALL_SM_INT_OPS(TYPE) \ OCTAVE_INSTALL_SM_INT_ARITH_OPS (sm, TYPE ## _, TYPE ## _) \ OCTAVE_INSTALL_SM_INT_ARITH_OPS (smx, TYPE ## _, ) \ OCTAVE_INSTALL_SM_INT_ARITH_OPS (sxm, , TYPE ## _) \ OCTAVE_INSTALL_SM_INT_ARITH_OPS (smfx, TYPE ## _, float_) \ OCTAVE_INSTALL_SM_INT_ARITH_OPS (sfxm, float_, TYPE ## _) \ OCTAVE_INSTALL_SM_INT_CMP_OPS (sm, TYPE ## _, TYPE ## _) \ OCTAVE_INSTALL_SM_INT_CMP_OPS (xm, , TYPE ## _) \ OCTAVE_INSTALL_SM_INT_CMP_OPS (smx, TYPE ## _, ) \ OCTAVE_INSTALL_SM_INT_CMP_OPS (fxm, float_, TYPE ## _) \ OCTAVE_INSTALL_SM_INT_CMP_OPS (smfx, TYPE ## _, float_) \ OCTAVE_INSTALL_SM_INT_BOOL_OPS (sm, TYPE ## _, TYPE ## _) \ OCTAVE_INSTALL_SM_INT_BOOL_OPS (xm, , TYPE ## _) \ OCTAVE_INSTALL_SM_INT_BOOL_OPS (smx, TYPE ## _, ) \ OCTAVE_INSTALL_SM_INT_BOOL_OPS (fxm, float_, TYPE ## _) \ OCTAVE_INSTALL_SM_INT_BOOL_OPS (smfx, TYPE ## _, float_) \ INSTALL_WIDENOP_TI (ti, octave_ ## TYPE ## _scalar, octave_ ## TYPE ## _matrix, TYPE ## _s_ ## TYPE ## _m_conv) \ INSTALL_WIDENOP_TI (ti, octave_ ## TYPE ## _scalar, octave_complex_matrix, TYPE ## _s_complex_m_conv) \ INSTALL_WIDENOP_TI (ti, octave_ ## TYPE ## _scalar, octave_float_complex_matrix, TYPE ## _s_float_complex_m_conv) \ INSTALL_ASSIGNCONV_TI (ti, octave_ ## TYPE ## _scalar, octave_ ## TYPE ## _matrix, octave_ ## TYPE ## _matrix) \ INSTALL_ASSIGNCONV_TI (ti, octave_ ## TYPE ## _scalar, octave_matrix, octave_ ## TYPE ## _matrix) \ INSTALL_ASSIGNCONV_TI (ti, octave_ ## TYPE ## _scalar, octave_float_matrix, octave_ ## TYPE ## _matrix) \ INSTALL_ASSIGNCONV_TI (ti, octave_ ## TYPE ## _scalar, octave_complex_matrix, octave_complex_matrix) \ INSTALL_ASSIGNCONV_TI (ti, octave_ ## TYPE ## _scalar, octave_float_complex_matrix, octave_float_complex_matrix) #define OCTAVE_INSTALL_MS_INT_ARITH_OPS(PFX, T1, T2) \ INSTALL_BINOP_TI (ti, op_add, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _add); \ INSTALL_BINOP_TI (ti, op_sub, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _sub); \ INSTALL_BINOP_TI (ti, op_mul, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _mul); \ INSTALL_BINOP_TI (ti, op_div, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _div); \ /* INSTALL_BINOP_TI (ti, op_pow, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _pow); */ \ /* INSTALL_BINOP_TI (ti, op_ldiv, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _ldiv); */ \ \ INSTALL_BINOP_TI (ti, op_el_mul, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _el_mul); \ INSTALL_BINOP_TI (ti, op_el_div, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _el_div); \ INSTALL_BINOP_TI (ti, op_el_pow, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _el_pow); \ INSTALL_BINOP_TI (ti, op_el_ldiv, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _el_ldiv); #define OCTAVE_INSTALL_MS_INT_CMP_OPS(PFX, T1, T2) \ INSTALL_BINOP_TI (ti, op_lt, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _lt); \ INSTALL_BINOP_TI (ti, op_le, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _le); \ INSTALL_BINOP_TI (ti, op_eq, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _eq); \ INSTALL_BINOP_TI (ti, op_ge, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _ge); \ INSTALL_BINOP_TI (ti, op_gt, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _gt); \ INSTALL_BINOP_TI (ti, op_ne, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _ne); #define OCTAVE_INSTALL_MS_INT_BOOL_OPS(PFX, T1, T2) \ INSTALL_BINOP_TI (ti, op_el_and, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _el_and); \ INSTALL_BINOP_TI (ti, op_el_or, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _el_or); \ INSTALL_BINOP_TI (ti, op_el_not_and, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _el_not_and); \ INSTALL_BINOP_TI (ti, op_el_not_or, octave_ ## T1 ## matrix, octave_ ## T2 ## scalar, PFX ## _el_not_or); #define OCTAVE_INSTALL_MS_INT_ASSIGN_OPS(PFX, TLHS, TRHS) \ INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_ ## TLHS ## matrix, octave_ ## TRHS ## scalar, PFX ## _assign) #define OCTAVE_INSTALL_MS_INT_ASSIGNEQ_OPS(PFX, TLHS, TRHS) \ INSTALL_ASSIGNOP_TI (ti, op_add_eq, octave_ ## TLHS ## matrix, octave_ ## TRHS ## scalar, PFX ## _assign_add) \ INSTALL_ASSIGNOP_TI (ti, op_sub_eq, octave_ ## TLHS ## matrix, octave_ ## TRHS ## scalar, PFX ## _assign_sub) \ INSTALL_ASSIGNOP_TI (ti, op_mul_eq, octave_ ## TLHS ## matrix, octave_ ## TRHS ## scalar, PFX ## _assign_mul) \ INSTALL_ASSIGNOP_TI (ti, op_div_eq, octave_ ## TLHS ## matrix, octave_ ## TRHS ## scalar, PFX ## _assign_div) #define OCTAVE_INSTALL_MS_INT_OPS(TYPE) \ OCTAVE_INSTALL_MS_INT_ARITH_OPS (ms, TYPE ## _, TYPE ## _) \ OCTAVE_INSTALL_MS_INT_ARITH_OPS (msx, TYPE ## _, ) \ OCTAVE_INSTALL_MS_INT_ARITH_OPS (mxs, , TYPE ## _) \ OCTAVE_INSTALL_MS_INT_ARITH_OPS (msfx, TYPE ## _, float_) \ OCTAVE_INSTALL_MS_INT_ARITH_OPS (mfxs, float_, TYPE ## _) \ OCTAVE_INSTALL_MS_INT_CMP_OPS (ms, TYPE ## _, TYPE ## _) \ OCTAVE_INSTALL_MS_INT_CMP_OPS (mx, TYPE ## _, ) \ OCTAVE_INSTALL_MS_INT_CMP_OPS (mxs, , TYPE ## _) \ OCTAVE_INSTALL_MS_INT_CMP_OPS (mfx, TYPE ## _, float_) \ OCTAVE_INSTALL_MS_INT_CMP_OPS (mfxs, float_, TYPE ## _) \ OCTAVE_INSTALL_MS_INT_BOOL_OPS (ms, TYPE ## _, TYPE ## _) \ OCTAVE_INSTALL_MS_INT_BOOL_OPS (mx, TYPE ## _, ) \ OCTAVE_INSTALL_MS_INT_BOOL_OPS (mxs, , TYPE ## _) \ OCTAVE_INSTALL_MS_INT_BOOL_OPS (mfx, TYPE ## _, float_) \ OCTAVE_INSTALL_MS_INT_BOOL_OPS (mfxs, float_, TYPE ## _) \ OCTAVE_INSTALL_MS_INT_ASSIGN_OPS (ms, TYPE ## _, TYPE ## _) \ OCTAVE_INSTALL_MS_INT_ASSIGNEQ_OPS (mse, TYPE ## _, TYPE ## _) \ OCTAVE_INSTALL_MS_INT_ASSIGN_OPS (mx, TYPE ## _, ) \ OCTAVE_INSTALL_MS_INT_ASSIGN_OPS (mfx, TYPE ## _, float_) \ INSTALL_ASSIGNCONV_TI (ti, octave_ ## TYPE ## _matrix, octave_complex_scalar, octave_complex_matrix) \ INSTALL_ASSIGNCONV_TI (ti, octave_ ## TYPE ## _matrix, octave_float_complex_scalar, octave_float_complex_matrix) #define OCTAVE_INSTALL_M_INT_UNOPS(TYPE) \ INSTALL_UNOP_TI (ti, op_not, octave_ ## TYPE ## _matrix, m_not); \ INSTALL_UNOP_TI (ti, op_uplus, octave_ ## TYPE ## _matrix, m_uplus); \ INSTALL_UNOP_TI (ti, op_uminus, octave_ ## TYPE ## _matrix, m_uminus); \ INSTALL_UNOP_TI (ti, op_transpose, octave_ ## TYPE ## _matrix, m_transpose); \ INSTALL_UNOP_TI (ti, op_hermitian, octave_ ## TYPE ## _matrix, m_transpose); \ \ INSTALL_NCUNOP_TI (ti, op_incr, octave_ ## TYPE ## _matrix, m_incr); \ INSTALL_NCUNOP_TI (ti, op_decr, octave_ ## TYPE ## _matrix, m_decr); \ INSTALL_NCUNOP_TI (ti, op_uminus, octave_ ## TYPE ## _matrix, m_changesign); #define OCTAVE_INSTALL_MM_INT_ARITH_OPS(PFX, T1, T2) \ INSTALL_BINOP_TI (ti, op_add, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _add); \ INSTALL_BINOP_TI (ti, op_sub, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _sub); \ /* INSTALL_BINOP_TI (ti, op_mul, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _mul); */ \ /* INSTALL_BINOP_TI (ti, op_div, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _div); */ \ INSTALL_BINOP_TI (ti, op_pow, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _pow); \ /* INSTALL_BINOP_TI (ti, op_ldiv, octave_ ## T1 ## _matrix, octave_ ## T2 ## _matrix, mm_ldiv); */ \ INSTALL_BINOP_TI (ti, op_el_mul, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _el_mul); \ INSTALL_BINOP_TI (ti, op_el_div, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _el_div); \ INSTALL_BINOP_TI (ti, op_el_pow, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _el_pow); \ INSTALL_BINOP_TI (ti, op_el_ldiv, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _el_ldiv); #define OCTAVE_INSTALL_MM_INT_CMP_OPS(PFX, T1, T2) \ INSTALL_BINOP_TI (ti, op_lt, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _lt); \ INSTALL_BINOP_TI (ti, op_le, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _le); \ INSTALL_BINOP_TI (ti, op_eq, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _eq); \ INSTALL_BINOP_TI (ti, op_ge, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _ge); \ INSTALL_BINOP_TI (ti, op_gt, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _gt); \ INSTALL_BINOP_TI (ti, op_ne, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _ne); #define OCTAVE_INSTALL_MM_INT_BOOL_OPS(PFX, T1, T2) \ INSTALL_BINOP_TI (ti, op_el_and, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _el_and); \ INSTALL_BINOP_TI (ti, op_el_or, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _el_or); \ INSTALL_BINOP_TI (ti, op_el_not_and, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _el_not_and); \ INSTALL_BINOP_TI (ti, op_el_not_or, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _el_not_or); \ INSTALL_BINOP_TI (ti, op_el_and_not, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _el_and_not); \ INSTALL_BINOP_TI (ti, op_el_or_not, octave_ ## T1 ## matrix, octave_ ## T2 ## matrix, PFX ## _el_or_not); #define OCTAVE_INSTALL_MM_INT_ASSIGN_OPS(PFX, TLHS, TRHS) \ INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_ ## TLHS ## matrix, octave_ ## TRHS ## matrix, PFX ## _assign) #define OCTAVE_INSTALL_MM_INT_ASSIGNEQ_OPS(PFX, TLHS, TRHS) \ INSTALL_ASSIGNOP_TI (ti, op_add_eq, octave_ ## TLHS ## matrix, octave_ ## TRHS ## matrix, PFX ## _assign_add) \ INSTALL_ASSIGNOP_TI (ti, op_sub_eq, octave_ ## TLHS ## matrix, octave_ ## TRHS ## matrix, PFX ## _assign_sub) \ INSTALL_ASSIGNOP_TI (ti, op_el_mul_eq, octave_ ## TLHS ## matrix, octave_ ## TRHS ## matrix, PFX ## _assign_el_mul) \ INSTALL_ASSIGNOP_TI (ti, op_el_div_eq, octave_ ## TLHS ## matrix, octave_ ## TRHS ## matrix, PFX ## _assign_el_div) #define OCTAVE_INSTALL_MM_INT_OPS(TYPE) \ OCTAVE_INSTALL_M_INT_UNOPS (TYPE) \ OCTAVE_INSTALL_MM_INT_ARITH_OPS (mm, TYPE ##_, TYPE ## _) \ OCTAVE_INSTALL_MM_INT_ARITH_OPS (mmx, TYPE ##_, ) \ OCTAVE_INSTALL_MM_INT_ARITH_OPS (mxm, , TYPE ##_) \ OCTAVE_INSTALL_MM_INT_ARITH_OPS (mmfx, TYPE ##_, float_) \ OCTAVE_INSTALL_MM_INT_ARITH_OPS (mfxm, float_, TYPE ##_) \ OCTAVE_INSTALL_MM_INT_CMP_OPS (mm, TYPE ## _, TYPE ## _) \ OCTAVE_INSTALL_MM_INT_CMP_OPS (mmx, TYPE ## _, ) \ OCTAVE_INSTALL_MM_INT_CMP_OPS (mxm, , TYPE ## _) \ OCTAVE_INSTALL_MM_INT_CMP_OPS (mmfx, TYPE ## _, float_) \ OCTAVE_INSTALL_MM_INT_CMP_OPS (mfxm, float_, TYPE ## _) \ OCTAVE_INSTALL_MM_INT_BOOL_OPS (mm, TYPE ## _, TYPE ## _) \ OCTAVE_INSTALL_MM_INT_BOOL_OPS (mmx, TYPE ## _, ) \ OCTAVE_INSTALL_MM_INT_BOOL_OPS (mxm, , TYPE ## _) \ OCTAVE_INSTALL_MM_INT_BOOL_OPS (mmfx, TYPE ## _, float_) \ OCTAVE_INSTALL_MM_INT_BOOL_OPS (mfxm, float_, TYPE ## _) \ OCTAVE_INSTALL_MM_INT_ASSIGN_OPS (mm, TYPE ## _, TYPE ## _) \ OCTAVE_INSTALL_MM_INT_ASSIGNEQ_OPS (mme, TYPE ## _, TYPE ## _) \ OCTAVE_INSTALL_MM_INT_ASSIGN_OPS (mmx, TYPE ## _, ) \ OCTAVE_INSTALL_MM_INT_ASSIGN_OPS (mmfx, TYPE ## _, float_) \ INSTALL_WIDENOP_TI (ti, octave_ ## TYPE ## _matrix, octave_complex_matrix, TYPE ## _m_complex_m_conv) \ INSTALL_WIDENOP_TI (ti, octave_ ## TYPE ## _matrix, octave_float_complex_matrix, TYPE ## _m_float_complex_m_conv) \ INSTALL_ASSIGNCONV_TI (ti, octave_ ## TYPE ## _matrix, octave_complex_matrix, octave_complex_matrix) \ INSTALL_ASSIGNCONV_TI (ti, octave_ ## TYPE ## _matrix, octave_float_complex_matrix, octave_float_complex_matrix) #define OCTAVE_INSTALL_RE_INT_ASSIGN_OPS(TYPE) \ INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_matrix, octave_ ## TYPE ## _scalar, TYPE ## ms_assign) \ INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_matrix, octave_ ## TYPE ## _matrix, TYPE ## mm_assign) \ INSTALL_ASSIGNCONV_TI (ti, octave_scalar, octave_ ## TYPE ## _scalar, octave_matrix) \ INSTALL_ASSIGNCONV_TI (ti, octave_matrix, octave_ ## TYPE ## _matrix, octave_matrix) #define OCTAVE_INSTALL_FLT_RE_INT_ASSIGN_OPS(TYPE) \ INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_float_matrix, octave_ ## TYPE ## _scalar, TYPE ## fms_assign) \ INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_float_matrix, octave_ ## TYPE ## _matrix, TYPE ## fmm_assign) \ INSTALL_ASSIGNCONV_TI (ti, octave_float_scalar, octave_ ## TYPE ## _scalar, octave_float_matrix) \ INSTALL_ASSIGNCONV_TI (ti, octave_float_matrix, octave_ ## TYPE ## _matrix, octave_float_matrix) #define OCTAVE_INSTALL_CX_INT_ASSIGN_OPS(TYPE) \ INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_complex_matrix, octave_ ## TYPE ## _scalar, TYPE ## cms_assign) \ INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_complex_matrix, octave_ ## TYPE ## _matrix, TYPE ## cmm_assign) \ INSTALL_ASSIGNCONV_TI (ti, octave_complex_scalar, octave_ ## TYPE ## _scalar, octave_complex_matrix) \ INSTALL_ASSIGNCONV_TI (ti, octave_complex_matrix, octave_ ## TYPE ## _matrix, octave_complex_matrix) #define OCTAVE_INSTALL_FLT_CX_INT_ASSIGN_OPS(TYPE) \ INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_float_complex_matrix, octave_ ## TYPE ## _scalar, TYPE ## fcms_assign) \ INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_float_complex_matrix, octave_ ## TYPE ## _matrix, TYPE ## fcmm_assign) \ INSTALL_ASSIGNCONV_TI (ti, octave_float_complex_scalar, octave_ ## TYPE ## _scalar, octave_complex_matrix) \ INSTALL_ASSIGNCONV_TI (ti, octave_float_complex_matrix, octave_ ## TYPE ## _matrix, octave_complex_matrix) #define OCTAVE_INSTALL_INT_NULL_ASSIGN_OPS(TYPE) \ INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_ ## TYPE ## _matrix, octave_null_matrix, TYPE ## null_assign) \ INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_ ## TYPE ## _matrix, octave_null_str, TYPE ## null_assign) \ INSTALL_ASSIGNOP_TI (ti, op_asn_eq, octave_ ## TYPE ## _matrix, octave_null_sq_str, TYPE ## null_assign) \ INSTALL_ASSIGNCONV_TI (ti, octave_ ## TYPE ## _scalar, octave_null_matrix, octave_ ## TYPE ## _matrix) \ INSTALL_ASSIGNCONV_TI (ti, octave_## TYPE ## _scalar, octave_null_str, octave_ ## TYPE ## _matrix) \ INSTALL_ASSIGNCONV_TI (ti, octave_## TYPE ## _scalar, octave_null_sq_str, octave_ ## TYPE ## _matrix) #define OCTAVE_INSTALL_INT_OPS(TYPE) \ OCTAVE_INSTALL_SS_INT_OPS (TYPE) \ OCTAVE_INSTALL_SM_INT_OPS (TYPE) \ OCTAVE_INSTALL_MS_INT_OPS (TYPE) \ OCTAVE_INSTALL_MM_INT_OPS (TYPE) \ OCTAVE_INSTALL_CONCAT_FN (TYPE) \ OCTAVE_INSTALL_RE_INT_ASSIGN_OPS (TYPE) \ OCTAVE_INSTALL_FLT_RE_INT_ASSIGN_OPS (TYPE) \ OCTAVE_INSTALL_CX_INT_ASSIGN_OPS (TYPE) \ OCTAVE_INSTALL_FLT_CX_INT_ASSIGN_OPS (TYPE) \ OCTAVE_INSTALL_INT_NULL_ASSIGN_OPS(TYPE) #define OCTAVE_INSTALL_SM_INT_ASSIGNCONV(TLHS, TRHS) \ INSTALL_ASSIGNCONV_TI (ti, octave_ ## TLHS ## _scalar, octave_ ## TRHS ## _scalar, octave_ ## TLHS ## _matrix) \ INSTALL_ASSIGNCONV_TI (ti, octave_ ## TLHS ## _scalar, octave_ ## TRHS ## _matrix, octave_ ## TLHS ## _matrix) #define OCTAVE_MIXED_INT_CMP_OPS(T1, T2) \ OCTAVE_SS_INT_CMP_OPS (T1 ## _ ## T2 ## _ss, T1 ## _, T2 ## _) \ OCTAVE_SM_INT_CMP_OPS (T1 ## _ ## T2 ## _sm, T1 ## _, T2 ## _) \ OCTAVE_MS_INT_CMP_OPS (T1 ## _ ## T2 ## _ms, T1 ## _, T2 ## _) \ OCTAVE_MM_INT_CMP_OPS (T1 ## _ ## T2 ## _mm, T1 ## _, T2 ## _) #define OCTAVE_INSTALL_MIXED_INT_CMP_OPS(T1, T2) \ OCTAVE_INSTALL_SS_INT_CMP_OPS (T1 ## _ ## T2 ## _ss, T1 ## _, T2 ## _) \ OCTAVE_INSTALL_SM_INT_CMP_OPS (T1 ## _ ## T2 ## _sm, T1 ## _, T2 ## _) \ OCTAVE_INSTALL_MS_INT_CMP_OPS (T1 ## _ ## T2 ## _ms, T1 ## _, T2 ## _) \ OCTAVE_INSTALL_MM_INT_CMP_OPS (T1 ## _ ## T2 ## _mm, T1 ## _, T2 ## _) #endif