Mercurial > forge

comparison main/fixed/src/fixedCNDArray.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 0924c374b60d
children
comparison
equal deleted inserted replaced
9480:954f2f00d782 9481:d84d2fea3c90
43 43
44 #include "fixed-inline.cc" 44 #include "fixed-inline.cc"
45 45
46 // Fixed Point Complex Matrix class. 46 // Fixed Point Complex Matrix class.
47 47
48 FixedComplexNDArray::FixedComplexNDArray (const MArrayN<int> &is, 48 FixedComplexNDArray::FixedComplexNDArray (const MArray<int> &is,
49 const MArrayN<int> &ds) 49 const MArray<int> &ds)
50 : MArrayN<FixedPointComplex> (is.dims()) 50 : MArray<FixedPointComplex> (is.dims())
51 { 51 {
52 if (dims () != ds.dims ()) { 52 if (dims () != ds.dims ()) {
53 (*current_liboctave_error_handler) ("NDArray size mismatch"); 53 (*current_liboctave_error_handler) ("NDArray size mismatch");
54 return; 54 return;
55 } 55 }
58 elem (i) = FixedPointComplex((unsigned int)is(i), (unsigned int)ds(i)); 58 elem (i) = FixedPointComplex((unsigned int)is(i), (unsigned int)ds(i));
59 } 59 }
60 60
61 FixedComplexNDArray::FixedComplexNDArray (const NDArray &is, 61 FixedComplexNDArray::FixedComplexNDArray (const NDArray &is,
62 const NDArray &ds) 62 const NDArray &ds)
63 : MArrayN<FixedPointComplex> (is.dims()) 63 : MArray<FixedPointComplex> (is.dims())
64 { 64 {
65 if (dims () != ds.dims ()) { 65 if (dims () != ds.dims ()) {
66 (*current_liboctave_error_handler) ("NDArray size mismatch"); 66 (*current_liboctave_error_handler) ("NDArray size mismatch");
67 return; 67 return;
68 } 68 }
71 elem (i) = FixedPointComplex((unsigned int)is(i), (unsigned int)ds(i)); 71 elem (i) = FixedPointComplex((unsigned int)is(i), (unsigned int)ds(i));
72 } 72 }
73 73
74 FixedComplexNDArray::FixedComplexNDArray (const ComplexNDArray &is, 74 FixedComplexNDArray::FixedComplexNDArray (const ComplexNDArray &is,
75 const ComplexNDArray &ds) 75 const ComplexNDArray &ds)
76 : MArrayN<FixedPointComplex> (is.dims()) 76 : MArray<FixedPointComplex> (is.dims())
77 { 77 {
78 if (dims () != ds.dims ()) { 78 if (dims () != ds.dims ()) {
79 (*current_liboctave_error_handler) ("NDArray size mismatch"); 79 (*current_liboctave_error_handler) ("NDArray size mismatch");
80 return; 80 return;
81 } 81 }
85 } 85 }
86 86
87 FixedComplexNDArray::FixedComplexNDArray (unsigned int is, 87 FixedComplexNDArray::FixedComplexNDArray (unsigned int is,
88 unsigned int ds, 88 unsigned int ds,
89 const FixedComplexNDArray& a) 89 const FixedComplexNDArray& a)
90 : MArrayN<FixedPointComplex> (a.dims()) 90 : MArray<FixedPointComplex> (a.dims())
91 { 91 {
92 for (int i = 0; i < nelem (); i++) 92 for (int i = 0; i < nelem (); i++)
93 elem (i) = FixedPointComplex(is, ds, a.elem (i)); 93 elem (i) = FixedPointComplex(is, ds, a.elem (i));
94 } 94 }
95 95
96 FixedComplexNDArray::FixedComplexNDArray (Complex is, Complex ds, 96 FixedComplexNDArray::FixedComplexNDArray (Complex is, Complex ds,
97 const FixedComplexNDArray& a) 97 const FixedComplexNDArray& a)
98 : MArrayN<FixedPointComplex> (a.dims()) 98 : MArray<FixedPointComplex> (a.dims())
99 { 99 {
100 for (int i = 0; i < nelem (); i++) 100 for (int i = 0; i < nelem (); i++)
101 elem (i) = FixedPointComplex(is, ds, a.elem (i)); 101 elem (i) = FixedPointComplex(is, ds, a.elem (i));
102 } 102 }
103 103
104 FixedComplexNDArray::FixedComplexNDArray (const MArrayN<int> &is, 104 FixedComplexNDArray::FixedComplexNDArray (const MArray<int> &is,
105 const MArrayN<int> &ds, 105 const MArray<int> &ds,
106 const FixedComplexNDArray& a) 106 const FixedComplexNDArray& a)
107 : MArrayN<FixedPointComplex> (a.dims()) 107 : MArray<FixedPointComplex> (a.dims())
108 { 108 {
109 if ((dims() != is.dims()) || (dims() != ds.dims())) { 109 if ((dims() != is.dims()) || (dims() != ds.dims())) {
110 (*current_liboctave_error_handler) ("NDArray size mismatch"); 110 (*current_liboctave_error_handler) ("NDArray size mismatch");
111 return; 111 return;
112 } 112 }
117 } 117 }
118 118
119 FixedComplexNDArray::FixedComplexNDArray (const NDArray &is, 119 FixedComplexNDArray::FixedComplexNDArray (const NDArray &is,
120 const NDArray &ds, 120 const NDArray &ds,
121 const FixedComplexNDArray& a) 121 const FixedComplexNDArray& a)
122 : MArrayN<FixedPointComplex> (a.dims()) 122 : MArray<FixedPointComplex> (a.dims())
123 { 123 {
124 if ((dims() != is.dims()) || (dims() != ds.dims())) { 124 if ((dims() != is.dims()) || (dims() != ds.dims())) {
125 (*current_liboctave_error_handler) ("NDArray size mismatch"); 125 (*current_liboctave_error_handler) ("NDArray size mismatch");
126 return; 126 return;
127 } 127 }
132 } 132 }
133 133
134 FixedComplexNDArray::FixedComplexNDArray (const ComplexNDArray &is, 134 FixedComplexNDArray::FixedComplexNDArray (const ComplexNDArray &is,
135 const ComplexNDArray &ds, 135 const ComplexNDArray &ds,
136 const FixedComplexNDArray& a) 136 const FixedComplexNDArray& a)
137 : MArrayN<FixedPointComplex> (a.dims()) 137 : MArray<FixedPointComplex> (a.dims())
138 { 138 {
139 if ((dims() != is.dims()) || (dims() != ds.dims())) { 139 if ((dims() != is.dims()) || (dims() != ds.dims())) {
140 (*current_liboctave_error_handler) ("NDArray size mismatch"); 140 (*current_liboctave_error_handler) ("NDArray size mismatch");
141 return; 141 return;
142 } 142 }
146 } 146 }
147 147
148 FixedComplexNDArray::FixedComplexNDArray (unsigned int is, 148 FixedComplexNDArray::FixedComplexNDArray (unsigned int is,
149 unsigned int ds, 149 unsigned int ds,
150 const FixedNDArray& a) 150 const FixedNDArray& a)
151 : MArrayN<FixedPointComplex> (a.dims()) 151 : MArray<FixedPointComplex> (a.dims())
152 { 152 {
153 for (int i = 0; i < nelem (); i++) 153 for (int i = 0; i < nelem (); i++)
154 elem (i) = FixedPointComplex(is, ds, a.elem (i)); 154 elem (i) = FixedPointComplex(is, ds, a.elem (i));
155 } 155 }
156 156
157 FixedComplexNDArray::FixedComplexNDArray (Complex is, Complex ds, 157 FixedComplexNDArray::FixedComplexNDArray (Complex is, Complex ds,
158 const FixedNDArray& a) 158 const FixedNDArray& a)
159 : MArrayN<FixedPointComplex> (a.dims()) 159 : MArray<FixedPointComplex> (a.dims())
160 { 160 {
161 for (int i = 0; i < nelem (); i++) 161 for (int i = 0; i < nelem (); i++)
162 elem (i) = FixedPointComplex(is, ds, FixedPointComplex(a.elem (i))); 162 elem (i) = FixedPointComplex(is, ds, FixedPointComplex(a.elem (i)));
163 } 163 }
164 164
165 FixedComplexNDArray::FixedComplexNDArray (const MArrayN<int> &is, 165 FixedComplexNDArray::FixedComplexNDArray (const MArray<int> &is,
166 const MArrayN<int> &ds, 166 const MArray<int> &ds,
167 const FixedNDArray& a) 167 const FixedNDArray& a)
168 : MArrayN<FixedPointComplex> (a.dims()) 168 : MArray<FixedPointComplex> (a.dims())
169 { 169 {
170 if ((dims() != is.dims()) || (dims() != ds.dims())) { 170 if ((dims() != is.dims()) || (dims() != ds.dims())) {
171 (*current_liboctave_error_handler) ("NDArray size mismatch"); 171 (*current_liboctave_error_handler) ("NDArray size mismatch");
172 return; 172 return;
173 } 173 }
178 } 178 }
179 179
180 FixedComplexNDArray::FixedComplexNDArray (const NDArray &is, 180 FixedComplexNDArray::FixedComplexNDArray (const NDArray &is,
181 const NDArray &ds, 181 const NDArray &ds,
182 const FixedNDArray& a) 182 const FixedNDArray& a)
183 : MArrayN<FixedPointComplex> (a.dims()) 183 : MArray<FixedPointComplex> (a.dims())
184 { 184 {
185 if ((dims() != is.dims()) || (dims() != ds.dims())) { 185 if ((dims() != is.dims()) || (dims() != ds.dims())) {
186 (*current_liboctave_error_handler) ("NDArray size mismatch"); 186 (*current_liboctave_error_handler) ("NDArray size mismatch");
187 return; 187 return;
188 } 188 }
193 } 193 }
194 194
195 FixedComplexNDArray::FixedComplexNDArray (const ComplexNDArray &is, 195 FixedComplexNDArray::FixedComplexNDArray (const ComplexNDArray &is,
196 const ComplexNDArray &ds, 196 const ComplexNDArray &ds,
197 const FixedNDArray& a) 197 const FixedNDArray& a)
198 : MArrayN<FixedPointComplex> (a.dims()) 198 : MArray<FixedPointComplex> (a.dims())
199 { 199 {
200 if ((dims() != is.dims()) || (dims() != ds.dims())) { 200 if ((dims() != is.dims()) || (dims() != ds.dims())) {
201 (*current_liboctave_error_handler) ("NDArray size mismatch"); 201 (*current_liboctave_error_handler) ("NDArray size mismatch");
202 return; 202 return;
203 } 203 }
207 } 207 }
208 208
209 FixedComplexNDArray::FixedComplexNDArray (unsigned int is, 209 FixedComplexNDArray::FixedComplexNDArray (unsigned int is,
210 unsigned int ds, 210 unsigned int ds,
211 const ComplexNDArray& a) 211 const ComplexNDArray& a)
212 : MArrayN<FixedPointComplex> (a.dims()) 212 : MArray<FixedPointComplex> (a.dims())
213 { 213 {
214 for (int i = 0; i < nelem (); i++) 214 for (int i = 0; i < nelem (); i++)
215 elem (i) = FixedPointComplex(is, ds, a.elem (i)); 215 elem (i) = FixedPointComplex(is, ds, a.elem (i));
216 } 216 }
217 217
218 FixedComplexNDArray::FixedComplexNDArray (Complex is, Complex ds, 218 FixedComplexNDArray::FixedComplexNDArray (Complex is, Complex ds,
219 const ComplexNDArray& a) 219 const ComplexNDArray& a)
220 : MArrayN<FixedPointComplex> (a.dims()) 220 : MArray<FixedPointComplex> (a.dims())
221 { 221 {
222 for (int i = 0; i < nelem (); i++) 222 for (int i = 0; i < nelem (); i++)
223 elem (i) = FixedPointComplex(is, ds, a.elem (i)); 223 elem (i) = FixedPointComplex(is, ds, a.elem (i));
224 } 224 }
225 225
226 FixedComplexNDArray::FixedComplexNDArray (const MArrayN<int> &is, 226 FixedComplexNDArray::FixedComplexNDArray (const MArray<int> &is,
227 const MArrayN<int> &ds, 227 const MArray<int> &ds,
228 const ComplexNDArray& a) 228 const ComplexNDArray& a)
229 : MArrayN<FixedPointComplex> (a.dims()) 229 : MArray<FixedPointComplex> (a.dims())
230 { 230 {
231 if ((dims() != is.dims()) || (dims() != ds.dims())) { 231 if ((dims() != is.dims()) || (dims() != ds.dims())) {
232 (*current_liboctave_error_handler) ("NDArray size mismatch"); 232 (*current_liboctave_error_handler) ("NDArray size mismatch");
233 return; 233 return;
234 } 234 }
239 } 239 }
240 240
241 FixedComplexNDArray::FixedComplexNDArray (const NDArray &is, 241 FixedComplexNDArray::FixedComplexNDArray (const NDArray &is,
242 const NDArray &ds, 242 const NDArray &ds,
243 const ComplexNDArray& a) 243 const ComplexNDArray& a)
244 : MArrayN<FixedPointComplex> (a.dims()) 244 : MArray<FixedPointComplex> (a.dims())
245 { 245 {
246 if ((dims() != is.dims()) || (dims() != ds.dims())) { 246 if ((dims() != is.dims()) || (dims() != ds.dims())) {
247 (*current_liboctave_error_handler) ("NDArray size mismatch"); 247 (*current_liboctave_error_handler) ("NDArray size mismatch");
248 return; 248 return;
249 } 249 }
254 } 254 }
255 255
256 FixedComplexNDArray::FixedComplexNDArray (const ComplexNDArray &is, 256 FixedComplexNDArray::FixedComplexNDArray (const ComplexNDArray &is,
257 const ComplexNDArray &ds, 257 const ComplexNDArray &ds,
258 const ComplexNDArray& a) 258 const ComplexNDArray& a)
259 : MArrayN<FixedPointComplex> (a.dims()) 259 : MArray<FixedPointComplex> (a.dims())
260 { 260 {
261 if ((dims() != is.dims()) || (dims() != ds.dims())) { 261 if ((dims() != is.dims()) || (dims() != ds.dims())) {
262 (*current_liboctave_error_handler) ("NDArray size mismatch"); 262 (*current_liboctave_error_handler) ("NDArray size mismatch");
263 return; 263 return;
264 } 264 }
268 } 268 }
269 269
270 FixedComplexNDArray::FixedComplexNDArray (unsigned int is, 270 FixedComplexNDArray::FixedComplexNDArray (unsigned int is,
271 unsigned int ds, 271 unsigned int ds,
272 const NDArray& a) 272 const NDArray& a)
273 : MArrayN<FixedPointComplex> (a.dims()) 273 : MArray<FixedPointComplex> (a.dims())
274 { 274 {
275 for (int i = 0; i < nelem (); i++) 275 for (int i = 0; i < nelem (); i++)
276 elem (i) = FixedPointComplex(is, ds, a.elem (i)); 276 elem (i) = FixedPointComplex(is, ds, a.elem (i));
277 } 277 }
278 278
279 FixedComplexNDArray::FixedComplexNDArray (Complex is, Complex ds, 279 FixedComplexNDArray::FixedComplexNDArray (Complex is, Complex ds,
280 const NDArray& a) 280 const NDArray& a)
281 : MArrayN<FixedPointComplex> (a.dims()) 281 : MArray<FixedPointComplex> (a.dims())
282 { 282 {
283 for (int i = 0; i < nelem (); i++) 283 for (int i = 0; i < nelem (); i++)
284 elem (i) = FixedPointComplex(is, ds, a.elem (i)); 284 elem (i) = FixedPointComplex(is, ds, a.elem (i));
285 } 285 }
286 286
287 FixedComplexNDArray::FixedComplexNDArray (const MArrayN<int> &is, 287 FixedComplexNDArray::FixedComplexNDArray (const MArray<int> &is,
288 const MArrayN<int> &ds, 288 const MArray<int> &ds,
289 const NDArray& a) 289 const NDArray& a)
290 : MArrayN<FixedPointComplex> (a.dims()) 290 : MArray<FixedPointComplex> (a.dims())
291 { 291 {
292 if ((dims() != is.dims()) || (dims() != ds.dims())) { 292 if ((dims() != is.dims()) || (dims() != ds.dims())) {
293 (*current_liboctave_error_handler) ("NDArray size mismatch"); 293 (*current_liboctave_error_handler) ("NDArray size mismatch");
294 return; 294 return;
295 } 295 }
300 } 300 }
301 301
302 FixedComplexNDArray::FixedComplexNDArray (const NDArray &is, 302 FixedComplexNDArray::FixedComplexNDArray (const NDArray &is,
303 const NDArray &ds, 303 const NDArray &ds,
304 const NDArray& a) 304 const NDArray& a)
305 : MArrayN<FixedPointComplex> (a.dims()) 305 : MArray<FixedPointComplex> (a.dims())
306 { 306 {
307 if ((dims() != is.dims()) || (dims() != ds.dims())) { 307 if ((dims() != is.dims()) || (dims() != ds.dims())) {
308 (*current_liboctave_error_handler) ("NDArray size mismatch"); 308 (*current_liboctave_error_handler) ("NDArray size mismatch");
309 return; 309 return;
310 } 310 }
315 } 315 }
316 316
317 FixedComplexNDArray::FixedComplexNDArray (const ComplexNDArray &is, 317 FixedComplexNDArray::FixedComplexNDArray (const ComplexNDArray &is,
318 const ComplexNDArray &ds, 318 const ComplexNDArray &ds,
319 const NDArray& a) 319 const NDArray& a)
320 : MArrayN<FixedPointComplex> (a.dims()) 320 : MArray<FixedPointComplex> (a.dims())
321 { 321 {
322 if ((dims() != is.dims()) || (dims() != ds.dims())) { 322 if ((dims() != is.dims()) || (dims() != ds.dims())) {
323 (*current_liboctave_error_handler) ("NDArray size mismatch"); 323 (*current_liboctave_error_handler) ("NDArray size mismatch");
324 return; 324 return;
325 } 325 }
330 330
331 FixedComplexNDArray::FixedComplexNDArray (unsigned int is, 331 FixedComplexNDArray::FixedComplexNDArray (unsigned int is,
332 unsigned int ds, 332 unsigned int ds,
333 const ComplexNDArray& a, 333 const ComplexNDArray& a,
334 const ComplexNDArray& b) 334 const ComplexNDArray& b)
335 : MArrayN<FixedPointComplex> (a.dims()) 335 : MArray<FixedPointComplex> (a.dims())
336 { 336 {
337 if (dims() != b.dims()) { 337 if (dims() != b.dims()) {
338 (*current_liboctave_error_handler) ("NDArray size mismatch"); 338 (*current_liboctave_error_handler) ("NDArray size mismatch");
339 return; 339 return;
340 } 340 }
344 } 344 }
345 345
346 FixedComplexNDArray::FixedComplexNDArray (Complex is, Complex ds, 346 FixedComplexNDArray::FixedComplexNDArray (Complex is, Complex ds,
347 const ComplexNDArray& a, 347 const ComplexNDArray& a,
348 const ComplexNDArray& b) 348 const ComplexNDArray& b)
349 : MArrayN<FixedPointComplex> (a.dims()) 349 : MArray<FixedPointComplex> (a.dims())
350 { 350 {
351 if (dims() != b.dims()) { 351 if (dims() != b.dims()) {
352 (*current_liboctave_error_handler) ("NDArray size mismatch"); 352 (*current_liboctave_error_handler) ("NDArray size mismatch");
353 return; 353 return;
354 } 354 }
355 355
356 for (int i = 0; i < nelem (); i++) 356 for (int i = 0; i < nelem (); i++)
357 elem (i) = FixedPointComplex(is, ds, a.elem (i), b.elem (i)); 357 elem (i) = FixedPointComplex(is, ds, a.elem (i), b.elem (i));
358 } 358 }
359 359
360 FixedComplexNDArray::FixedComplexNDArray (const MArrayN<int> &is, 360 FixedComplexNDArray::FixedComplexNDArray (const MArray<int> &is,
361 const MArrayN<int> &ds, 361 const MArray<int> &ds,
362 const ComplexNDArray& a, 362 const ComplexNDArray& a,
363 const ComplexNDArray& b) 363 const ComplexNDArray& b)
364 : MArrayN<FixedPointComplex> (a.dims()) 364 : MArray<FixedPointComplex> (a.dims())
365 { 365 {
366 if ((dims() != b.dims()) || (dims() != is.dims()) 366 if ((dims() != b.dims()) || (dims() != is.dims())
367 || (dims() != ds.dims())) { 367 || (dims() != ds.dims())) {
368 (*current_liboctave_error_handler) ("NDArray size mismatch"); 368 (*current_liboctave_error_handler) ("NDArray size mismatch");
369 return; 369 return;
375 375
376 FixedComplexNDArray::FixedComplexNDArray (const NDArray &is, 376 FixedComplexNDArray::FixedComplexNDArray (const NDArray &is,
377 const NDArray &ds, 377 const NDArray &ds,
378 const ComplexNDArray& a, 378 const ComplexNDArray& a,
379 const ComplexNDArray& b) 379 const ComplexNDArray& b)
380 : MArrayN<FixedPointComplex> (a.dims()) 380 : MArray<FixedPointComplex> (a.dims())
381 { 381 {
382 if ((dims() != b.dims()) || (dims() != is.dims()) 382 if ((dims() != b.dims()) || (dims() != is.dims())
383 || (dims() != ds.dims())) { 383 || (dims() != ds.dims())) {
384 (*current_liboctave_error_handler) ("NDArray size mismatch"); 384 (*current_liboctave_error_handler) ("NDArray size mismatch");
385 return; 385 return;
392 } 392 }
393 393
394 FixedComplexNDArray::FixedComplexNDArray (const ComplexNDArray &is, 394 FixedComplexNDArray::FixedComplexNDArray (const ComplexNDArray &is,
395 const ComplexNDArray &ds, const ComplexNDArray& a, 395 const ComplexNDArray &ds, const ComplexNDArray& a,
396 const ComplexNDArray& b) 396 const ComplexNDArray& b)
397 : MArrayN<FixedPointComplex> (a.dims()) 397 : MArray<FixedPointComplex> (a.dims())
398 { 398 {
399 if ((dims() != b.dims()) || (dims() != is.dims()) 399 if ((dims() != b.dims()) || (dims() != is.dims())
400 || (dims() != ds.dims())) { 400 || (dims() != ds.dims())) {
401 (*current_liboctave_error_handler) ("NDArray size mismatch"); 401 (*current_liboctave_error_handler) ("NDArray size mismatch");
402 return; 402 return;
405 for (int i = 0; i < nelem (); i++) 405 for (int i = 0; i < nelem (); i++)
406 elem (i) = FixedPointComplex(is (i), ds (i), a.elem (i), b.elem (i)); 406 elem (i) = FixedPointComplex(is (i), ds (i), a.elem (i), b.elem (i));
407 } 407 }
408 408
409 FixedComplexNDArray::FixedComplexNDArray (const FixedNDArray& m) 409 FixedComplexNDArray::FixedComplexNDArray (const FixedNDArray& m)
410 : MArrayN<FixedPointComplex> (m.dims (), FixedPointComplex()) 410 : MArray<FixedPointComplex> (m.dims (), FixedPointComplex())
411 { 411 {
412 for (int i = 0; i < nelem (); i++) 412 for (int i = 0; i < nelem (); i++)
413 elem (i) = FixedPointComplex(m.elem (i)); 413 elem (i) = FixedPointComplex(m.elem (i));
414 } 414 }
415 415
416 FixedComplexNDArray::FixedComplexNDArray (const FixedNDArray& a, 416 FixedComplexNDArray::FixedComplexNDArray (const FixedNDArray& a,
417 const FixedNDArray& b) 417 const FixedNDArray& b)
418 : MArrayN<FixedPointComplex> (a.dims (), FixedPointComplex()) 418 : MArray<FixedPointComplex> (a.dims (), FixedPointComplex())
419 { 419 {
420 if (dims() != b.dims()) { 420 if (dims() != b.dims()) {
421 (*current_liboctave_error_handler) ("NDArray size mismatch"); 421 (*current_liboctave_error_handler) ("NDArray size mismatch");
422 return; 422 return;
423 } 423 }
574 } 574 }
575 575
576 boolNDArray 576 boolNDArray
577 FixedComplexNDArray::all (octave_idx_type dim) const 577 FixedComplexNDArray::all (octave_idx_type dim) const
578 { 578 {
579 return do_mx_red_op<boolNDArray> (*this, dim, mx_inline_all); 579 return do_mx_red_op<bool, FixedPointComplex> (*this, dim, mx_inline_all);
580 } 580 }
581 581
582 boolNDArray 582 boolNDArray
583 FixedComplexNDArray::any (octave_idx_type dim) const 583 FixedComplexNDArray::any (octave_idx_type dim) const
584 { 584 {
585 return do_mx_red_op<boolNDArray> (*this, dim, mx_inline_any); 585 return do_mx_red_op<bool, FixedPointComplex> (*this, dim, mx_inline_any);
586 } 586 }
587 587
588 FixedComplexNDArray 588 FixedComplexNDArray
589 FixedComplexNDArray::cumprod (octave_idx_type dim) const 589 FixedComplexNDArray::cumprod (octave_idx_type dim) const
590 { 590 {
591 return do_mx_cum_op<FixedComplexNDArray> (*this, dim, mx_inline_cumprod); 591 return do_mx_cum_op<FixedPointComplex, FixedPointComplex> (*this, dim, mx_inline_cumprod);
592 } 592 }
593 593
594 FixedComplexNDArray 594 FixedComplexNDArray
595 FixedComplexNDArray::cumsum (octave_idx_type dim) const 595 FixedComplexNDArray::cumsum (octave_idx_type dim) const
596 { 596 {
597 return do_mx_cum_op<FixedComplexNDArray> (*this, dim, mx_inline_cumsum); 597 return do_mx_cum_op<FixedPointComplex, FixedPointComplex> (*this, dim, mx_inline_cumsum);
598 } 598 }
599 599
600 FixedComplexNDArray 600 FixedComplexNDArray
601 FixedComplexNDArray::prod (octave_idx_type dim) const 601 FixedComplexNDArray::prod (octave_idx_type dim) const
602 { 602 {
603 return do_mx_red_op<FixedComplexNDArray> (*this, dim, mx_inline_prod); 603 return do_mx_red_op<FixedPointComplex, FixedPointComplex> (*this, dim, mx_inline_prod);
604 } 604 }
605 605
606 FixedComplexNDArray 606 FixedComplexNDArray
607 FixedComplexNDArray::sum (octave_idx_type dim) const 607 FixedComplexNDArray::sum (octave_idx_type dim) const
608 { 608 {
609 return do_mx_red_op<FixedComplexNDArray> (*this, dim, mx_inline_sum); 609 return do_mx_red_op<FixedPointComplex, FixedPointComplex> (*this, dim, mx_inline_sum);
610 } 610 }
611 611
612 FixedComplexNDArray 612 FixedComplexNDArray
613 FixedComplexNDArray::sumsq (octave_idx_type dim) const 613 FixedComplexNDArray::sumsq (octave_idx_type dim) const
614 { 614 {
615 return do_mx_red_op<FixedComplexNDArray> (*this, dim, mx_inline_sumsq); 615 return do_mx_red_op<FixedPointComplex, FixedPointComplex> (*this, dim, mx_inline_sumsq);
616 } 616 }
617 617
618 FixedNDArray 618 FixedNDArray
619 FixedComplexNDArray::abs (void) const 619 FixedComplexNDArray::abs (void) const
620 { 620 {
706 return retval; 706 return retval;
707 } 707 }
708 708
709 FixedComplexNDArray elem_pow (const FixedComplexNDArray &a, const FixedPointComplex &b) 709 FixedComplexNDArray elem_pow (const FixedComplexNDArray &a, const FixedPointComplex &b)
710 { 710 {
711 return elem_pow (a, FixedComplexNDArray(dim_vector(1), b)); 711 return elem_pow (a, FixedComplexNDArray(dim_vector (1, 1), b));
712 } 712 }
713 713
714 FixedComplexNDArray elem_pow (const FixedPointComplex &a, const FixedComplexNDArray &b) 714 FixedComplexNDArray elem_pow (const FixedPointComplex &a, const FixedComplexNDArray &b)
715 { 715 {
716 return elem_pow (FixedComplexNDArray(dim_vector(1), a), b); 716 return elem_pow (FixedComplexNDArray(dim_vector (1, 1), a), b);
717 } 717 }
718 718
719 FixedComplexNDArray 719 FixedComplexNDArray
720 FixedComplexNDArray::max (octave_idx_type dim) const 720 FixedComplexNDArray::max (octave_idx_type dim) const
721 { 721 {
722 ArrayN<octave_idx_type> dummy_idx; 722 Array<octave_idx_type> dummy_idx;
723 return max (dummy_idx, dim); 723 return max (dummy_idx, dim);
724 } 724 }
725 725
726 FixedComplexNDArray 726 FixedComplexNDArray
727 FixedComplexNDArray::max (ArrayN<octave_idx_type>& idx_arg, octave_idx_type dim) const 727 FixedComplexNDArray::max (Array<octave_idx_type>& idx_arg, octave_idx_type dim) const
728 { 728 {
729 dim_vector dv = dims (); 729 dim_vector dv = dims ();
730 dim_vector dr = dims (); 730 dim_vector dr = dims ();
731 731
732 if (dv.numel () == 0 || dim > dv.length () || dim < 0) 732 if (dv.numel () == 0 || dim > dv.length () || dim < 0)
784 } 784 }
785 785
786 FixedComplexNDArray 786 FixedComplexNDArray
787 FixedComplexNDArray::min (octave_idx_type dim) const 787 FixedComplexNDArray::min (octave_idx_type dim) const
788 { 788 {
789 ArrayN<octave_idx_type> dummy_idx; 789 Array<octave_idx_type> dummy_idx;
790 return min (dummy_idx, dim); 790 return min (dummy_idx, dim);
791 } 791 }
792 792
793 FixedComplexNDArray 793 FixedComplexNDArray
794 FixedComplexNDArray::min (ArrayN<octave_idx_type>& idx_arg, octave_idx_type dim) const 794 FixedComplexNDArray::min (Array<octave_idx_type>& idx_arg, octave_idx_type dim) const
795 { 795 {
796 dim_vector dv = dims (); 796 dim_vector dv = dims ();
797 dim_vector dr = dims (); 797 dim_vector dr = dims ();
798 798
799 if (dv.numel () == 0 || dim > dv.length () || dim < 0) 799 if (dv.numel () == 0 || dim > dv.length () || dim < 0)
858 octave_idx_type nd = ndims (); 858 octave_idx_type nd = ndims ();
859 859
860 switch (nd) 860 switch (nd)
861 { 861 {
862 case 1: 862 case 1:
863 retval = FixedComplexMatrix (Array2<FixedPointComplex> 863 retval = FixedComplexMatrix (Array<FixedPointComplex>
864 (*this, dimensions(0), 1)); 864 (*this, dim_vector (dimensions(0), 1)));
865 break; 865 break;
866 866
867 case 2: 867 case 2:
868 retval = FixedComplexMatrix (Array2<FixedPointComplex> 868 retval = FixedComplexMatrix (Array<FixedPointComplex>
869 (*this, dimensions(0), dimensions(1))); 869 (*this, dim_vector (dimensions(0), dimensions(1))));
870 break; 870 break;
871 871
872 default: 872 default:
873 (*current_liboctave_error_handler) 873 (*current_liboctave_error_handler)
874 ("invalid conversion of FixedComplexNDArray to FixedComplexMatrix"); 874 ("invalid conversion of FixedComplexNDArray to FixedComplexMatrix");
1092 } 1092 }
1093 1093
1094 return result; 1094 return result;
1095 } 1095 }
1096 1096
1097 NDS_CMP_OPS(FixedComplexNDArray, real, FixedPointComplex, real) 1097 NDS_CMP_OPS(FixedComplexNDArray, FixedPointComplex)
1098 NDS_BOOL_OPS(FixedComplexNDArray, FixedPointComplex, FixedPointComplex()) 1098 NDS_BOOL_OPS(FixedComplexNDArray, FixedPointComplex)
1099 1099
1100 SND_CMP_OPS(FixedPointComplex, real, FixedComplexNDArray, real) 1100 SND_CMP_OPS(FixedPointComplex, FixedComplexNDArray)
1101 SND_BOOL_OPS(FixedPointComplex, FixedComplexNDArray, FixedPointComplex()) 1101 SND_BOOL_OPS(FixedPointComplex, FixedComplexNDArray)
1102 1102
1103 NDND_CMP_OPS(FixedComplexNDArray, real, FixedComplexNDArray, real) 1103 NDND_CMP_OPS(FixedComplexNDArray, FixedComplexNDArray)
1104 NDND_BOOL_OPS(FixedComplexNDArray, FixedComplexNDArray, FixedPointComplex()) 1104 NDND_BOOL_OPS(FixedComplexNDArray, FixedComplexNDArray)
1105 1105
1106 /* 1106 /*
1107 ;;; Local Variables: *** 1107 ;;; Local Variables: ***
1108 ;;; mode: C++ *** 1108 ;;; mode: C++ ***
1109 ;;; End: *** 1109 ;;; End: ***