GNU Octave  6.2.0
A high-level interpreted language, primarily intended for numerical computations, mostly compatible with Matlab
mx-op-decl.h
Go to the documentation of this file.
1 ////////////////////////////////////////////////////////////////////////
2 //
3 // Copyright (C) 1996-2021 The Octave Project Developers
4 //
5 // See the file COPYRIGHT.md in the top-level directory of this
6 // distribution or <https://octave.org/copyright/>.
7 //
8 // This file is part of Octave.
9 //
10 // Octave is free software: you can redistribute it and/or modify it
11 // under the terms of the GNU General Public License as published by
12 // the Free Software Foundation, either version 3 of the License, or
13 // (at your option) any later version.
14 //
15 // Octave is distributed in the hope that it will be useful, but
16 // WITHOUT ANY WARRANTY; without even the implied warranty of
17 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 // GNU General Public License for more details.
19 //
20 // You should have received a copy of the GNU General Public License
21 // along with Octave; see the file COPYING. If not, see
22 // <https://www.gnu.org/licenses/>.
23 //
24 ////////////////////////////////////////////////////////////////////////
25 
26 #if ! defined (octave_mx_op_decl_h)
27 #define octave_mx_op_decl_h 1
28 
29 #include "octave-config.h"
30 
31 #define BIN_OP_DECL(R, OP, X, Y, API) \
32  extern API R OP (const X&, const Y&)
33 
34 class boolMatrix;
35 class boolNDArray;
36 
37 #define CMP_OP_DECL(OP, X, Y, API) \
38  extern API boolMatrix OP (const X&, const Y&)
39 
40 #define NDCMP_OP_DECL(OP, X, Y, API) \
41  extern API boolNDArray OP (const X&, const Y&)
42 
43 #define BOOL_OP_DECL(OP, X, Y, API) \
44  extern API boolMatrix OP (const X&, const Y&)
45 
46 #define NDBOOL_OP_DECL(OP, X, Y, API) \
47  extern API boolNDArray OP (const X&, const Y&)
48 
49 // vector by scalar operations.
50 
51 #define VS_BIN_OP_DECLS(R, V, S, API) \
52  BIN_OP_DECL (R, operator +, V, S, API); \
53  BIN_OP_DECL (R, operator -, V, S, API); \
54  BIN_OP_DECL (R, operator *, V, S, API); \
55  BIN_OP_DECL (R, operator /, V, S, API);
56 
57 #define VS_OP_DECLS(R, V, S, API) \
58  VS_BIN_OP_DECLS(R, V, S, API)
59 
60 // scalar by vector by operations.
61 
62 #define SV_BIN_OP_DECLS(R, S, V, API) \
63  BIN_OP_DECL (R, operator +, S, V, API); \
64  BIN_OP_DECL (R, operator -, S, V, API); \
65  BIN_OP_DECL (R, operator *, S, V, API); \
66  BIN_OP_DECL (R, operator /, S, V, API);
67 
68 #define SV_OP_DECLS(R, S, V, API) \
69  SV_BIN_OP_DECLS(R, S, V, API)
70 
71 // vector by vector operations.
72 
73 #define VV_BIN_OP_DECLS(R, V1, V2, API) \
74  BIN_OP_DECL (R, operator +, V1, V2, API); \
75  BIN_OP_DECL (R, operator -, V1, V2, API); \
76  BIN_OP_DECL (R, product, V1, V2, API); \
77  BIN_OP_DECL (R, quotient, V1, V2, API);
78 
79 #define VV_OP_DECLS(R, V1, V2, API) \
80  VV_BIN_OP_DECLS(R, V1, V2, API)
81 
82 // matrix by scalar operations.
83 
84 #define MS_BIN_OP_DECLS(R, M, S, API) \
85  BIN_OP_DECL (R, operator +, M, S, API); \
86  BIN_OP_DECL (R, operator -, M, S, API); \
87  BIN_OP_DECL (R, operator *, M, S, API); \
88  BIN_OP_DECL (R, operator /, M, S, API);
89 
90 #define MS_CMP_OP_DECLS(M, S, API) \
91  CMP_OP_DECL (mx_el_lt, M, S, API); \
92  CMP_OP_DECL (mx_el_le, M, S, API); \
93  CMP_OP_DECL (mx_el_ge, M, S, API); \
94  CMP_OP_DECL (mx_el_gt, M, S, API); \
95  CMP_OP_DECL (mx_el_eq, M, S, API); \
96  CMP_OP_DECL (mx_el_ne, M, S, API);
97 
98 #define MS_BOOL_OP_DECLS(M, S, API) \
99  BOOL_OP_DECL (mx_el_and, M, S, API); \
100  BOOL_OP_DECL (mx_el_or, M, S, API); \
101 
102 #define MS_OP_DECLS(R, M, S, API) \
103  MS_BIN_OP_DECLS (R, M, S, API) \
104  MS_CMP_OP_DECLS (M, S, API) \
105  MS_BOOL_OP_DECLS (M, S, API) \
106 
107 // scalar by matrix operations.
108 
109 #define SM_BIN_OP_DECLS(R, S, M, API) \
110  BIN_OP_DECL (R, operator +, S, M, API); \
111  BIN_OP_DECL (R, operator -, S, M, API); \
112  BIN_OP_DECL (R, operator *, S, M, API); \
113  BIN_OP_DECL (R, operator /, S, M, API);
114 
115 #define SM_CMP_OP_DECLS(S, M, API) \
116  CMP_OP_DECL (mx_el_lt, S, M, API); \
117  CMP_OP_DECL (mx_el_le, S, M, API); \
118  CMP_OP_DECL (mx_el_ge, S, M, API); \
119  CMP_OP_DECL (mx_el_gt, S, M, API); \
120  CMP_OP_DECL (mx_el_eq, S, M, API); \
121  CMP_OP_DECL (mx_el_ne, S, M, API);
122 
123 #define SM_BOOL_OP_DECLS(S, M, API) \
124  BOOL_OP_DECL (mx_el_and, S, M, API); \
125  BOOL_OP_DECL (mx_el_or, S, M, API); \
126 
127 #define SM_OP_DECLS(R, S, M, API) \
128  SM_BIN_OP_DECLS (R, S, M, API) \
129  SM_CMP_OP_DECLS (S, M, API) \
130  SM_BOOL_OP_DECLS (S, M, API) \
131 
132 // matrix by matrix operations.
133 
134 #define MM_BIN_OP_DECLS(R, M1, M2, API) \
135  BIN_OP_DECL (R, operator +, M1, M2, API); \
136  BIN_OP_DECL (R, operator -, M1, M2, API); \
137  BIN_OP_DECL (R, product, M1, M2, API); \
138  BIN_OP_DECL (R, quotient, M1, M2, API);
139 
140 #define MM_CMP_OP_DECLS(M1, M2, API) \
141  CMP_OP_DECL (mx_el_lt, M1, M2, API); \
142  CMP_OP_DECL (mx_el_le, M1, M2, API); \
143  CMP_OP_DECL (mx_el_ge, M1, M2, API); \
144  CMP_OP_DECL (mx_el_gt, M1, M2, API); \
145  CMP_OP_DECL (mx_el_eq, M1, M2, API); \
146  CMP_OP_DECL (mx_el_ne, M1, M2, API);
147 
148 #define MM_BOOL_OP_DECLS(M1, M2, API) \
149  BOOL_OP_DECL (mx_el_and, M1, M2, API); \
150  BOOL_OP_DECL (mx_el_or, M1, M2, API);
151 
152 #define MM_OP_DECLS(R, M1, M2, API) \
153  MM_BIN_OP_DECLS (R, M1, M2, API) \
154  MM_CMP_OP_DECLS (M1, M2, API) \
155  MM_BOOL_OP_DECLS (M1, M2, API)
156 
157 // N-D matrix by scalar operations.
158 
159 #define NDS_BIN_OP_DECLS(R, ND, S, API) \
160  BIN_OP_DECL (R, operator +, ND, S, API); \
161  BIN_OP_DECL (R, operator -, ND, S, API); \
162  BIN_OP_DECL (R, operator *, ND, S, API); \
163  BIN_OP_DECL (R, operator /, ND, S, API);
164 
165 #define NDS_CMP_OP_DECLS(ND, S, API) \
166  NDCMP_OP_DECL (mx_el_lt, ND, S, API); \
167  NDCMP_OP_DECL (mx_el_le, ND, S, API); \
168  NDCMP_OP_DECL (mx_el_ge, ND, S, API); \
169  NDCMP_OP_DECL (mx_el_gt, ND, S, API); \
170  NDCMP_OP_DECL (mx_el_eq, ND, S, API); \
171  NDCMP_OP_DECL (mx_el_ne, ND, S, API);
172 
173 #define NDS_BOOL_OP_DECLS(ND, S, API) \
174  NDBOOL_OP_DECL (mx_el_and, ND, S, API); \
175  NDBOOL_OP_DECL (mx_el_or, ND, S, API); \
176  NDBOOL_OP_DECL (mx_el_not_and, ND, S, API); \
177  NDBOOL_OP_DECL (mx_el_not_or, ND, S, API);
178 
179 #define NDS_OP_DECLS(R, ND, S, API) \
180  NDS_BIN_OP_DECLS (R, ND, S, API) \
181  NDS_CMP_OP_DECLS (ND, S, API) \
182  NDS_BOOL_OP_DECLS (ND, S, API)
183 
184 // scalar by N-D matrix operations.
185 
186 #define SND_BIN_OP_DECLS(R, S, ND, API) \
187  BIN_OP_DECL (R, operator +, S, ND, API); \
188  BIN_OP_DECL (R, operator -, S, ND, API); \
189  BIN_OP_DECL (R, operator *, S, ND, API); \
190  BIN_OP_DECL (R, operator /, S, ND, API);
191 
192 #define SND_CMP_OP_DECLS(S, ND, API) \
193  NDCMP_OP_DECL (mx_el_lt, S, ND, API); \
194  NDCMP_OP_DECL (mx_el_le, S, ND, API); \
195  NDCMP_OP_DECL (mx_el_ge, S, ND, API); \
196  NDCMP_OP_DECL (mx_el_gt, S, ND, API); \
197  NDCMP_OP_DECL (mx_el_eq, S, ND, API); \
198  NDCMP_OP_DECL (mx_el_ne, S, ND, API);
199 
200 #define SND_BOOL_OP_DECLS(S, ND, API) \
201  NDBOOL_OP_DECL (mx_el_and, S, ND, API); \
202  NDBOOL_OP_DECL (mx_el_or, S, ND, API); \
203  NDBOOL_OP_DECL (mx_el_and_not, S, ND, API); \
204  NDBOOL_OP_DECL (mx_el_or_not, S, ND, API);
205 
206 #define SND_OP_DECLS(R, S, ND, API) \
207  SND_BIN_OP_DECLS (R, S, ND, API) \
208  SND_CMP_OP_DECLS (S, ND, API) \
209  SND_BOOL_OP_DECLS (S, ND, API)
210 
211 // N-D matrix by N-D matrix operations.
212 
213 #define NDND_BIN_OP_DECLS(R, ND1, ND2, API) \
214  BIN_OP_DECL (R, operator +, ND1, ND2, API); \
215  BIN_OP_DECL (R, operator -, ND1, ND2, API); \
216  BIN_OP_DECL (R, product, ND1, ND2, API); \
217  BIN_OP_DECL (R, quotient, ND1, ND2, API);
218 
219 #define NDND_CMP_OP_DECLS(ND1, ND2, API) \
220  NDCMP_OP_DECL (mx_el_lt, ND1, ND2, API); \
221  NDCMP_OP_DECL (mx_el_le, ND1, ND2, API); \
222  NDCMP_OP_DECL (mx_el_ge, ND1, ND2, API); \
223  NDCMP_OP_DECL (mx_el_gt, ND1, ND2, API); \
224  NDCMP_OP_DECL (mx_el_eq, ND1, ND2, API); \
225  NDCMP_OP_DECL (mx_el_ne, ND1, ND2, API);
226 
227 #define NDND_BOOL_OP_DECLS(ND1, ND2, API) \
228  NDBOOL_OP_DECL (mx_el_and, ND1, ND2, API); \
229  NDBOOL_OP_DECL (mx_el_or, ND1, ND2, API); \
230  NDBOOL_OP_DECL (mx_el_and_not, ND1, ND2, API); \
231  NDBOOL_OP_DECL (mx_el_or_not, ND1, ND2, API); \
232  NDBOOL_OP_DECL (mx_el_not_and, ND1, ND2, API); \
233  NDBOOL_OP_DECL (mx_el_not_or, ND1, ND2, API);
234 
235 #define NDND_OP_DECLS(R, ND1, ND2, API) \
236  NDND_BIN_OP_DECLS (R, ND1, ND2, API) \
237  NDND_CMP_OP_DECLS (ND1, ND2, API) \
238  NDND_BOOL_OP_DECLS (ND1, ND2, API)
239 
240 // scalar by diagonal matrix operations.
241 
242 #define SDM_BIN_OP_DECLS(R, S, DM, API) \
243  BIN_OP_DECL (R, operator *, S, DM, API); \
244 
245 #define SDM_OP_DECLS(R, S, DM, API) \
246  SDM_BIN_OP_DECLS(R, S, DM, API)
247 
248 // diagonal matrix by scalar operations.
249 
250 #define DMS_BIN_OP_DECLS(R, DM, S, API) \
251  BIN_OP_DECL (R, operator *, DM, S, API); \
252  BIN_OP_DECL (R, operator /, DM, S, API);
253 
254 #define DMS_OP_DECLS(R, DM, S, API) \
255  DMS_BIN_OP_DECLS(R, DM, S, API)
256 
257 // matrix by diagonal matrix operations.
258 
259 #define MDM_BIN_OP_DECLS(R, M, DM, API) \
260  BIN_OP_DECL (R, operator +, M, DM, API); \
261  BIN_OP_DECL (R, operator -, M, DM, API); \
262  BIN_OP_DECL (R, operator *, M, DM, API);
263 
264 #define MDM_OP_DECLS(R, M, DM, API) \
265  MDM_BIN_OP_DECLS(R, M, DM, API)
266 
267 // diagonal matrix by matrix operations.
268 
269 #define DMM_BIN_OP_DECLS(R, DM, M, API) \
270  BIN_OP_DECL (R, operator +, DM, M, API); \
271  BIN_OP_DECL (R, operator -, DM, M, API); \
272  BIN_OP_DECL (R, operator *, DM, M, API);
273 
274 #define DMM_OP_DECLS(R, DM, M, API) \
275  DMM_BIN_OP_DECLS(R, DM, M, API)
276 
277 // diagonal matrix by diagonal matrix operations.
278 
279 #define DMDM_BIN_OP_DECLS(R, DM1, DM2, API) \
280  BIN_OP_DECL (R, operator +, DM1, DM2, API); \
281  BIN_OP_DECL (R, operator -, DM1, DM2, API); \
282  BIN_OP_DECL (R, product, DM1, DM2, API);
283 
284 #define DMDM_OP_DECLS(R, DM1, DM2, API) \
285  DMDM_BIN_OP_DECLS (R, DM1, DM2, API)
286 
287 // scalar by N-D array min/max ops
288 
289 #define MINMAX_DECLS(T, S, API) \
290  extern API T min (S d, const T& m); \
291  extern API T min (const T& m, S d); \
292  extern API T min (const T& a, const T& b); \
293  extern API T max (S d, const T& m); \
294  extern API T max (const T& m, S d); \
295  extern API T max (const T& a, const T& b);
296 
297 // permutation matrix by matrix ops and vice versa
298 
299 #define PMM_BIN_OP_DECLS(R, PM, M, API) \
300  BIN_OP_DECL (R, operator *, PM, M, API);
301 
302 #define MPM_BIN_OP_DECLS(R, M, PM, API) \
303  BIN_OP_DECL (R, operator *, M, PM, API);
304 
305 #endif