Mercurial > forge

comparison main/fixed/src/fixedCColVector.cc @ 9481:d84d2fea3c90 octave-forge

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Re-enable compilation of fixed package
author jordigh
date Wed, 22 Feb 2012 22:07:33 +0000
parents f8d77845533f
children
comparison
equal deleted inserted replaced
9480:954f2f00d782 9481:d84d2fea3c90
39 39
40 // Fixed Point Complex Column Vector class 40 // Fixed Point Complex Column Vector class
41 41
42 42
43 FixedComplexColumnVector::FixedComplexColumnVector (const MArray<int> &is, 43 FixedComplexColumnVector::FixedComplexColumnVector (const MArray<int> &is,
44 const MArray<int> &ds) : MArray<FixedPointComplex> (is.length()) 44 const MArray<int> &ds)
45 : MArray<FixedPointComplex> (dim_vector (is.length(), 1))
45 { 46 {
46 if (length() != ds.length()) { 47 if (length() != ds.length()) {
47 (*current_liboctave_error_handler) ("vector size mismatch"); 48 (*current_liboctave_error_handler) ("vector size mismatch");
48 return; 49 return;
49 } 50 }
51 for (int i = 0; i < length (); i++) 52 for (int i = 0; i < length (); i++)
52 elem (i) = FixedPointComplex((unsigned int)is(i), (unsigned int)ds(i)); 53 elem (i) = FixedPointComplex((unsigned int)is(i), (unsigned int)ds(i));
53 } 54 }
54 55
55 FixedComplexColumnVector::FixedComplexColumnVector (const ColumnVector &is, 56 FixedComplexColumnVector::FixedComplexColumnVector (const ColumnVector &is,
56 const ColumnVector &ds) : MArray<FixedPointComplex> (is.length()) 57 const ColumnVector &ds)
58 : MArray<FixedPointComplex> (dim_vector (is.length(), 1))
57 { 59 {
58 if (length() != ds.length()) { 60 if (length() != ds.length()) {
59 (*current_liboctave_error_handler) ("vector size mismatch"); 61 (*current_liboctave_error_handler) ("vector size mismatch");
60 return; 62 return;
61 } 63 }
62 64
63 for (int i = 0; i < length (); i++) 65 for (int i = 0; i < length (); i++)
64 elem (i) = FixedPointComplex((unsigned int)is(i), (unsigned int)ds(i)); 66 elem (i) = FixedPointComplex((unsigned int)is(i), (unsigned int)ds(i));
65 } 67 }
66 68
67 FixedComplexColumnVector::FixedComplexColumnVector ( 69 FixedComplexColumnVector::FixedComplexColumnVector
68 const ComplexColumnVector &is, const ComplexColumnVector &ds) : 70 (const ComplexColumnVector &is, const ComplexColumnVector &ds)
69 MArray<FixedPointComplex> (is.length()) 71 : MArray<FixedPointComplex> (dim_vector (is.length(), 1))
70 { 72 {
71 if (length() != ds.length()) { 73 if (length() != ds.length()) {
72 (*current_liboctave_error_handler) ("vector size mismatch"); 74 (*current_liboctave_error_handler) ("vector size mismatch");
73 return; 75 return;
74 } 76 }
75 77
76 for (int i = 0; i < length (); i++) 78 for (int i = 0; i < length (); i++)
77 elem (i) = FixedPointComplex(is(i), ds(i)); 79 elem (i) = FixedPointComplex(is(i), ds(i));
78 } 80 }
79 81
80 FixedComplexColumnVector::FixedComplexColumnVector (unsigned int is, 82 FixedComplexColumnVector::FixedComplexColumnVector
81 unsigned int ds, const FixedComplexColumnVector& a) : 83 (unsigned int is, unsigned int ds, const FixedComplexColumnVector& a)
82 MArray<FixedPointComplex> (a.length()) 84 : MArray<FixedPointComplex> (dim_vector (a.length(), 1))
83 { 85 {
84 for (int i = 0; i < length (); i++) 86 for (int i = 0; i < length (); i++)
85 elem (i) = FixedPointComplex(is, ds, a(i)); 87 elem (i) = FixedPointComplex(is, ds, a(i));
86 } 88 }
87 89
88 FixedComplexColumnVector::FixedComplexColumnVector (Complex is, 90 FixedComplexColumnVector::FixedComplexColumnVector
89 Complex ds, const FixedComplexColumnVector& a) : 91 (Complex is, Complex ds, const FixedComplexColumnVector& a)
90 MArray<FixedPointComplex> (a.length()) 92 : MArray<FixedPointComplex> (dim_vector (a.length(), 1))
91 { 93 {
92 for (int i = 0; i < length (); i++) 94 for (int i = 0; i < length (); i++)
93 elem (i) = FixedPointComplex(is, ds, a(i)); 95 elem (i) = FixedPointComplex(is, ds, a(i));
94 } 96 }
95 97
96 FixedComplexColumnVector::FixedComplexColumnVector (const MArray<int> &is, 98 FixedComplexColumnVector::FixedComplexColumnVector
97 const MArray<int> &ds, const FixedComplexColumnVector& a) : 99 (const MArray<int> &is, const MArray<int> &ds,
98 MArray<FixedPointComplex> (is.length()) 100 const FixedComplexColumnVector& a)
101 : MArray<FixedPointComplex> (dim_vector (is.length(), 1))
99 { 102 {
100 if ((length() != ds.length()) || (length() != a.length())) { 103 if ((length() != ds.length()) || (length() != a.length())) {
101 (*current_liboctave_error_handler) ("vector size mismatch"); 104 (*current_liboctave_error_handler) ("vector size mismatch");
102 return; 105 return;
103 } 106 }
105 for (int i = 0; i < length (); i++) 108 for (int i = 0; i < length (); i++)
106 elem (i) = FixedPointComplex((unsigned int)is(i), (unsigned int)ds(i), 109 elem (i) = FixedPointComplex((unsigned int)is(i), (unsigned int)ds(i),
107 a(i)); 110 a(i));
108 } 111 }
109 112
110 FixedComplexColumnVector::FixedComplexColumnVector (const ColumnVector &is, 113 FixedComplexColumnVector::FixedComplexColumnVector
111 const ColumnVector &ds, const FixedComplexColumnVector& a) : 114 (const ColumnVector &is, const ColumnVector &ds,
112 MArray<FixedPointComplex> (is.length()) 115 const FixedComplexColumnVector& a)
116 : MArray<FixedPointComplex> (dim_vector (is.length(), 1))
113 { 117 {
114 if ((length() != ds.length()) || (length() != a.length())) { 118 if ((length() != ds.length()) || (length() != a.length())) {
115 (*current_liboctave_error_handler) ("vector size mismatch"); 119 (*current_liboctave_error_handler) ("vector size mismatch");
116 return; 120 return;
117 } 121 }
119 for (int i = 0; i < length (); i++) 123 for (int i = 0; i < length (); i++)
120 elem (i) = FixedPointComplex((unsigned int)is(i), (unsigned int)ds(i), 124 elem (i) = FixedPointComplex((unsigned int)is(i), (unsigned int)ds(i),
121 a(i)); 125 a(i));
122 } 126 }
123 127
124 FixedComplexColumnVector::FixedComplexColumnVector ( 128 FixedComplexColumnVector::FixedComplexColumnVector
125 const ComplexColumnVector &is, const ComplexColumnVector &ds, 129 (const ComplexColumnVector &is, const ComplexColumnVector &ds,
126 const FixedComplexColumnVector& a) : 130 const FixedComplexColumnVector& a)
127 MArray<FixedPointComplex> (is.length()) 131 : MArray<FixedPointComplex> (dim_vector (is.length(), 1))
128 { 132 {
129 if ((length() != ds.length()) || (length() != a.length())) { 133 if ((length() != ds.length()) || (length() != a.length())) {
130 (*current_liboctave_error_handler) ("vector size mismatch"); 134 (*current_liboctave_error_handler) ("vector size mismatch");
131 return; 135 return;
132 } 136 }
133 137
134 for (int i = 0; i < length (); i++) 138 for (int i = 0; i < length (); i++)
135 elem (i) = FixedPointComplex(is(i), ds(i), a(i)); 139 elem (i) = FixedPointComplex(is(i), ds(i), a(i));
136 } 140 }
137 141
138 FixedComplexColumnVector::FixedComplexColumnVector (unsigned int is, 142 FixedComplexColumnVector::FixedComplexColumnVector
139 unsigned int ds, const FixedColumnVector& a) : 143 (unsigned int is, unsigned int ds, const FixedColumnVector& a)
140 MArray<FixedPointComplex> (a.length()) 144 : MArray<FixedPointComplex> (dim_vector (a.length(), 1))
141 { 145 {
142 for (int i = 0; i < length (); i++) 146 for (int i = 0; i < length (); i++)
143 elem (i) = FixedPointComplex(is, ds, a(i)); 147 elem (i) = FixedPointComplex(is, ds, a(i));
144 } 148 }
145 149
146 FixedComplexColumnVector::FixedComplexColumnVector (Complex is, 150 FixedComplexColumnVector::FixedComplexColumnVector
147 Complex ds, const FixedColumnVector& a) : 151 (Complex is, Complex ds, const FixedColumnVector& a)
148 MArray<FixedPointComplex> (a.length()) 152 : MArray<FixedPointComplex> (dim_vector (a.length(), 1))
149 { 153 {
150 for (int i = 0; i < length (); i++) 154 for (int i = 0; i < length (); i++)
151 elem (i) = FixedPointComplex(is, ds, FixedPointComplex(a(i))); 155 elem (i) = FixedPointComplex(is, ds, FixedPointComplex(a(i)));
152 } 156 }
153 157
154 FixedComplexColumnVector::FixedComplexColumnVector (const MArray<int> &is, 158 FixedComplexColumnVector::FixedComplexColumnVector
155 const MArray<int> &ds, const FixedColumnVector& a) : 159 (const MArray<int> &is, const MArray<int> &ds, const FixedColumnVector& a)
156 MArray<FixedPointComplex> (is.length()) 160 : MArray<FixedPointComplex> (dim_vector (is.length(), 1))
157 { 161 {
158 if ((length() != ds.length()) || (length() != a.length())) { 162 if ((length() != ds.length()) || (length() != a.length())) {
159 (*current_liboctave_error_handler) ("vector size mismatch"); 163 (*current_liboctave_error_handler) ("vector size mismatch");
160 return; 164 return;
161 } 165 }
163 for (int i = 0; i < length (); i++) 167 for (int i = 0; i < length (); i++)
164 elem (i) = FixedPointComplex((unsigned int)is(i), (unsigned int)ds(i), 168 elem (i) = FixedPointComplex((unsigned int)is(i), (unsigned int)ds(i),
165 a(i)); 169 a(i));
166 } 170 }
167 171
168 FixedComplexColumnVector::FixedComplexColumnVector (const ColumnVector &is, 172 FixedComplexColumnVector::FixedComplexColumnVector
169 const ColumnVector &ds, const FixedColumnVector& a) : 173 (const ColumnVector &is, const ColumnVector &ds,
170 MArray<FixedPointComplex> (is.length()) 174 const FixedColumnVector& a)
175 : MArray<FixedPointComplex> (dim_vector (is.length(), 1))
171 { 176 {
172 if ((length() != ds.length()) || (length() != a.length())) { 177 if ((length() != ds.length()) || (length() != a.length())) {
173 (*current_liboctave_error_handler) ("vector size mismatch"); 178 (*current_liboctave_error_handler) ("vector size mismatch");
174 return; 179 return;
175 } 180 }
177 for (int i = 0; i < length (); i++) 182 for (int i = 0; i < length (); i++)
178 elem (i) = FixedPointComplex((unsigned int)is(i), (unsigned int)ds(i), 183 elem (i) = FixedPointComplex((unsigned int)is(i), (unsigned int)ds(i),
179 a(i)); 184 a(i));
180 } 185 }
181 186
182 FixedComplexColumnVector::FixedComplexColumnVector ( 187 FixedComplexColumnVector::FixedComplexColumnVector
183 const ComplexColumnVector &is, const ComplexColumnVector &ds, 188 (const ComplexColumnVector &is, const ComplexColumnVector &ds,
184 const FixedColumnVector& a) : MArray<FixedPointComplex> (is.length()) 189 const FixedColumnVector& a)
190 : MArray<FixedPointComplex> (dim_vector (is.length(), 1))
185 { 191 {
186 if ((length() != ds.length()) || (length() != a.length())) { 192 if ((length() != ds.length()) || (length() != a.length())) {
187 (*current_liboctave_error_handler) ("vector size mismatch"); 193 (*current_liboctave_error_handler) ("vector size mismatch");
188 return; 194 return;
189 } 195 }
190 196
191 for (int i = 0; i < length (); i++) 197 for (int i = 0; i < length (); i++)
192 elem (i) = FixedPointComplex(is(i), ds(i), FixedPointComplex(a(i))); 198 elem (i) = FixedPointComplex(is(i), ds(i), FixedPointComplex(a(i)));
193 } 199 }
194 200
195 FixedComplexColumnVector::FixedComplexColumnVector (unsigned int is, 201 FixedComplexColumnVector::FixedComplexColumnVector
196 unsigned int ds, const ComplexColumnVector& a) : 202 (unsigned int is, unsigned int ds, const ComplexColumnVector& a)
197 MArray<FixedPointComplex> (a.length()) 203 : MArray<FixedPointComplex> (dim_vector (a.length(), 1))
198 { 204 {
199 for (int i = 0; i < length (); i++) 205 for (int i = 0; i < length (); i++)
200 elem (i) = FixedPointComplex(is, ds, a(i)); 206 elem (i) = FixedPointComplex(is, ds, a(i));
201 } 207 }
202 208
203 FixedComplexColumnVector::FixedComplexColumnVector (Complex is, 209 FixedComplexColumnVector::FixedComplexColumnVector
204 Complex ds, const ComplexColumnVector& a) : 210 (Complex is, Complex ds, const ComplexColumnVector& a)
205 MArray<FixedPointComplex> (a.length()) 211 : MArray<FixedPointComplex> (dim_vector (a.length(), 1))
206 { 212 {
207 for (int i = 0; i < length (); i++) 213 for (int i = 0; i < length (); i++)
208 elem (i) = FixedPointComplex(is, ds, a(i)); 214 elem (i) = FixedPointComplex(is, ds, a(i));
209 } 215 }
210 216
211 FixedComplexColumnVector::FixedComplexColumnVector (const MArray<int> &is, 217 FixedComplexColumnVector::FixedComplexColumnVector
212 const MArray<int> &ds, const ComplexColumnVector& a) : 218 (const MArray<int> &is, const MArray<int> &ds, const ComplexColumnVector& a)
213 MArray<FixedPointComplex> (is.length()) 219 : MArray<FixedPointComplex> (dim_vector (is.length(), 1))
214 { 220 {
215 if ((length() != ds.length()) || (length() != a.length())) { 221 if ((length() != ds.length()) || (length() != a.length())) {
216 (*current_liboctave_error_handler) ("vector size mismatch"); 222 (*current_liboctave_error_handler) ("vector size mismatch");
217 return; 223 return;
218 } 224 }
220 for (int i = 0; i < length (); i++) 226 for (int i = 0; i < length (); i++)
221 elem (i) = FixedPointComplex((unsigned int)is(i), (unsigned int)ds(i), 227 elem (i) = FixedPointComplex((unsigned int)is(i), (unsigned int)ds(i),
222 a(i)); 228 a(i));
223 } 229 }
224 230
225 FixedComplexColumnVector::FixedComplexColumnVector (const ColumnVector &is, 231 FixedComplexColumnVector::FixedComplexColumnVector
226 const ColumnVector &ds, const ComplexColumnVector& a) : 232 (const ColumnVector &is, const ColumnVector &ds,
227 MArray<FixedPointComplex> (is.length()) 233 const ComplexColumnVector& a)
234 : MArray<FixedPointComplex> (dim_vector (is.length(), 1))
228 { 235 {
229 if ((length() != ds.length()) || (length() != a.length())) { 236 if ((length() != ds.length()) || (length() != a.length())) {
230 (*current_liboctave_error_handler) ("vector size mismatch"); 237 (*current_liboctave_error_handler) ("vector size mismatch");
231 return; 238 return;
232 } 239 }
234 for (int i = 0; i < length (); i++) 241 for (int i = 0; i < length (); i++)
235 elem (i) = FixedPointComplex((unsigned int)is(i), (unsigned int)ds(i), 242 elem (i) = FixedPointComplex((unsigned int)is(i), (unsigned int)ds(i),
236 a(i)); 243 a(i));
237 } 244 }
238 245
239 FixedComplexColumnVector::FixedComplexColumnVector ( 246 FixedComplexColumnVector::FixedComplexColumnVector
240 const ComplexColumnVector &is, const ComplexColumnVector &ds, 247 (const ComplexColumnVector &is, const ComplexColumnVector &ds,
241 const ComplexColumnVector& a) : MArray<FixedPointComplex> (is.length()) 248 const ComplexColumnVector& a)
249 : MArray<FixedPointComplex> (dim_vector (is.length(), 1))
242 { 250 {
243 if ((length() != ds.length()) || (length() != a.length())) { 251 if ((length() != ds.length()) || (length() != a.length())) {
244 (*current_liboctave_error_handler) ("vector size mismatch"); 252 (*current_liboctave_error_handler) ("vector size mismatch");
245 return; 253 return;
246 } 254 }
247 255
248 for (int i = 0; i < length (); i++) 256 for (int i = 0; i < length (); i++)
249 elem (i) = FixedPointComplex(is(i), ds(i), a(i)); 257 elem (i) = FixedPointComplex(is(i), ds(i), a(i));
250 } 258 }
251 259
252 FixedComplexColumnVector::FixedComplexColumnVector (unsigned int is, 260 FixedComplexColumnVector::FixedComplexColumnVector
253 unsigned int ds, const ColumnVector& a) : 261 (unsigned int is, unsigned int ds, const ColumnVector& a)
254 MArray<FixedPointComplex> (a.length()) 262 : MArray<FixedPointComplex> (dim_vector (a.length(), 1))
255 { 263 {
256 for (int i = 0; i < length (); i++) 264 for (int i = 0; i < length (); i++)
257 elem (i) = FixedPointComplex(is, ds, a(i)); 265 elem (i) = FixedPointComplex(is, ds, a(i));
258 } 266 }
259 267
260 FixedComplexColumnVector::FixedComplexColumnVector (Complex is, 268 FixedComplexColumnVector::FixedComplexColumnVector
261 Complex ds, const ColumnVector& a) : 269 (Complex is, Complex ds, const ColumnVector& a)
262 MArray<FixedPointComplex> (a.length()) 270 : MArray<FixedPointComplex> (dim_vector (a.length(), 1))
263 { 271 {
264 for (int i = 0; i < length (); i++) 272 for (int i = 0; i < length (); i++)
265 elem (i) = FixedPointComplex(is, ds, a(i)); 273 elem (i) = FixedPointComplex(is, ds, a(i));
266 } 274 }
267 275
268 FixedComplexColumnVector::FixedComplexColumnVector (const MArray<int> &is, 276 FixedComplexColumnVector::FixedComplexColumnVector
269 const MArray<int> &ds, const ColumnVector& a) : 277 (const MArray<int> &is, const MArray<int> &ds, const ColumnVector& a)
270 MArray<FixedPointComplex> (is.length()) 278 : MArray<FixedPointComplex> (dim_vector (is.length(), 1))
271 { 279 {
272 if ((length() != ds.length()) || (length() != a.length())) { 280 if ((length() != ds.length()) || (length() != a.length())) {
273 (*current_liboctave_error_handler) ("vector size mismatch"); 281 (*current_liboctave_error_handler) ("vector size mismatch");
274 return; 282 return;
275 } 283 }
277 for (int i = 0; i < length (); i++) 285 for (int i = 0; i < length (); i++)
278 elem (i) = FixedPointComplex((unsigned int)is(i), (unsigned int)ds(i), 286 elem (i) = FixedPointComplex((unsigned int)is(i), (unsigned int)ds(i),
279 a(i)); 287 a(i));
280 } 288 }
281 289
282 FixedComplexColumnVector::FixedComplexColumnVector (const ColumnVector &is, 290 FixedComplexColumnVector::FixedComplexColumnVector
283 const ColumnVector &ds, const ColumnVector& a) : 291 (const ColumnVector &is, const ColumnVector &ds, const ColumnVector& a)
284 MArray<FixedPointComplex> (is.length()) 292 : MArray<FixedPointComplex> (dim_vector (is.length(), 1))
285 { 293 {
286 if ((length() != ds.length()) || (length() != a.length())) { 294 if ((length() != ds.length()) || (length() != a.length())) {
287 (*current_liboctave_error_handler) ("vector size mismatch"); 295 (*current_liboctave_error_handler) ("vector size mismatch");
288 return; 296 return;
289 } 297 }
291 for (int i = 0; i < length (); i++) 299 for (int i = 0; i < length (); i++)
292 elem (i) = FixedPointComplex((unsigned int)is(i), (unsigned int)ds(i), 300 elem (i) = FixedPointComplex((unsigned int)is(i), (unsigned int)ds(i),
293 a(i)); 301 a(i));
294 } 302 }
295 303
296 FixedComplexColumnVector::FixedComplexColumnVector ( 304 FixedComplexColumnVector::FixedComplexColumnVector
297 const ComplexColumnVector &is, const ComplexColumnVector &ds, 305 (const ComplexColumnVector &is, const ComplexColumnVector &ds,
298 const ColumnVector& a) : MArray<FixedPointComplex> (is.length()) 306 const ColumnVector& a)
307 : MArray<FixedPointComplex> (dim_vector (is.length(), 1))
299 { 308 {
300 if ((length() != ds.length()) || (length() != a.length())) { 309 if ((length() != ds.length()) || (length() != a.length())) {
301 (*current_liboctave_error_handler) ("vector size mismatch"); 310 (*current_liboctave_error_handler) ("vector size mismatch");
302 return; 311 return;
303 } 312 }
304 313
305 for (int i = 0; i < length (); i++) 314 for (int i = 0; i < length (); i++)
306 elem (i) = FixedPointComplex(is(i), ds(i), a(i)); 315 elem (i) = FixedPointComplex(is(i), ds(i), a(i));
307 } 316 }
308 317
309 FixedComplexColumnVector::FixedComplexColumnVector (unsigned int is, 318 FixedComplexColumnVector::FixedComplexColumnVector
310 unsigned int ds, const ComplexColumnVector& a, 319 (unsigned int is, unsigned int ds, const ComplexColumnVector& a,
311 const ComplexColumnVector& b) : MArray<FixedPointComplex> (a.length()) 320 const ComplexColumnVector& b)
321 : MArray<FixedPointComplex> (dim_vector (a.length(), 1))
312 { 322 {
313 if (length() != b.length()) { 323 if (length() != b.length()) {
314 (*current_liboctave_error_handler) ("vector size mismatch"); 324 (*current_liboctave_error_handler) ("vector size mismatch");
315 return; 325 return;
316 } 326 }
317 327
318 for (int i = 0; i < length (); i++) 328 for (int i = 0; i < length (); i++)
319 elem (i) = FixedPointComplex(is, ds, a(i), b(i)); 329 elem (i) = FixedPointComplex(is, ds, a(i), b(i));
320 } 330 }
321 331
322 FixedComplexColumnVector::FixedComplexColumnVector (Complex is, 332 FixedComplexColumnVector::FixedComplexColumnVector
323 Complex ds, const ComplexColumnVector& a, 333 (Complex is, Complex ds, const ComplexColumnVector& a,
324 const ComplexColumnVector& b) : MArray<FixedPointComplex> (a.length()) 334 const ComplexColumnVector& b)
335 : MArray<FixedPointComplex> (dim_vector (a.length(), 1))
325 { 336 {
326 if (length() != b.length()) { 337 if (length() != b.length()) {
327 (*current_liboctave_error_handler) ("vector size mismatch"); 338 (*current_liboctave_error_handler) ("vector size mismatch");
328 return; 339 return;
329 } 340 }
330 341
331 for (int i = 0; i < length (); i++) 342 for (int i = 0; i < length (); i++)
332 elem (i) = FixedPointComplex(is, ds, a(i), b(i)); 343 elem (i) = FixedPointComplex(is, ds, a(i), b(i));
333 } 344 }
334 345
335 FixedComplexColumnVector::FixedComplexColumnVector (const MArray<int> &is, 346 FixedComplexColumnVector::FixedComplexColumnVector
336 const MArray<int> &ds, const ComplexColumnVector& a, 347 (const MArray<int> &is, const MArray<int> &ds,
337 const ComplexColumnVector& b) : MArray<FixedPointComplex> (is.length()) 348 const ComplexColumnVector& a, const ComplexColumnVector& b)
349 : MArray<FixedPointComplex> (dim_vector (is.length(), 1))
338 { 350 {
339 if ((length() != ds.length()) || (length() != a.length()) || 351 if ((length() != ds.length()) || (length() != a.length()) ||
340 (length() != b.length())) { 352 (length() != b.length())) {
341 (*current_liboctave_error_handler) ("vector size mismatch"); 353 (*current_liboctave_error_handler) ("vector size mismatch");
342 return; 354 return;
345 for (int i = 0; i < length (); i++) 357 for (int i = 0; i < length (); i++)
346 elem (i) = FixedPointComplex((unsigned int)is(i), (unsigned int)ds(i), 358 elem (i) = FixedPointComplex((unsigned int)is(i), (unsigned int)ds(i),
347 a(i), b(i)); 359 a(i), b(i));
348 } 360 }
349 361
350 FixedComplexColumnVector::FixedComplexColumnVector (const ColumnVector &is, 362 FixedComplexColumnVector::FixedComplexColumnVector
351 const ColumnVector &ds, const ComplexColumnVector& a, 363 (const ColumnVector &is, const ColumnVector &ds,
352 const ComplexColumnVector& b) : MArray<FixedPointComplex> (is.length()) 364 const ComplexColumnVector& a, const ComplexColumnVector& b)
365 : MArray<FixedPointComplex> (dim_vector (is.length(), 1))
353 { 366 {
354 if ((length() != ds.length()) || (length() != a.length()) || 367 if ((length() != ds.length()) || (length() != a.length()) ||
355 (length() != b.length())) { 368 (length() != b.length())) {
356 (*current_liboctave_error_handler) ("vector size mismatch"); 369 (*current_liboctave_error_handler) ("vector size mismatch");
357 return; 370 return;
360 for (int i = 0; i < length (); i++) 373 for (int i = 0; i < length (); i++)
361 elem (i) = FixedPointComplex((unsigned int)is(i), (unsigned int)ds(i), 374 elem (i) = FixedPointComplex((unsigned int)is(i), (unsigned int)ds(i),
362 a(i), b(i)); 375 a(i), b(i));
363 } 376 }
364 377
365 FixedComplexColumnVector::FixedComplexColumnVector ( 378 FixedComplexColumnVector::FixedComplexColumnVector
366 const ComplexColumnVector &is, const ComplexColumnVector &ds, 379 (const ComplexColumnVector &is, const ComplexColumnVector &ds,
367 const ComplexColumnVector& a, const ComplexColumnVector& b) : 380 const ComplexColumnVector& a, const ComplexColumnVector& b)
368 MArray<FixedPointComplex> (is.length()) 381 : MArray<FixedPointComplex> (dim_vector (is.length(), 1))
369 { 382 {
370 if ((length() != ds.length()) || (length() != a.length()) || 383 if ((length() != ds.length()) || (length() != a.length()) ||
371 (length() != b.length())) { 384 (length() != b.length())) {
372 (*current_liboctave_error_handler) ("vector size mismatch"); 385 (*current_liboctave_error_handler) ("vector size mismatch");
373 return; 386 return;
470 return chdecsize(n + getdecsize()); 483 return chdecsize(n + getdecsize());
471 } 484 }
472 485
473 FixedComplexColumnVector 486 FixedComplexColumnVector
474 FixedComplexColumnVector::incdecsize () { 487 FixedComplexColumnVector::incdecsize () {
475 return chdecsize(1 + getdecsize()); 488 return chdecsize(Complex (1) + getdecsize());
476 } 489 }
477 490
478 FixedComplexColumnVector 491 FixedComplexColumnVector
479 FixedComplexColumnVector::incintsize (const Complex n) { 492 FixedComplexColumnVector::incintsize (const Complex n) {
480 return chintsize(n + getintsize()); 493 return chintsize(n + getintsize());
489 return chintsize(n + getintsize()); 502 return chintsize(n + getintsize());
490 } 503 }
491 504
492 FixedComplexColumnVector 505 FixedComplexColumnVector
493 FixedComplexColumnVector::incintsize () { 506 FixedComplexColumnVector::incintsize () {
494 return chintsize(1 + getintsize()); 507 return chintsize(Complex (1) + getintsize());
495 } 508 }
496 509
497 // Fixed Point Complex Column Vector class. 510 // Fixed Point Complex Column Vector class.
498 511
499 bool 512 bool