Mercurial > hg > octave-jordi
annotate liboctave/MArray2.cc @ 9546:1beb23d2b892
optimize op= in common cases
| author | Jaroslav Hajek <highegg@gmail.com> |
|---|---|
| date | Wed, 19 Aug 2009 13:47:59 +0200 |
| parents | a1dbe9d80eee |
| children | 3a1dd361f978 |
| rev | line source |
|---|---|
| 1988 | 1 /* |
| 2 | |
| 7017 | 3 Copyright (C) 1996, 1997, 1998, 2000, 2002, 2003, 2004, 2005, 2007 |
| 4 John W. Eaton | |
| 1988 | 5 |
| 6 This file is part of Octave. | |
| 7 | |
| 8 Octave is free software; you can redistribute it and/or modify it | |
| 9 under the terms of the GNU General Public License as published by the | |
| 7016 | 10 Free Software Foundation; either version 3 of the License, or (at your |
| 11 option) any later version. | |
| 1988 | 12 |
| 13 Octave is distributed in the hope that it will be useful, but WITHOUT | |
| 14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 16 for more details. | |
| 17 | |
| 18 You should have received a copy of the GNU General Public License | |
| 7016 | 19 along with Octave; see the file COPYING. If not, see |
| 20 <http://www.gnu.org/licenses/>. | |
| 1988 | 21 |
| 22 */ | |
| 23 | |
| 24 #ifdef HAVE_CONFIG_H | |
| 25 #include <config.h> | |
| 26 #endif | |
| 27 | |
| 28 #include "MArray2.h" | |
| 4669 | 29 #include "Array-util.h" |
| 1988 | 30 #include "lo-error.h" |
| 31 | |
| 32 #include "MArray-defs.h" | |
| 33 | |
| 34 // Two dimensional array with math ops. | |
| 35 | |
| 36 // Element by element MArray2 by scalar ops. | |
| 37 | |
| 38 template <class T> | |
| 39 MArray2<T>& | |
| 40 operator += (MArray2<T>& a, const T& s) | |
| 41 { | |
|
9546
1beb23d2b892
optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
42 if (a.is_shared ()) |
|
1beb23d2b892
optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
43 return a = a + s; |
| 4646 | 44 DO_VS_OP2 (T, a, +=, s) |
| 1988 | 45 return a; |
| 46 } | |
| 47 | |
| 48 template <class T> | |
| 49 MArray2<T>& | |
| 50 operator -= (MArray2<T>& a, const T& s) | |
| 51 { | |
|
9546
1beb23d2b892
optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
52 if (a.is_shared ()) |
|
1beb23d2b892
optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
53 return a = a - s; |
| 4646 | 54 DO_VS_OP2 (T, a, -=, s) |
| 1988 | 55 return a; |
| 56 } | |
| 57 | |
|
9546
1beb23d2b892
optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
58 template <class T> |
|
1beb23d2b892
optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
59 MArray2<T>& |
|
1beb23d2b892
optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
60 operator *= (MArray2<T>& a, const T& s) |
|
1beb23d2b892
optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
61 { |
|
1beb23d2b892
optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
62 if (a.is_shared ()) |
|
1beb23d2b892
optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
63 return a = a * s; |
|
1beb23d2b892
optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
64 DO_VS_OP2 (T, a, *=, s) |
|
1beb23d2b892
optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
65 return a; |
|
1beb23d2b892
optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
66 } |
|
1beb23d2b892
optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
67 |
|
1beb23d2b892
optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
68 template <class T> |
|
1beb23d2b892
optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
69 MArray2<T>& |
|
1beb23d2b892
optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
70 operator /= (MArray2<T>& a, const T& s) |
|
1beb23d2b892
optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
71 { |
|
1beb23d2b892
optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
72 if (a.is_shared ()) |
|
1beb23d2b892
optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
73 return a = a / s; |
|
1beb23d2b892
optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
74 DO_VS_OP2 (T, a, /=, s) |
|
1beb23d2b892
optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
75 return a; |
|
1beb23d2b892
optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
76 } |
|
1beb23d2b892
optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
77 |
| 1988 | 78 // Element by element MArray2 by MArray2 ops. |
| 79 | |
| 80 template <class T> | |
| 81 MArray2<T>& | |
| 82 operator += (MArray2<T>& a, const MArray2<T>& b) | |
| 83 { | |
|
9546
1beb23d2b892
optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
84 if (a.is_shared ()) |
|
1beb23d2b892
optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
85 return a = a + b; |
| 5275 | 86 octave_idx_type r = a.rows (); |
| 87 octave_idx_type c = a.cols (); | |
| 88 octave_idx_type br = b.rows (); | |
| 89 octave_idx_type bc = b.cols (); | |
| 2383 | 90 if (r != br || c != bc) |
| 91 gripe_nonconformant ("operator +=", r, c, br, bc); | |
| 1988 | 92 else |
| 93 { | |
| 94 if (r > 0 && c > 0) | |
| 95 { | |
| 5275 | 96 octave_idx_type l = a.length (); |
| 4646 | 97 DO_VV_OP2 (T, a, +=, b); |
| 1988 | 98 } |
| 99 } | |
| 100 return a; | |
| 101 } | |
| 102 | |
| 103 template <class T> | |
| 104 MArray2<T>& | |
| 105 operator -= (MArray2<T>& a, const MArray2<T>& b) | |
| 106 { | |
|
9546
1beb23d2b892
optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
107 if (a.is_shared ()) |
|
1beb23d2b892
optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
108 return a = a - b; |
| 5275 | 109 octave_idx_type r = a.rows (); |
| 110 octave_idx_type c = a.cols (); | |
| 111 octave_idx_type br = b.rows (); | |
| 112 octave_idx_type bc = b.cols (); | |
| 2383 | 113 if (r != br || c != bc) |
| 114 gripe_nonconformant ("operator -=", r, c, br, bc); | |
| 1988 | 115 else |
| 116 { | |
| 117 if (r > 0 && c > 0) | |
| 118 { | |
| 5275 | 119 octave_idx_type l = a.length (); |
| 4646 | 120 DO_VV_OP2 (T, a, -=, b); |
| 1988 | 121 } |
| 122 } | |
| 123 return a; | |
| 124 } | |
| 125 | |
| 126 // Element by element MArray2 by scalar ops. | |
| 127 | |
| 128 #define MARRAY_A2S_OP(OP) \ | |
| 129 template <class T> \ | |
| 130 MArray2<T> \ | |
| 131 operator OP (const MArray2<T>& a, const T& s) \ | |
| 132 { \ | |
| 3504 | 133 MArray2<T> result (a.rows (), a.cols ()); \ |
| 134 T *r = result.fortran_vec (); \ | |
| 5275 | 135 octave_idx_type l = a.length (); \ |
| 3504 | 136 const T *v = a.data (); \ |
| 137 DO_VS_OP (r, l, v, OP, s); \ | |
| 138 return result; \ | |
| 1988 | 139 } |
| 140 | |
| 141 MARRAY_A2S_OP (+) | |
| 142 MARRAY_A2S_OP (-) | |
| 143 MARRAY_A2S_OP (*) | |
| 144 MARRAY_A2S_OP (/) | |
| 145 | |
| 146 // Element by element scalar by MArray2 ops. | |
| 147 | |
| 148 #define MARRAY_SA2_OP(OP) \ | |
| 149 template <class T> \ | |
| 150 MArray2<T> \ | |
| 151 operator OP (const T& s, const MArray2<T>& a) \ | |
| 152 { \ | |
| 3504 | 153 MArray2<T> result (a.rows (), a.cols ()); \ |
| 154 T *r = result.fortran_vec (); \ | |
| 5275 | 155 octave_idx_type l = a.length (); \ |
| 3504 | 156 const T *v = a.data (); \ |
| 157 DO_SV_OP (r, l, s, OP, v); \ | |
| 158 return result; \ | |
| 1988 | 159 } |
| 160 | |
| 161 MARRAY_SA2_OP (+) | |
| 162 MARRAY_SA2_OP (-) | |
| 163 MARRAY_SA2_OP (*) | |
| 164 MARRAY_SA2_OP (/) | |
| 165 | |
| 166 // Element by element MArray2 by MArray2 ops. | |
| 167 | |
| 2383 | 168 #define MARRAY_A2A2_OP(FCN, OP) \ |
| 1988 | 169 template <class T> \ |
| 170 MArray2<T> \ | |
| 171 FCN (const MArray2<T>& a, const MArray2<T>& b) \ | |
| 172 { \ | |
| 5275 | 173 octave_idx_type a_nr = a.rows (); \ |
| 174 octave_idx_type a_nc = a.cols (); \ | |
| 175 octave_idx_type b_nr = b.rows (); \ | |
| 176 octave_idx_type b_nc = b.cols (); \ | |
| 3504 | 177 if (a_nr != b_nr || a_nc != b_nc) \ |
| 1988 | 178 { \ |
| 3504 | 179 gripe_nonconformant (#FCN, a_nr, a_nc, b_nr, b_nc); \ |
| 1988 | 180 return MArray2<T> (); \ |
| 181 } \ | |
| 3504 | 182 if (a_nr == 0 || a_nc == 0) \ |
| 183 return MArray2<T> (a_nr, a_nc); \ | |
| 5275 | 184 octave_idx_type l = a.length (); \ |
| 3504 | 185 MArray2<T> result (a_nr, a_nc); \ |
| 186 T *r = result.fortran_vec (); \ | |
| 187 const T *x = a.data (); \ | |
| 188 const T *y = b.data (); \ | |
| 189 DO_VV_OP (r, l, x, OP, y); \ | |
| 190 return result; \ | |
| 1988 | 191 } |
| 192 | |
| 2383 | 193 MARRAY_A2A2_OP (operator +, +) |
| 194 MARRAY_A2A2_OP (operator -, -) | |
| 195 MARRAY_A2A2_OP (product, *) | |
| 196 MARRAY_A2A2_OP (quotient, /) | |
| 1988 | 197 |
| 198 // Unary MArray2 ops. | |
| 199 | |
| 200 template <class T> | |
| 201 MArray2<T> | |
| 3574 | 202 operator + (const MArray2<T>& a) |
| 203 { | |
| 204 return a; | |
| 205 } | |
| 206 | |
| 207 template <class T> | |
| 208 MArray2<T> | |
| 1988 | 209 operator - (const MArray2<T>& a) |
| 210 { | |
| 5275 | 211 octave_idx_type l = a.length (); |
| 3504 | 212 MArray2<T> result (a.rows (), a.cols ()); |
| 213 T *r = result.fortran_vec (); | |
| 214 const T *x = a.data (); | |
| 215 NEG_V (r, l, x); | |
| 216 return result; | |
| 1988 | 217 } |
| 218 | |
| 219 /* | |
| 220 ;;; Local Variables: *** | |
| 221 ;;; mode: C++ *** | |
| 222 ;;; End: *** | |
| 223 */ |