Mercurial > octave-nkf
annotate liboctave/MArray-defs.h @ 7948:af10baa63915 ss-3-1-50
3.1.50 snapshot
| author | John W. Eaton <jwe@octave.org> |
|---|---|
| date | Fri, 18 Jul 2008 17:42:48 -0400 |
| parents | 82be108cc558 |
| children | b11c31849b44 |
| rev | line source |
|---|---|
| 7016 | 1 /* |
| 2 | |
| 7017 | 3 Copyright (C) 1996, 1999, 2000, 2003, 2005, 2006, 2007 John W. Eaton |
| 7016 | 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 | |
| 3741 | 23 #if !defined (octave_MArray_defs_h) |
| 24 #define octave_MArray_defs_h 1 | |
| 25 | |
| 3649 | 26 // Nothing like a little CPP abuse to brighten everyone's day. |
| 1988 | 27 |
| 3504 | 28 #define DO_VS_OP(r, l, v, OP, s) \ |
| 1988 | 29 if (l > 0) \ |
| 30 { \ | |
| 5275 | 31 for (octave_idx_type i = 0; i < l; i++) \ |
| 3504 | 32 r[i] = v[i] OP s; \ |
| 1988 | 33 } |
| 34 | |
| 3504 | 35 #define DO_SV_OP(r, l, s, OP, v) \ |
| 1988 | 36 if (l > 0) \ |
| 37 { \ | |
| 5275 | 38 for (octave_idx_type i = 0; i < l; i++) \ |
| 3504 | 39 r[i] = s OP v[i]; \ |
| 1988 | 40 } |
| 41 | |
| 3504 | 42 #define DO_VV_OP(r, l, x, OP, y) \ |
| 1988 | 43 if (l > 0) \ |
| 44 { \ | |
| 5275 | 45 for (octave_idx_type i = 0; i < l; i++) \ |
| 3504 | 46 r[i] = x[i] OP y[i]; \ |
| 1988 | 47 } |
| 48 | |
| 3504 | 49 #define NEG_V(r, l, x) \ |
| 1988 | 50 if (l > 0) \ |
| 51 { \ | |
| 5275 | 52 for (octave_idx_type i = 0; i < l; i++) \ |
| 3504 | 53 r[i] = -x[i]; \ |
| 1988 | 54 } |
| 55 | |
| 4646 | 56 #define DO_VS_OP2(T, a, OP, s) \ |
| 5275 | 57 octave_idx_type l = a.length (); \ |
| 1988 | 58 if (l > 0) \ |
| 59 { \ | |
| 60 T *tmp = a.fortran_vec (); \ | |
| 5275 | 61 for (octave_idx_type i = 0; i < l; i++) \ |
| 1988 | 62 tmp[i] OP s; \ |
| 63 } | |
| 64 | |
| 4646 | 65 #define DO_VV_OP2(T, a, OP, b) \ |
| 1988 | 66 do \ |
| 67 { \ | |
| 68 T *a_tmp = a.fortran_vec (); \ | |
| 69 const T *b_tmp = b.data (); \ | |
| 5275 | 70 for (octave_idx_type i = 0; i < l; i++) \ |
| 3243 | 71 a_tmp[i] OP b_tmp[i]; \ |
| 1988 | 72 } \ |
| 73 while (0) | |
| 74 | |
| 3573 | 75 // A macro that can be used to declare and instantiate OP= operators. |
| 6708 | 76 #define MARRAY_OP_ASSIGN_DECL(A_T, E_T, OP, PFX, API, LTGT, RHS_T) \ |
| 77 PFX API A_T<E_T>& \ | |
| 3573 | 78 operator OP LTGT (A_T<E_T>&, const RHS_T&) |
| 79 | |
| 80 // All the OP= operators that we care about. | |
| 6708 | 81 #define MARRAY_OP_ASSIGN_DECLS(A_T, E_T, PFX, API, LTGT, RHS_T) \ |
| 82 MARRAY_OP_ASSIGN_DECL (A_T, E_T, +=, PFX, API, LTGT, RHS_T); \ | |
| 83 MARRAY_OP_ASSIGN_DECL (A_T, E_T, -=, PFX, API, LTGT, RHS_T); | |
| 3573 | 84 |
| 85 // Generate forward declarations for OP= operators. | |
| 6708 | 86 #define MARRAY_OP_ASSIGN_FWD_DECLS(A_T, RHS_T, API) \ |
| 87 MARRAY_OP_ASSIGN_DECLS (A_T, T, template <typename T>, API, , RHS_T) | |
| 3573 | 88 |
| 89 // Generate friend declarations for the OP= operators. | |
| 6708 | 90 #define MARRAY_OP_ASSIGN_FRIENDS(A_T, RHS_T, API) \ |
| 91 MARRAY_OP_ASSIGN_DECLS (A_T, T, friend, API, <>, RHS_T) | |
| 3573 | 92 |
| 93 // Instantiate the OP= operators. | |
| 6708 | 94 #define MARRAY_OP_ASSIGN_DEFS(A_T, E_T, RHS_T, API) \ |
| 95 MARRAY_OP_ASSIGN_DECLS (A_T, E_T, template, API, , RHS_T) | |
| 3573 | 96 |
| 97 // A function that can be used to forward OP= operations from derived | |
| 98 // classes back to us. | |
| 99 #define MARRAY_OP_ASSIGN_FWD_FCN(R, F, T, C_X, X_T, C_Y, Y_T) \ | |
| 100 inline R \ | |
| 101 F (X_T& x, const Y_T& y) \ | |
| 102 { \ | |
| 103 return R (F (C_X (x), C_Y (y))); \ | |
| 104 } | |
| 105 | |
| 106 // All the OP= operators that we care about forwarding. | |
| 107 #define MARRAY_OP_ASSIGN_FWD_DEFS(R, T, C_X, X_T, C_Y, Y_T) \ | |
| 108 MARRAY_OP_ASSIGN_FWD_FCN (R, operator +=, T, C_X, X_T, C_Y, Y_T) \ | |
| 109 MARRAY_OP_ASSIGN_FWD_FCN (R, operator -=, T, C_X, X_T, C_Y, Y_T) | |
| 110 | |
| 111 // A macro that can be used to declare and instantiate unary operators. | |
| 6708 | 112 #define MARRAY_UNOP(A_T, E_T, F, PFX, API, LTGT) \ |
| 113 PFX API A_T<E_T> \ | |
| 3573 | 114 F LTGT (const A_T<E_T>&) |
| 115 | |
| 116 // All the unary operators that we care about. | |
| 6708 | 117 #define MARRAY_UNOP_DECLS(A_T, E_T, PFX, API, LTGT) \ |
| 118 MARRAY_UNOP (A_T, E_T, operator +, PFX, API, LTGT); \ | |
| 119 MARRAY_UNOP (A_T, E_T, operator -, PFX, API, LTGT); | |
| 3573 | 120 |
| 121 // Generate forward declarations for unary operators. | |
| 6708 | 122 #define MARRAY_UNOP_FWD_DECLS(A_T, API) \ |
| 123 MARRAY_UNOP_DECLS (A_T, T, template <typename T>, API, ) | |
| 3573 | 124 |
| 125 // Generate friend declarations for the unary operators. | |
| 6708 | 126 #define MARRAY_UNOP_FRIENDS(A_T, API) \ |
| 127 MARRAY_UNOP_DECLS (A_T, T, friend, API, <>) | |
| 3573 | 128 |
| 129 // Instantiate the unary operators. | |
| 6708 | 130 #define MARRAY_UNOP_DEFS(A_T, E_T, API) \ |
| 131 MARRAY_UNOP_DECLS (A_T, E_T, template, API, ) | |
| 3573 | 132 |
| 133 // A function that can be used to forward unary operations from derived | |
| 134 // classes back to us. | |
| 135 #define MARRAY_UNOP_FWD_FCN(R, F, T, C_X, X_T) \ | |
| 136 inline R \ | |
| 137 F (const X_T& x) \ | |
| 138 { \ | |
| 139 return R (F (C_X (x))); \ | |
| 140 } | |
| 141 | |
| 142 // All the unary operators that we care about forwarding. | |
| 143 #define MARRAY_UNOP_FWD_DEFS(R, T, C_X, X_T) \ | |
| 144 MARRAY_UNOP_FWD_FCN (R, operator +, T, C_X, X_T) \ | |
| 145 MARRAY_UNOP_FWD_FCN (R, operator -, T, C_X, X_T) | |
| 146 | |
| 147 // A macro that can be used to declare and instantiate binary operators. | |
| 6708 | 148 #define MARRAY_BINOP_DECL(A_T, E_T, F, PFX, API, LTGT, X_T, Y_T) \ |
| 149 PFX API A_T<E_T> \ | |
| 3573 | 150 F LTGT (const X_T&, const Y_T&) |
| 151 | |
| 152 // All the binary operators that we care about. We have two | |
| 153 // sets of macros since the MArray OP MArray operations use functions | |
| 154 // (product and quotient) instead of operators (*, /). | |
| 6708 | 155 #define MARRAY_BINOP_DECLS(A_T, E_T, PFX, API, LTGT, X_T, Y_T) \ |
| 156 MARRAY_BINOP_DECL (A_T, E_T, operator +, PFX, API, LTGT, X_T, Y_T); \ | |
| 157 MARRAY_BINOP_DECL (A_T, E_T, operator -, PFX, API, LTGT, X_T, Y_T); \ | |
| 158 MARRAY_BINOP_DECL (A_T, E_T, operator *, PFX, API, LTGT, X_T, Y_T); \ | |
| 159 MARRAY_BINOP_DECL (A_T, E_T, operator /, PFX, API, LTGT, X_T, Y_T); | |
| 3573 | 160 |
| 6708 | 161 #define MARRAY_AA_BINOP_DECLS(A_T, E_T, PFX, API, LTGT) \ |
| 162 MARRAY_BINOP_DECL (A_T, E_T, operator +, PFX, API, LTGT, A_T<E_T>, A_T<E_T>); \ | |
| 163 MARRAY_BINOP_DECL (A_T, E_T, operator -, PFX, API, LTGT, A_T<E_T>, A_T<E_T>); \ | |
| 164 MARRAY_BINOP_DECL (A_T, E_T, quotient, PFX, API, LTGT, A_T<E_T>, A_T<E_T>); \ | |
| 165 MARRAY_BINOP_DECL (A_T, E_T, product, PFX, API, LTGT, A_T<E_T>, A_T<E_T>); | |
| 3573 | 166 |
| 6708 | 167 #define MDIAGARRAY2_DAS_BINOP_DECLS(A_T, E_T, PFX, API, LTGT, X_T, Y_T) \ |
| 168 MARRAY_BINOP_DECL (A_T, E_T, operator *, PFX, API, LTGT, X_T, Y_T); \ | |
| 169 MARRAY_BINOP_DECL (A_T, E_T, operator /, PFX, API, LTGT, X_T, Y_T); | |
| 3580 | 170 |
| 6708 | 171 #define MDIAGARRAY2_SDA_BINOP_DECLS(A_T, E_T, PFX, API, LTGT, X_T, Y_T) \ |
| 172 MARRAY_BINOP_DECL (A_T, E_T, operator *, PFX, API, LTGT, X_T, Y_T); | |
| 3580 | 173 |
| 6708 | 174 #define MDIAGARRAY2_DADA_BINOP_DECLS(A_T, E_T, PFX, API, LTGT) \ |
| 175 MARRAY_BINOP_DECL (A_T, E_T, operator +, PFX, API, LTGT, A_T<E_T>, A_T<E_T>); \ | |
| 176 MARRAY_BINOP_DECL (A_T, E_T, operator -, PFX, API, LTGT, A_T<E_T>, A_T<E_T>); \ | |
| 177 MARRAY_BINOP_DECL (A_T, E_T, product, PFX, API, LTGT, A_T<E_T>, A_T<E_T>); | |
| 3580 | 178 |
| 3573 | 179 // Generate forward declarations for binary operators. |
| 6708 | 180 #define MARRAY_BINOP_FWD_DECLS(A_T, API) \ |
| 181 MARRAY_BINOP_DECLS (A_T, T, template <typename T>, API, , A_T<T>, T) \ | |
| 182 MARRAY_BINOP_DECLS (A_T, T, template <typename T>, API, , T, A_T<T>) \ | |
| 183 MARRAY_AA_BINOP_DECLS (A_T, T, template <typename T>, API, ) | |
| 3573 | 184 |
| 6708 | 185 #define MDIAGARRAY2_BINOP_FWD_DECLS(A_T, API) \ |
| 186 MDIAGARRAY2_DAS_BINOP_DECLS (A_T, T, template <typename T>, API, , A_T<T>, T) \ | |
| 187 MDIAGARRAY2_SDA_BINOP_DECLS (A_T, T, template <typename T>, API, , T, A_T<T>) \ | |
| 188 MDIAGARRAY2_DADA_BINOP_DECLS (A_T, T, template <typename T>, API, ) | |
| 3580 | 189 |
| 3573 | 190 // Generate friend declarations for the binary operators. |
| 6708 | 191 #define MARRAY_BINOP_FRIENDS(A_T, API) \ |
| 192 MARRAY_BINOP_DECLS (A_T, T, friend, API, <>, A_T<T>, T) \ | |
| 193 MARRAY_BINOP_DECLS (A_T, T, friend, API, <>, T, A_T<T>) \ | |
| 194 MARRAY_AA_BINOP_DECLS (A_T, T, friend, API, <>) | |
| 3573 | 195 |
| 6708 | 196 #define MDIAGARRAY2_BINOP_FRIENDS(A_T, API) \ |
| 197 MDIAGARRAY2_DAS_BINOP_DECLS (A_T, T, friend, API, <>, A_T<T>, T) \ | |
| 198 MDIAGARRAY2_SDA_BINOP_DECLS (A_T, T, friend, API, <>, T, A_T<T>) \ | |
| 199 MDIAGARRAY2_DADA_BINOP_DECLS (A_T, T, friend, API, <>) | |
| 3580 | 200 |
| 3573 | 201 // Instantiate the binary operators. |
| 6708 | 202 #define MARRAY_BINOP_DEFS(A_T, E_T, API) \ |
| 203 MARRAY_BINOP_DECLS (A_T, E_T, template, API, , A_T<E_T>, E_T) \ | |
| 204 MARRAY_BINOP_DECLS (A_T, E_T, template, API, , E_T, A_T<E_T>) \ | |
| 205 MARRAY_AA_BINOP_DECLS (A_T, E_T, template, API, ) | |
| 3573 | 206 |
| 6708 | 207 #define MDIAGARRAY2_BINOP_DEFS(A_T, E_T, API) \ |
| 208 MDIAGARRAY2_DAS_BINOP_DECLS (A_T, E_T, template, API, , A_T<E_T>, E_T) \ | |
| 209 MDIAGARRAY2_SDA_BINOP_DECLS (A_T, E_T, template, API, , E_T, A_T<E_T>) \ | |
| 210 MDIAGARRAY2_DADA_BINOP_DECLS (A_T, E_T, template, API, ) | |
| 3580 | 211 |
| 3573 | 212 // A function that can be used to forward binary operations from derived |
| 213 // classes back to us. | |
| 214 #define MARRAY_BINOP_FWD_FCN(R, F, T, C_X, X_T, C_Y, Y_T) \ | |
| 215 inline R \ | |
| 216 F (const X_T& x, const Y_T& y) \ | |
| 217 { \ | |
| 218 return R (F (C_X (x), C_Y (y))); \ | |
| 219 } | |
| 220 | |
| 221 // The binary operators that we care about forwarding. We have two | |
| 222 // sets of macros since the MArray OP MArray operations use functions | |
| 223 // (product and quotient) instead of operators (*, /). | |
| 224 #define MARRAY_BINOP_FWD_DEFS(R, T, C_X, X_T, C_Y, Y_T) \ | |
| 225 MARRAY_BINOP_FWD_FCN (R, operator +, T, C_X, X_T, C_Y, Y_T) \ | |
| 226 MARRAY_BINOP_FWD_FCN (R, operator -, T, C_X, X_T, C_Y, Y_T) \ | |
| 227 MARRAY_BINOP_FWD_FCN (R, operator *, T, C_X, X_T, C_Y, Y_T) \ | |
| 228 MARRAY_BINOP_FWD_FCN (R, operator /, T, C_X, X_T, C_Y, Y_T) | |
| 229 | |
| 230 #define MARRAY_AA_BINOP_FWD_DEFS(R, T, C_X, X_T, C_Y, Y_T) \ | |
| 231 MARRAY_BINOP_FWD_FCN (R, operator +, T, C_X, X_T, C_Y, Y_T) \ | |
| 232 MARRAY_BINOP_FWD_FCN (R, operator -, T, C_X, X_T, C_Y, Y_T) \ | |
| 233 MARRAY_BINOP_FWD_FCN (R, product, T, C_X, X_T, C_Y, Y_T) \ | |
| 234 MARRAY_BINOP_FWD_FCN (R, quotient, T, C_X, X_T, C_Y, Y_T) | |
| 235 | |
| 3580 | 236 #define MDIAGARRAY2_DAS_BINOP_FWD_DEFS(R, T, C_X, X_T, C_Y, Y_T) \ |
| 237 MARRAY_BINOP_FWD_FCN (R, operator *, T, C_X, X_T, C_Y, Y_T) \ | |
| 238 MARRAY_BINOP_FWD_FCN (R, operator /, T, C_X, X_T, C_Y, Y_T) | |
| 239 | |
| 240 #define MDIAGARRAY2_SDA_BINOP_FWD_DEFS(R, T, C_X, X_T, C_Y, Y_T) \ | |
| 241 MARRAY_BINOP_FWD_FCN (R, operator *, T, C_X, X_T, C_Y, Y_T) | |
| 242 | |
| 243 #define MDIAGARRAY2_DADA_BINOP_FWD_DEFS(R, T, C_X, X_T, C_Y, Y_T) \ | |
| 244 MARRAY_BINOP_FWD_FCN (R, operator +, T, C_X, X_T, C_Y, Y_T) \ | |
| 245 MARRAY_BINOP_FWD_FCN (R, operator -, T, C_X, X_T, C_Y, Y_T) \ | |
| 246 MARRAY_BINOP_FWD_FCN (R, product, T, C_X, X_T, C_Y, Y_T) | |
| 247 | |
| 3573 | 248 // Forward declarations for the MArray operators. |
| 6708 | 249 #define MARRAY_OPS_FORWARD_DECLS(A_T, API) \ |
| 3573 | 250 template <class T> \ |
| 251 class A_T; \ | |
| 252 \ | |
| 6708 | 253 MARRAY_OP_ASSIGN_FWD_DECLS (A_T, T, API) \ |
| 254 MARRAY_OP_ASSIGN_FWD_DECLS (A_T, A_T<T>, API) \ | |
| 255 MARRAY_UNOP_FWD_DECLS (A_T, API) \ | |
| 256 MARRAY_BINOP_FWD_DECLS (A_T, API) | |
| 3573 | 257 |
| 6708 | 258 #define MDIAGARRAY2_OPS_FORWARD_DECLS(A_T, API) \ |
| 3580 | 259 template <class T> \ |
| 260 class A_T; \ | |
| 261 \ | |
| 6708 | 262 MARRAY_OP_ASSIGN_FWD_DECLS (A_T, A_T<T>, API) \ |
| 263 MARRAY_UNOP_FWD_DECLS (A_T, API) \ | |
| 264 MDIAGARRAY2_BINOP_FWD_DECLS (A_T, API) | |
| 3580 | 265 |
| 3573 | 266 // Friend declarations for the MArray operators. |
| 6708 | 267 #define MARRAY_OPS_FRIEND_DECLS(A_T, API) \ |
| 268 MARRAY_OP_ASSIGN_FRIENDS (A_T, T, API) \ | |
| 269 MARRAY_OP_ASSIGN_FRIENDS (A_T, A_T<T>, API) \ | |
| 270 MARRAY_UNOP_FRIENDS (A_T, API) \ | |
| 271 MARRAY_BINOP_FRIENDS (A_T, API) | |
| 3573 | 272 |
| 6708 | 273 #define MDIAGARRAY2_OPS_FRIEND_DECLS(A_T, API) \ |
| 274 MARRAY_OP_ASSIGN_FRIENDS (A_T, A_T<T>, API) \ | |
| 275 MARRAY_UNOP_FRIENDS (A_T, API) \ | |
| 276 MDIAGARRAY2_BINOP_FRIENDS (A_T, API) | |
| 3580 | 277 |
| 3573 | 278 // The following macros are for external use. |
| 279 | |
| 280 // Instantiate all the MArray friends for MArray element type T. | |
| 6708 | 281 #define INSTANTIATE_MARRAY_FRIENDS(T, API) \ |
| 282 MARRAY_OP_ASSIGN_DEFS (MArray, T, T, API) \ | |
| 283 MARRAY_OP_ASSIGN_DEFS (MArray, T, MArray<T>, API) \ | |
| 284 MARRAY_UNOP_DEFS (MArray, T, API) \ | |
| 285 MARRAY_BINOP_DEFS (MArray, T, API) | |
| 3573 | 286 |
| 4513 | 287 // Instantiate all the MArray2 friends for MArray2 element type T. |
| 6708 | 288 #define INSTANTIATE_MARRAY2_FRIENDS(T, API) \ |
| 289 MARRAY_OP_ASSIGN_DEFS (MArray2, T, T, API) \ | |
| 290 MARRAY_OP_ASSIGN_DEFS (MArray2, T, MArray2<T>, API) \ | |
| 291 MARRAY_UNOP_DEFS (MArray2, T, API) \ | |
| 292 MARRAY_BINOP_DEFS (MArray2, T, API) | |
| 3573 | 293 |
| 4513 | 294 // Instantiate all the MArrayN friends for MArrayN element type T. |
| 6708 | 295 #define INSTANTIATE_MARRAYN_FRIENDS(T, API) \ |
| 296 MARRAY_OP_ASSIGN_DEFS (MArrayN, T, T, API) \ | |
| 297 MARRAY_OP_ASSIGN_DEFS (MArrayN, T, MArrayN<T>, API) \ | |
| 298 MARRAY_UNOP_DEFS (MArrayN, T, API) \ | |
| 299 MARRAY_BINOP_DEFS (MArrayN, T, API) | |
| 4513 | 300 |
| 301 // Instantiate all the MDiagArray2 friends for MDiagArray2 element type T. | |
| 6708 | 302 #define INSTANTIATE_MDIAGARRAY2_FRIENDS(T, API) \ |
| 303 MARRAY_OP_ASSIGN_DEFS (MDiagArray2, T, MDiagArray2<T>, API) \ | |
| 304 MARRAY_UNOP_DEFS (MDiagArray2, T, API) \ | |
| 305 MDIAGARRAY2_BINOP_DEFS (MDiagArray2, T, API) | |
| 3580 | 306 |
| 3573 | 307 // Define all the MArray forwarding functions for return type R and |
| 308 // MArray element type T | |
| 309 #define MARRAY_FORWARD_DEFS(B, R, T) \ | |
| 310 MARRAY_OP_ASSIGN_FWD_DEFS \ | |
| 311 (R, T, dynamic_cast<B<T>&>, R, , T) \ | |
| 312 \ | |
| 313 MARRAY_OP_ASSIGN_FWD_DEFS \ | |
| 314 (R, T, \ | |
| 315 dynamic_cast<B<T>&>, R, dynamic_cast<const B<T>&>, R) \ | |
| 316 \ | |
| 317 MARRAY_UNOP_FWD_DEFS \ | |
| 318 (R, T, dynamic_cast<const B<T>&>, R) \ | |
| 319 \ | |
| 320 MARRAY_BINOP_FWD_DEFS \ | |
| 321 (R, T, dynamic_cast<const B<T>&>, R, , T) \ | |
| 322 \ | |
| 323 MARRAY_BINOP_FWD_DEFS \ | |
| 324 (R, T, , T, dynamic_cast<const B<T>&>, R) \ | |
| 325 \ | |
| 326 MARRAY_AA_BINOP_FWD_DEFS \ | |
| 327 (R, T, dynamic_cast<const B<T>&>, R, dynamic_cast<const B<T>&>, R) | |
| 328 | |
| 3580 | 329 #define MDIAGARRAY2_FORWARD_DEFS(B, R, T) \ |
| 330 MARRAY_OP_ASSIGN_FWD_DEFS \ | |
| 331 (R, T, \ | |
| 332 dynamic_cast<B<T>&>, R, dynamic_cast<const B<T>&>, R) \ | |
| 333 \ | |
| 334 MARRAY_UNOP_FWD_DEFS \ | |
| 335 (R, T, dynamic_cast<const B<T>&>, R) \ | |
| 336 \ | |
| 337 MDIAGARRAY2_DAS_BINOP_FWD_DEFS \ | |
| 338 (R, T, dynamic_cast<const B<T>&>, R, , T) \ | |
| 339 \ | |
| 340 MDIAGARRAY2_SDA_BINOP_FWD_DEFS \ | |
| 341 (R, T, , T, dynamic_cast<const B<T>&>, R) \ | |
| 342 \ | |
| 343 MDIAGARRAY2_DADA_BINOP_FWD_DEFS \ | |
| 344 (R, T, dynamic_cast<const B<T>&>, R, dynamic_cast<const B<T>&>, R) | |
| 345 | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7101
diff
changeset
|
346 #define MARRAY_NORM_BODY(TYPE, RTYPE, blas_norm, BLAS_NORM, NAN_VALUE) \ |
| 6508 | 347 \ |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7101
diff
changeset
|
348 RTYPE retval = NAN_VALUE; \ |
| 6508 | 349 \ |
| 350 octave_idx_type len = length (); \ | |
| 351 \ | |
| 352 if (len > 0) \ | |
| 353 { \ | |
| 354 const TYPE *d = data (); \ | |
| 355 \ | |
| 356 if (p == -1) \ | |
| 357 { \ | |
| 358 /* Frobenius norm. */ \ | |
| 359 retval = 0; \ | |
| 360 \ | |
| 7101 | 361 /* precondition */ \ |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7101
diff
changeset
|
362 RTYPE inf_norm = 0.; \ |
| 6508 | 363 for (octave_idx_type i = 0; i < len; i++) \ |
| 364 { \ | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7101
diff
changeset
|
365 RTYPE d_abs = std::abs (d[i]); \ |
| 7101 | 366 if (d_abs > inf_norm) \ |
| 367 inf_norm = d_abs; \ | |
| 368 } \ | |
| 369 inf_norm = (inf_norm == octave_Inf || inf_norm == 0. ? 1.0 : \ | |
| 370 inf_norm); \ | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7101
diff
changeset
|
371 RTYPE scale = 1. / inf_norm; \ |
| 7101 | 372 \ |
| 373 for (octave_idx_type i = 0; i < len; i++) \ | |
| 374 { \ | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7101
diff
changeset
|
375 RTYPE d_abs = std::abs (d[i]) * scale; \ |
| 6508 | 376 retval += d_abs * d_abs; \ |
| 377 } \ | |
| 378 \ | |
| 7101 | 379 retval = ::sqrt (retval) * inf_norm; \ |
| 6508 | 380 } \ |
| 381 else if (p == 2) \ | |
| 382 F77_FCN (blas_norm, BLAS_NORM) (len, d, 1, retval); \ | |
| 383 else if (xisinf (p)) \ | |
| 384 { \ | |
| 385 octave_idx_type i = 0; \ | |
| 386 \ | |
| 387 while (i < len && xisnan (d[i])) \ | |
| 388 i++; \ | |
| 389 \ | |
| 390 if (i < len) \ | |
| 391 retval = std::abs (d[i]); \ | |
| 392 \ | |
| 393 if (p > 0) \ | |
| 394 { \ | |
| 395 while (i < len) \ | |
| 396 { \ | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7101
diff
changeset
|
397 RTYPE d_abs = std::abs (d[i++]); \ |
| 6508 | 398 \ |
| 399 if (d_abs > retval) \ | |
| 400 retval = d_abs; \ | |
| 401 } \ | |
| 402 } \ | |
| 403 else \ | |
| 404 { \ | |
| 405 while (i < len) \ | |
| 406 { \ | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7101
diff
changeset
|
407 RTYPE d_abs = std::abs (d[i++]); \ |
| 6508 | 408 \ |
| 409 if (d_abs < retval) \ | |
| 410 retval = d_abs; \ | |
| 411 } \ | |
| 412 } \ | |
| 413 } \ | |
| 414 else \ | |
| 415 { \ | |
| 416 retval = 0; \ | |
| 417 \ | |
| 418 for (octave_idx_type i = 0; i < len; i++) \ | |
| 419 { \ | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7101
diff
changeset
|
420 RTYPE d_abs = std::abs (d[i]); \ |
| 6508 | 421 retval += pow (d_abs, p); \ |
| 422 } \ | |
| 423 \ | |
| 424 retval = pow (retval, 1/p); \ | |
| 425 } \ | |
| 426 } \ | |
| 427 \ | |
| 428 return retval | |
| 429 | |
| 3573 | 430 // Now we have all the definitions we need. |
| 431 | |
| 3741 | 432 #endif |