Mercurial > hg > octave-jordi

comparison liboctave/MArray2.cc @ 5275:23b37da9fd5b

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[project @ 2005-04-08 16:07:35 by jwe]
author jwe
date Fri, 08 Apr 2005 16:07:37 +0000
parents e35b034d3523
children 4c8a2e4e0717
comparison
equal deleted inserted replaced
5274:eae7b40388e9 5275:23b37da9fd5b
54 54
55 template <class T> 55 template <class T>
56 MArray2<T>& 56 MArray2<T>&
57 operator += (MArray2<T>& a, const MArray2<T>& b) 57 operator += (MArray2<T>& a, const MArray2<T>& b)
58 { 58 {
59 int r = a.rows (); 59 octave_idx_type r = a.rows ();
60 int c = a.cols (); 60 octave_idx_type c = a.cols ();
61 int br = b.rows (); 61 octave_idx_type br = b.rows ();
62 int bc = b.cols (); 62 octave_idx_type bc = b.cols ();
63 if (r != br || c != bc) 63 if (r != br || c != bc)
64 gripe_nonconformant ("operator +=", r, c, br, bc); 64 gripe_nonconformant ("operator +=", r, c, br, bc);
65 else 65 else
66 { 66 {
67 if (r > 0 && c > 0) 67 if (r > 0 && c > 0)
68 { 68 {
69 int l = a.length (); 69 octave_idx_type l = a.length ();
70 DO_VV_OP2 (T, a, +=, b); 70 DO_VV_OP2 (T, a, +=, b);
71 } 71 }
72 } 72 }
73 return a; 73 return a;
74 } 74 }
75 75
76 template <class T> 76 template <class T>
77 MArray2<T>& 77 MArray2<T>&
78 operator -= (MArray2<T>& a, const MArray2<T>& b) 78 operator -= (MArray2<T>& a, const MArray2<T>& b)
79 { 79 {
80 int r = a.rows (); 80 octave_idx_type r = a.rows ();
81 int c = a.cols (); 81 octave_idx_type c = a.cols ();
82 int br = b.rows (); 82 octave_idx_type br = b.rows ();
83 int bc = b.cols (); 83 octave_idx_type bc = b.cols ();
84 if (r != br || c != bc) 84 if (r != br || c != bc)
85 gripe_nonconformant ("operator -=", r, c, br, bc); 85 gripe_nonconformant ("operator -=", r, c, br, bc);
86 else 86 else
87 { 87 {
88 if (r > 0 && c > 0) 88 if (r > 0 && c > 0)
89 { 89 {
90 int l = a.length (); 90 octave_idx_type l = a.length ();
91 DO_VV_OP2 (T, a, -=, b); 91 DO_VV_OP2 (T, a, -=, b);
92 } 92 }
93 } 93 }
94 return a; 94 return a;
95 } 95 }
101 MArray2<T> \ 101 MArray2<T> \
102 operator OP (const MArray2<T>& a, const T& s) \ 102 operator OP (const MArray2<T>& a, const T& s) \
103 { \ 103 { \
104 MArray2<T> result (a.rows (), a.cols ()); \ 104 MArray2<T> result (a.rows (), a.cols ()); \
105 T *r = result.fortran_vec (); \ 105 T *r = result.fortran_vec (); \
106 int l = a.length (); \ 106 octave_idx_type l = a.length (); \
107 const T *v = a.data (); \ 107 const T *v = a.data (); \
108 DO_VS_OP (r, l, v, OP, s); \ 108 DO_VS_OP (r, l, v, OP, s); \
109 return result; \ 109 return result; \
110 } 110 }
111 111
121 MArray2<T> \ 121 MArray2<T> \
122 operator OP (const T& s, const MArray2<T>& a) \ 122 operator OP (const T& s, const MArray2<T>& a) \
123 { \ 123 { \
124 MArray2<T> result (a.rows (), a.cols ()); \ 124 MArray2<T> result (a.rows (), a.cols ()); \
125 T *r = result.fortran_vec (); \ 125 T *r = result.fortran_vec (); \
126 int l = a.length (); \ 126 octave_idx_type l = a.length (); \
127 const T *v = a.data (); \ 127 const T *v = a.data (); \
128 DO_SV_OP (r, l, s, OP, v); \ 128 DO_SV_OP (r, l, s, OP, v); \
129 return result; \ 129 return result; \
130 } 130 }
131 131
139 #define MARRAY_A2A2_OP(FCN, OP) \ 139 #define MARRAY_A2A2_OP(FCN, OP) \
140 template <class T> \ 140 template <class T> \
141 MArray2<T> \ 141 MArray2<T> \
142 FCN (const MArray2<T>& a, const MArray2<T>& b) \ 142 FCN (const MArray2<T>& a, const MArray2<T>& b) \
143 { \ 143 { \
144 int a_nr = a.rows (); \ 144 octave_idx_type a_nr = a.rows (); \
145 int a_nc = a.cols (); \ 145 octave_idx_type a_nc = a.cols (); \
146 int b_nr = b.rows (); \ 146 octave_idx_type b_nr = b.rows (); \
147 int b_nc = b.cols (); \ 147 octave_idx_type b_nc = b.cols (); \
148 if (a_nr != b_nr || a_nc != b_nc) \ 148 if (a_nr != b_nr || a_nc != b_nc) \
149 { \ 149 { \
150 gripe_nonconformant (#FCN, a_nr, a_nc, b_nr, b_nc); \ 150 gripe_nonconformant (#FCN, a_nr, a_nc, b_nr, b_nc); \
151 return MArray2<T> (); \ 151 return MArray2<T> (); \
152 } \ 152 } \
153 if (a_nr == 0 || a_nc == 0) \ 153 if (a_nr == 0 || a_nc == 0) \
154 return MArray2<T> (a_nr, a_nc); \ 154 return MArray2<T> (a_nr, a_nc); \
155 int l = a.length (); \ 155 octave_idx_type l = a.length (); \
156 MArray2<T> result (a_nr, a_nc); \ 156 MArray2<T> result (a_nr, a_nc); \
157 T *r = result.fortran_vec (); \ 157 T *r = result.fortran_vec (); \
158 const T *x = a.data (); \ 158 const T *x = a.data (); \
159 const T *y = b.data (); \ 159 const T *y = b.data (); \
160 DO_VV_OP (r, l, x, OP, y); \ 160 DO_VV_OP (r, l, x, OP, y); \
177 177
178 template <class T> 178 template <class T>
179 MArray2<T> 179 MArray2<T>
180 operator - (const MArray2<T>& a) 180 operator - (const MArray2<T>& a)
181 { 181 {
182 int l = a.length (); 182 octave_idx_type l = a.length ();
183 MArray2<T> result (a.rows (), a.cols ()); 183 MArray2<T> result (a.rows (), a.cols ());
184 T *r = result.fortran_vec (); 184 T *r = result.fortran_vec ();
185 const T *x = a.data (); 185 const T *x = a.data ();
186 NEG_V (r, l, x); 186 NEG_V (r, l, x);
187 return result; 187 return result;