GNU Octave
4.0.0
A high-level interpreted language, primarily intended for numerical computations, mostly compatible with Matlab
Main Page
Namespaces
Classes
Files
File List
File Members
•
All
Classes
Namespaces
Files
Functions
Variables
Typedefs
Enumerations
Enumerator
Properties
Friends
Macros
Pages
liboctave
array
MArray-decl.h
Go to the documentation of this file.
1
/*
2
3
Copyright (C) 1996-2015 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_MArray_decl_h)
24
#define octave_MArray_decl_h 1
25
26
// A macro that can be used to declare and instantiate OP= operators.
27
#define MARRAY_OP_ASSIGN_DECL(A_T, E_T, OP, PFX, API, LTGT, RHS_T) \
28
PFX API A_T<E_T>& \
29
operator OP LTGT (A_T<E_T>&, const RHS_T&)
30
31
#define MARRAY_OP_ASSIGN_DECLX(A_T, E_T, OP, PFX, API, LTGT, RHS_T) \
32
PFX API A_T<E_T>& \
33
OP LTGT (A_T<E_T>&, const RHS_T&)
34
35
// All the OP= operators that we care about.
36
#define MARRAY_OP_ASSIGN_DECLS(A_T, E_T, PFX, API, LTGT, RHS_T) \
37
MARRAY_OP_ASSIGN_DECL (A_T, E_T, +=, PFX, API, LTGT, RHS_T); \
38
MARRAY_OP_ASSIGN_DECL (A_T, E_T, -=, PFX, API, LTGT, RHS_T); \
39
MARRAY_OP_ASSIGN_DECLX (A_T, E_T, product_eq, PFX, API, LTGT, RHS_T); \
40
MARRAY_OP_ASSIGN_DECLX (A_T, E_T, quotient_eq, PFX, API, LTGT, RHS_T);
41
42
#define MARRAY_OP_ASSIGN_DECLS1(A_T, E_T, PFX, API, LTGT, RHS_T) \
43
MARRAY_OP_ASSIGN_DECL (A_T, E_T, +=, PFX, API, LTGT, RHS_T); \
44
MARRAY_OP_ASSIGN_DECL (A_T, E_T, -=, PFX, API, LTGT, RHS_T); \
45
MARRAY_OP_ASSIGN_DECL (A_T, E_T, *=, PFX, API, LTGT, RHS_T); \
46
MARRAY_OP_ASSIGN_DECL (A_T, E_T, /=, PFX, API, LTGT, RHS_T);
47
48
// Generate forward declarations for OP= operators.
49
#define MARRAY_OP_ASSIGN_FWD_DECLS(A_T, RHS_T, API) \
50
MARRAY_OP_ASSIGN_DECLS (A_T, T, template <typename T>, API, , RHS_T)
51
52
#define MARRAY_OP_ASSIGN_FWD_DECLS1(A_T, RHS_T, API) \
53
MARRAY_OP_ASSIGN_DECLS1 (A_T, T, template <typename T>, API, , RHS_T)
54
55
// Generate friend declarations for the OP= operators.
56
#define MARRAY_OP_ASSIGN_FRIENDS(A_T, RHS_T, API) \
57
MARRAY_OP_ASSIGN_DECLS (A_T, T, friend, API, <>, RHS_T)
58
59
#define MARRAY_OP_ASSIGN_FRIENDS1(A_T, RHS_T, API) \
60
MARRAY_OP_ASSIGN_DECLS1 (A_T, T, friend, API, <>, RHS_T)
61
62
// A function that can be used to forward OP= operations from derived
63
// classes back to us.
64
#define MARRAY_OP_ASSIGN_FWD_FCN(R, F, T, C_X, X_T, C_Y, Y_T) \
65
inline R \
66
F (X_T& x, const Y_T& y) \
67
{ \
68
return R (F (C_X (x), C_Y (y))); \
69
}
70
71
// All the OP= operators that we care about forwarding.
72
#define MARRAY_OP_ASSIGN_FWD_DEFS(R, T, C_X, X_T, C_Y, Y_T) \
73
MARRAY_OP_ASSIGN_FWD_FCN (R, operator +=, T, C_X, X_T, C_Y, Y_T) \
74
MARRAY_OP_ASSIGN_FWD_FCN (R, operator -=, T, C_X, X_T, C_Y, Y_T) \
75
MARRAY_OP_ASSIGN_FWD_FCN (R, product_eq, T, C_X, X_T, C_Y, Y_T) \
76
MARRAY_OP_ASSIGN_FWD_FCN (R, quotient_eq, T, C_X, X_T, C_Y, Y_T)
77
78
#define MARRAY_OP_ASSIGN_FWD_DEFS1(R, T, C_X, X_T, C_Y, Y_T) \
79
MARRAY_OP_ASSIGN_FWD_FCN (R, operator +=, T, C_X, X_T, C_Y, Y_T) \
80
MARRAY_OP_ASSIGN_FWD_FCN (R, operator -=, T, C_X, X_T, C_Y, Y_T) \
81
MARRAY_OP_ASSIGN_FWD_FCN (R, operator *=, T, C_X, X_T, C_Y, Y_T) \
82
MARRAY_OP_ASSIGN_FWD_FCN (R, operator /=, T, C_X, X_T, C_Y, Y_T)
83
84
// A macro that can be used to declare and instantiate unary operators.
85
#define MARRAY_UNOP(A_T, E_T, F, PFX, API, LTGT) \
86
PFX API A_T<E_T> \
87
F LTGT (const A_T<E_T>&)
88
89
// All the unary operators that we care about.
90
#define MARRAY_UNOP_DECLS(A_T, E_T, PFX, API, LTGT) \
91
MARRAY_UNOP (A_T, E_T, operator +, PFX, API, LTGT); \
92
MARRAY_UNOP (A_T, E_T, operator -, PFX, API, LTGT);
93
94
// Generate forward declarations for unary operators.
95
#define MARRAY_UNOP_FWD_DECLS(A_T, API) \
96
MARRAY_UNOP_DECLS (A_T, T, template <typename T>, API, )
97
98
// Generate friend declarations for the unary operators.
99
#define MARRAY_UNOP_FRIENDS(A_T, API) \
100
MARRAY_UNOP_DECLS (A_T, T, friend, API, <>)
101
102
// A function that can be used to forward unary operations from derived
103
// classes back to us.
104
#define MARRAY_UNOP_FWD_FCN(R, F, T, C_X, X_T) \
105
inline R \
106
F (const X_T& x) \
107
{ \
108
return R (F (C_X (x))); \
109
}
110
111
// All the unary operators that we care about forwarding.
112
#define MARRAY_UNOP_FWD_DEFS(R, T, C_X, X_T) \
113
MARRAY_UNOP_FWD_FCN (R, operator +, T, C_X, X_T) \
114
MARRAY_UNOP_FWD_FCN (R, operator -, T, C_X, X_T)
115
116
// A macro that can be used to declare and instantiate binary operators.
117
#define MARRAY_BINOP_DECL(A_T, E_T, F, PFX, API, LTGT, X_T, Y_T) \
118
PFX API A_T<E_T> \
119
F LTGT (const X_T&, const Y_T&)
120
121
// All the binary operators that we care about. We have two
122
// sets of macros since the MArray OP MArray operations use functions
123
// (product and quotient) instead of operators (*, /).
124
#define MARRAY_BINOP_DECLS(A_T, E_T, PFX, API, LTGT, X_T, Y_T) \
125
MARRAY_BINOP_DECL (A_T, E_T, operator +, PFX, API, LTGT, X_T, Y_T); \
126
MARRAY_BINOP_DECL (A_T, E_T, operator -, PFX, API, LTGT, X_T, Y_T); \
127
MARRAY_BINOP_DECL (A_T, E_T, operator *, PFX, API, LTGT, X_T, Y_T); \
128
MARRAY_BINOP_DECL (A_T, E_T, operator /, PFX, API, LTGT, X_T, Y_T);
129
130
#define MARRAY_AA_BINOP_DECLS(A_T, E_T, PFX, API, LTGT) \
131
MARRAY_BINOP_DECL (A_T, E_T, operator +, PFX, API, LTGT, A_T<E_T>, A_T<E_T>); \
132
MARRAY_BINOP_DECL (A_T, E_T, operator -, PFX, API, LTGT, A_T<E_T>, A_T<E_T>); \
133
MARRAY_BINOP_DECL (A_T, E_T, quotient, PFX, API, LTGT, A_T<E_T>, A_T<E_T>); \
134
MARRAY_BINOP_DECL (A_T, E_T, product, PFX, API, LTGT, A_T<E_T>, A_T<E_T>);
135
136
#define MDIAGARRAY2_DAS_BINOP_DECLS(A_T, E_T, PFX, API, LTGT, X_T, Y_T) \
137
MARRAY_BINOP_DECL (A_T, E_T, operator *, PFX, API, LTGT, X_T, Y_T); \
138
MARRAY_BINOP_DECL (A_T, E_T, operator /, PFX, API, LTGT, X_T, Y_T);
139
140
#define MDIAGARRAY2_SDA_BINOP_DECLS(A_T, E_T, PFX, API, LTGT, X_T, Y_T) \
141
MARRAY_BINOP_DECL (A_T, E_T, operator *, PFX, API, LTGT, X_T, Y_T);
142
143
#define MDIAGARRAY2_DADA_BINOP_DECLS(A_T, E_T, PFX, API, LTGT) \
144
MARRAY_BINOP_DECL (A_T, E_T, operator +, PFX, API, LTGT, A_T<E_T>, A_T<E_T>); \
145
MARRAY_BINOP_DECL (A_T, E_T, operator -, PFX, API, LTGT, A_T<E_T>, A_T<E_T>); \
146
MARRAY_BINOP_DECL (A_T, E_T, product, PFX, API, LTGT, A_T<E_T>, A_T<E_T>);
147
148
// Generate forward declarations for binary operators.
149
#define MARRAY_BINOP_FWD_DECLS(A_T, API) \
150
MARRAY_BINOP_DECLS (A_T, T, template <typename T>, API, , A_T<T>, T) \
151
MARRAY_BINOP_DECLS (A_T, T, template <typename T>, API, , T, A_T<T>) \
152
MARRAY_AA_BINOP_DECLS (A_T, T, template <typename T>, API, )
153
154
#define MDIAGARRAY2_BINOP_FWD_DECLS(A_T, API) \
155
MDIAGARRAY2_DAS_BINOP_DECLS (A_T, T, template <typename T>, API, , A_T<T>, T) \
156
MDIAGARRAY2_SDA_BINOP_DECLS (A_T, T, template <typename T>, API, , T, A_T<T>) \
157
MDIAGARRAY2_DADA_BINOP_DECLS (A_T, T, template <typename T>, API, )
158
159
// Generate friend declarations for the binary operators.
160
#define MARRAY_BINOP_FRIENDS(A_T, API) \
161
MARRAY_BINOP_DECLS (A_T, T, friend, API, <>, A_T<T>, T) \
162
MARRAY_BINOP_DECLS (A_T, T, friend, API, <>, T, A_T<T>) \
163
MARRAY_AA_BINOP_DECLS (A_T, T, friend, API, <>)
164
165
#define MDIAGARRAY2_BINOP_FRIENDS(A_T, API) \
166
MDIAGARRAY2_DAS_BINOP_DECLS (A_T, T, friend, API, <>, A_T<T>, T) \
167
MDIAGARRAY2_SDA_BINOP_DECLS (A_T, T, friend, API, <>, T, A_T<T>) \
168
MDIAGARRAY2_DADA_BINOP_DECLS (A_T, T, friend, API, <>)
169
170
// A function that can be used to forward binary operations from derived
171
// classes back to us.
172
#define MARRAY_BINOP_FWD_FCN(R, F, T, C_X, X_T, C_Y, Y_T) \
173
inline R \
174
F (const X_T& x, const Y_T& y) \
175
{ \
176
return R (F (C_X (x), C_Y (y))); \
177
}
178
179
// The binary operators that we care about forwarding. We have two
180
// sets of macros since the MArray OP MArray operations use functions
181
// (product and quotient) instead of operators (*, /).
182
#define MARRAY_BINOP_FWD_DEFS(R, T, C_X, X_T, C_Y, Y_T) \
183
MARRAY_BINOP_FWD_FCN (R, operator +, T, C_X, X_T, C_Y, Y_T) \
184
MARRAY_BINOP_FWD_FCN (R, operator -, T, C_X, X_T, C_Y, Y_T) \
185
MARRAY_BINOP_FWD_FCN (R, operator *, T, C_X, X_T, C_Y, Y_T) \
186
MARRAY_BINOP_FWD_FCN (R, operator /, T, C_X, X_T, C_Y, Y_T)
187
188
#define MARRAY_AA_BINOP_FWD_DEFS(R, T, C_X, X_T, C_Y, Y_T) \
189
MARRAY_BINOP_FWD_FCN (R, operator +, T, C_X, X_T, C_Y, Y_T) \
190
MARRAY_BINOP_FWD_FCN (R, operator -, T, C_X, X_T, C_Y, Y_T) \
191
MARRAY_BINOP_FWD_FCN (R, product, T, C_X, X_T, C_Y, Y_T) \
192
MARRAY_BINOP_FWD_FCN (R, quotient, T, C_X, X_T, C_Y, Y_T)
193
194
#define MDIAGARRAY2_DAS_BINOP_FWD_DEFS(R, T, C_X, X_T, C_Y, Y_T) \
195
MARRAY_BINOP_FWD_FCN (R, operator *, T, C_X, X_T, C_Y, Y_T) \
196
MARRAY_BINOP_FWD_FCN (R, operator /, T, C_X, X_T, C_Y, Y_T)
197
198
#define MDIAGARRAY2_SDA_BINOP_FWD_DEFS(R, T, C_X, X_T, C_Y, Y_T) \
199
MARRAY_BINOP_FWD_FCN (R, operator *, T, C_X, X_T, C_Y, Y_T)
200
201
#define MDIAGARRAY2_DADA_BINOP_FWD_DEFS(R, T, C_X, X_T, C_Y, Y_T) \
202
MARRAY_BINOP_FWD_FCN (R, operator +, T, C_X, X_T, C_Y, Y_T) \
203
MARRAY_BINOP_FWD_FCN (R, operator -, T, C_X, X_T, C_Y, Y_T) \
204
MARRAY_BINOP_FWD_FCN (R, product, T, C_X, X_T, C_Y, Y_T)
205
206
// Forward declarations for the MArray operators.
207
#define MARRAY_OPS_FORWARD_DECLS(A_T, API) \
208
template <class T> \
209
class A_T; \
210
\
211
MARRAY_OP_ASSIGN_FWD_DECLS1 (A_T, T, API) \
212
MARRAY_OP_ASSIGN_FWD_DECLS (A_T, A_T<T>, API) \
213
MARRAY_UNOP_FWD_DECLS (A_T, API) \
214
MARRAY_BINOP_FWD_DECLS (A_T, API)
215
216
#define MDIAGARRAY2_OPS_FORWARD_DECLS(A_T, API) \
217
template <class T> \
218
class A_T; \
219
\
220
MARRAY_UNOP_FWD_DECLS (A_T, API) \
221
MDIAGARRAY2_BINOP_FWD_DECLS (A_T, API)
222
223
// Friend declarations for the MArray operators.
224
#define MARRAY_OPS_FRIEND_DECLS(A_T, API) \
225
MARRAY_OP_ASSIGN_FRIENDS1 (A_T, T, API) \
226
MARRAY_OP_ASSIGN_FRIENDS (A_T, A_T<T>, API) \
227
MARRAY_UNOP_FRIENDS (A_T, API) \
228
MARRAY_BINOP_FRIENDS (A_T, API)
229
230
#define MDIAGARRAY2_OPS_FRIEND_DECLS(A_T, API) \
231
MARRAY_UNOP_FRIENDS (A_T, API) \
232
MDIAGARRAY2_BINOP_FRIENDS (A_T, API)
233
234
// Define all the MArray forwarding functions for return type R and
235
// MArray element type T
236
#define MARRAY_FORWARD_DEFS(B, R, T) \
237
MARRAY_OP_ASSIGN_FWD_DEFS1 \
238
(R, T, dynamic_cast<B<T>&>, R, , T) \
239
\
240
MARRAY_OP_ASSIGN_FWD_DEFS \
241
(R, T, \
242
dynamic_cast<B<T>&>, R, dynamic_cast<const B<T>&>, R) \
243
\
244
MARRAY_UNOP_FWD_DEFS \
245
(R, T, dynamic_cast<const B<T>&>, R) \
246
\
247
MARRAY_BINOP_FWD_DEFS \
248
(R, T, dynamic_cast<const B<T>&>, R, , T) \
249
\
250
MARRAY_BINOP_FWD_DEFS \
251
(R, T, , T, dynamic_cast<const B<T>&>, R) \
252
\
253
MARRAY_AA_BINOP_FWD_DEFS \
254
(R, T, dynamic_cast<const B<T>&>, R, dynamic_cast<const B<T>&>, R)
255
256
#define MDIAGARRAY2_FORWARD_DEFS(B, R, T) \
257
MARRAY_UNOP_FWD_DEFS \
258
(R, T, dynamic_cast<const B<T>&>, R) \
259
\
260
MDIAGARRAY2_DAS_BINOP_FWD_DEFS \
261
(R, T, dynamic_cast<const B<T>&>, R, , T) \
262
\
263
MDIAGARRAY2_SDA_BINOP_FWD_DEFS \
264
(R, T, , T, dynamic_cast<const B<T>&>, R) \
265
\
266
MDIAGARRAY2_DADA_BINOP_FWD_DEFS \
267
(R, T, dynamic_cast<const B<T>&>, R, dynamic_cast<const B<T>&>, R)
268
269
#endif
Generated on Thu Jun 4 2015 23:30:23 for GNU Octave by
1.8.8