Mercurial > forge

comparison main/fixed/src/fixedNDArray.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 NDArray class. 46 // Fixed Point NDArray class.
47 47
48 FixedNDArray::FixedNDArray (const MArrayN<int> &is, const MArrayN<int> &ds) 48 FixedNDArray::FixedNDArray (const MArray<int> &is, const MArray<int> &ds)
49 : MArrayN<FixedPoint> (is.dims()) 49 : MArray<FixedPoint> (is.dims())
50 { 50 {
51 if (dims () != ds.dims ()) { 51 if (dims () != ds.dims ()) {
52 (*current_liboctave_error_handler) ("NDArray size mismatch"); 52 (*current_liboctave_error_handler) ("NDArray size mismatch");
53 return; 53 return;
54 } 54 }
57 elem (i) = FixedPoint((unsigned int)is(i), (unsigned int)ds(i)); 57 elem (i) = FixedPoint((unsigned int)is(i), (unsigned int)ds(i));
58 } 58 }
59 59
60 60
61 FixedNDArray::FixedNDArray (const NDArray &is, const NDArray &ds) 61 FixedNDArray::FixedNDArray (const NDArray &is, const NDArray &ds)
62 : MArrayN<FixedPoint> (is.dims()) 62 : MArray<FixedPoint> (is.dims())
63 { 63 {
64 if (dims () != ds.dims ()) { 64 if (dims () != ds.dims ()) {
65 (*current_liboctave_error_handler) ("NDArray size mismatch"); 65 (*current_liboctave_error_handler) ("NDArray size mismatch");
66 return; 66 return;
67 } 67 }
68 68
69 for (int i = 0; i < nelem (); i++) 69 for (int i = 0; i < nelem (); i++)
70 elem (i) = FixedPoint((unsigned int)is(i), (unsigned int)ds(i)); 70 elem (i) = FixedPoint((unsigned int)is(i), (unsigned int)ds(i));
71 } 71 }
72 72
73 FixedNDArray::FixedNDArray (const MArrayN<int> &is, const MArrayN<int> &ds, 73 FixedNDArray::FixedNDArray (const MArray<int> &is, const MArray<int> &ds,
74 const FixedNDArray& a) 74 const FixedNDArray& a)
75 : MArrayN<FixedPoint> (a.dims()) 75 : MArray<FixedPoint> (a.dims())
76 { 76 {
77 if ((dims () != is.dims ()) || (dims () != ds.dims ())) { 77 if ((dims () != is.dims ()) || (dims () != ds.dims ())) {
78 (*current_liboctave_error_handler) ("NDArray size mismatch"); 78 (*current_liboctave_error_handler) ("NDArray size mismatch");
79 return; 79 return;
80 } 80 }
84 a.elem (i)); 84 a.elem (i));
85 } 85 }
86 86
87 FixedNDArray::FixedNDArray (const NDArray &is, const NDArray &ds, 87 FixedNDArray::FixedNDArray (const NDArray &is, const NDArray &ds,
88 const FixedNDArray& a) 88 const FixedNDArray& a)
89 : MArrayN<FixedPoint> (a.dims()) 89 : MArray<FixedPoint> (a.dims())
90 { 90 {
91 if ((dims () != is.dims ()) || (dims () != ds.dims ())) { 91 if ((dims () != is.dims ()) || (dims () != ds.dims ())) {
92 (*current_liboctave_error_handler) ("NDArray size mismatch"); 92 (*current_liboctave_error_handler) ("NDArray size mismatch");
93 return; 93 return;
94 } 94 }
98 a.elem (i)); 98 a.elem (i));
99 } 99 }
100 100
101 FixedNDArray::FixedNDArray (unsigned int is, unsigned int ds, 101 FixedNDArray::FixedNDArray (unsigned int is, unsigned int ds,
102 const FixedNDArray& a) 102 const FixedNDArray& a)
103 : MArrayN<FixedPoint> (a.dims()) 103 : MArray<FixedPoint> (a.dims())
104 { 104 {
105 for (int i = 0; i < nelem (); i++) 105 for (int i = 0; i < nelem (); i++)
106 elem (i) = FixedPoint(is, ds, a.elem (i)); 106 elem (i) = FixedPoint(is, ds, a.elem (i));
107 } 107 }
108 108
109 FixedNDArray::FixedNDArray (const MArrayN<int> &is, 109 FixedNDArray::FixedNDArray (const MArray<int> &is,
110 const MArrayN<int> &ds, 110 const MArray<int> &ds,
111 const NDArray& a) 111 const NDArray& a)
112 : MArrayN<FixedPoint> (a.dims()) 112 : MArray<FixedPoint> (a.dims())
113 { 113 {
114 if ((dims () != is.dims ()) || (dims () != ds.dims ())) { 114 if ((dims () != is.dims ()) || (dims () != ds.dims ())) {
115 (*current_liboctave_error_handler) ("NDArray size mismatch"); 115 (*current_liboctave_error_handler) ("NDArray size mismatch");
116 return; 116 return;
117 } 117 }
121 a.elem (i)); 121 a.elem (i));
122 } 122 }
123 123
124 FixedNDArray::FixedNDArray (const NDArray &is, const NDArray &ds, 124 FixedNDArray::FixedNDArray (const NDArray &is, const NDArray &ds,
125 const NDArray& a) 125 const NDArray& a)
126 : MArrayN<FixedPoint> (a.dims()) 126 : MArray<FixedPoint> (a.dims())
127 { 127 {
128 if ((dims () != is.dims ()) || (dims () != ds.dims ())) { 128 if ((dims () != is.dims ()) || (dims () != ds.dims ())) {
129 (*current_liboctave_error_handler) ("NDArray size mismatch"); 129 (*current_liboctave_error_handler) ("NDArray size mismatch");
130 return; 130 return;
131 } 131 }
135 a.elem (i)); 135 a.elem (i));
136 } 136 }
137 137
138 FixedNDArray::FixedNDArray (unsigned int is, unsigned int ds, 138 FixedNDArray::FixedNDArray (unsigned int is, unsigned int ds,
139 const NDArray& a) 139 const NDArray& a)
140 : MArrayN<FixedPoint> (a.dims()) 140 : MArray<FixedPoint> (a.dims())
141 { 141 {
142 for (int i = 0; i < nelem (); i++) 142 for (int i = 0; i < nelem (); i++)
143 elem (i) = FixedPoint(is, ds, a.elem (i)); 143 elem (i) = FixedPoint(is, ds, a.elem (i));
144 } 144 }
145 145
146 FixedNDArray::FixedNDArray (unsigned int is, unsigned int ds, 146 FixedNDArray::FixedNDArray (unsigned int is, unsigned int ds,
147 const NDArray& a, const NDArray& b) 147 const NDArray& a, const NDArray& b)
148 : MArrayN<FixedPoint> (a.dims()) 148 : MArray<FixedPoint> (a.dims())
149 { 149 {
150 if (dims() != b.dims()) { 150 if (dims() != b.dims()) {
151 (*current_liboctave_error_handler) ("NDArray size mismatch"); 151 (*current_liboctave_error_handler) ("NDArray size mismatch");
152 return; 152 return;
153 } 153 }
155 for (int i = 0; i < nelem (); i++) 155 for (int i = 0; i < nelem (); i++)
156 elem (i) = FixedPoint(is, ds, (unsigned int)a.elem (i), 156 elem (i) = FixedPoint(is, ds, (unsigned int)a.elem (i),
157 (unsigned int)b.elem (i)); 157 (unsigned int)b.elem (i));
158 } 158 }
159 159
160 FixedNDArray::FixedNDArray (const MArrayN<int> &is, const MArrayN<int> &ds, 160 FixedNDArray::FixedNDArray (const MArray<int> &is, const MArray<int> &ds,
161 const NDArray& a, const NDArray& b) 161 const NDArray& a, const NDArray& b)
162 : MArrayN<FixedPoint> (a.dims()) 162 : MArray<FixedPoint> (a.dims())
163 { 163 {
164 if ((dims() != b.dims()) || (dims() != is.dims()) || 164 if ((dims() != b.dims()) || (dims() != is.dims()) ||
165 (dims() != ds.dims())) { 165 (dims() != ds.dims())) {
166 (*current_liboctave_error_handler) ("NDArray size mismatch"); 166 (*current_liboctave_error_handler) ("NDArray size mismatch");
167 return; 167 return;
173 (unsigned int)b.elem (i)); 173 (unsigned int)b.elem (i));
174 } 174 }
175 175
176 FixedNDArray::FixedNDArray (const NDArray &is, const NDArray &ds, 176 FixedNDArray::FixedNDArray (const NDArray &is, const NDArray &ds,
177 const NDArray& a, const NDArray& b) 177 const NDArray& a, const NDArray& b)
178 : MArrayN<FixedPoint> (a.dims()) 178 : MArray<FixedPoint> (a.dims())
179 { 179 {
180 if ((dims() != b.dims()) || (dims() != is.dims()) || 180 if ((dims() != b.dims()) || (dims() != is.dims()) ||
181 (dims() != ds.dims())) { 181 (dims() != ds.dims())) {
182 (*current_liboctave_error_handler) ("NDArray size mismatch"); 182 (*current_liboctave_error_handler) ("NDArray size mismatch");
183 return; 183 return;
187 elem (i) = FixedPoint((unsigned int)is(i), (unsigned int)ds(i), 187 elem (i) = FixedPoint((unsigned int)is(i), (unsigned int)ds(i),
188 (unsigned int)a.elem (i), 188 (unsigned int)a.elem (i),
189 (unsigned int)b.elem (i)); 189 (unsigned int)b.elem (i));
190 } 190 }
191 191
192 FixedNDArray::FixedNDArray (const MArrayN<int> &a) 192 FixedNDArray::FixedNDArray (const MArray<int> &a)
193 : MArrayN<FixedPoint> (a.dims()) 193 : MArray<FixedPoint> (a.dims())
194 { 194 {
195 for (octave_idx_type i = 0; i < nelem (); i++) 195 for (octave_idx_type i = 0; i < nelem (); i++)
196 elem (i) = FixedPoint(a.elem (i)); 196 elem (i) = FixedPoint(a.elem (i));
197 } 197 }
198 198
199 FixedNDArray::FixedNDArray (const NDArray &a) 199 FixedNDArray::FixedNDArray (const NDArray &a)
200 : MArrayN<FixedPoint> (a.dims()) 200 : MArray<FixedPoint> (a.dims())
201 { 201 {
202 for (octave_idx_type i = 0; i < nelem (); i++) 202 for (octave_idx_type i = 0; i < nelem (); i++)
203 elem (i) = FixedPoint(a.elem (i)); 203 elem (i) = FixedPoint(a.elem (i));
204 } 204 }
205 205
357 // other operations. 357 // other operations.
358 358
359 boolNDArray 359 boolNDArray
360 FixedNDArray::all (octave_idx_type dim) const 360 FixedNDArray::all (octave_idx_type dim) const
361 { 361 {
362 return do_mx_red_op<boolNDArray> (*this, dim, mx_inline_all); 362 return do_mx_red_op<bool, FixedPoint> (*this, dim, mx_inline_all);
363 } 363 }
364 364
365 boolNDArray 365 boolNDArray
366 FixedNDArray::any (octave_idx_type dim) const 366 FixedNDArray::any (octave_idx_type dim) const
367 { 367 {
368 return do_mx_red_op<boolNDArray> (*this, dim, mx_inline_any); 368 return do_mx_red_op<bool, FixedPoint> (*this, dim, mx_inline_any);
369 } 369 }
370 370
371 FixedNDArray 371 FixedNDArray
372 FixedNDArray::cumprod (octave_idx_type dim) const 372 FixedNDArray::cumprod (octave_idx_type dim) const
373 { 373 {
374 return do_mx_cum_op<FixedNDArray> (*this, dim, mx_inline_cumprod); 374 return do_mx_cum_op<FixedPoint, FixedPoint> (*this, dim, mx_inline_cumprod);
375 } 375 }
376 376
377 FixedNDArray 377 FixedNDArray
378 FixedNDArray::cumsum (octave_idx_type dim) const 378 FixedNDArray::cumsum (octave_idx_type dim) const
379 { 379 {
380 return do_mx_cum_op<FixedNDArray> (*this, dim, mx_inline_cumsum); 380 return do_mx_cum_op<FixedPoint, FixedPoint> (*this, dim, mx_inline_cumsum);
381 } 381 }
382 382
383 FixedNDArray 383 FixedNDArray
384 FixedNDArray::prod (octave_idx_type dim) const 384 FixedNDArray::prod (octave_idx_type dim) const
385 { 385 {
386 return do_mx_red_op<FixedNDArray> (*this, dim, mx_inline_prod); 386 return do_mx_red_op<FixedPoint, FixedPoint> (*this, dim, mx_inline_prod);
387 } 387 }
388 388
389 FixedNDArray 389 FixedNDArray
390 FixedNDArray::sum (octave_idx_type dim) const 390 FixedNDArray::sum (octave_idx_type dim) const
391 { 391 {
392 return do_mx_red_op<FixedNDArray> (*this, dim, mx_inline_sum); 392 return do_mx_red_op<FixedPoint, FixedPoint> (*this, dim, mx_inline_sum);
393 } 393 }
394 394
395 FixedNDArray 395 FixedNDArray
396 FixedNDArray::sumsq (octave_idx_type dim) const 396 FixedNDArray::sumsq (octave_idx_type dim) const
397 { 397 {
398 return do_mx_red_op<FixedNDArray> (*this, dim, mx_inline_sumsq); 398 return do_mx_red_op<FixedPoint, FixedPoint> (*this, dim, mx_inline_sumsq);
399 } 399 }
400 400
401 FixedNDArray 401 FixedNDArray
402 FixedNDArray::max (octave_idx_type dim) const 402 FixedNDArray::max (octave_idx_type dim) const
403 { 403 {
404 return do_mx_minmax_op<FixedNDArray> (*this, dim, mx_inline_max); 404 return do_mx_minmax_op<FixedPoint> (*this, dim, mx_inline_max);
405 } 405 }
406 406
407 FixedNDArray 407 FixedNDArray
408 FixedNDArray::max (ArrayN<octave_idx_type>& idx_arg, octave_idx_type dim) const 408 FixedNDArray::max (Array<octave_idx_type>& idx_arg, octave_idx_type dim) const
409 { 409 {
410 return do_mx_minmax_op<FixedNDArray> (*this, idx_arg, dim, mx_inline_max); 410 return do_mx_minmax_op<FixedPoint> (*this, idx_arg, dim, mx_inline_max);
411 } 411 }
412 412
413 FixedNDArray 413 FixedNDArray
414 FixedNDArray::min (octave_idx_type dim) const 414 FixedNDArray::min (octave_idx_type dim) const
415 { 415 {
416 return do_mx_minmax_op<FixedNDArray> (*this, dim, mx_inline_min); 416 return do_mx_minmax_op<FixedPoint> (*this, dim, mx_inline_min);
417 } 417 }
418 418
419 FixedNDArray 419 FixedNDArray
420 FixedNDArray::min (ArrayN<octave_idx_type>& idx_arg, octave_idx_type dim) const 420 FixedNDArray::min (Array<octave_idx_type>& idx_arg, octave_idx_type dim) const
421 { 421 {
422 return do_mx_minmax_op<FixedNDArray> (*this, idx_arg, dim, mx_inline_min); 422 return do_mx_minmax_op<FixedPoint> (*this, idx_arg, dim, mx_inline_min);
423 } 423 }
424 424
425 FixedNDArray 425 FixedNDArray
426 FixedNDArray::abs (void) const 426 FixedNDArray::abs (void) const
427 { 427 {
443 octave_idx_type nd = ndims (); 443 octave_idx_type nd = ndims ();
444 444
445 switch (nd) 445 switch (nd)
446 { 446 {
447 case 1: 447 case 1:
448 retval = FixedMatrix (Array2<FixedPoint> (*this, dimensions(0), 1)); 448 retval = FixedMatrix (Array<FixedPoint> (*this, dim_vector (dimensions(0), 1)));
449 break; 449 break;
450 450
451 case 2: 451 case 2:
452 retval = FixedMatrix (Array2<FixedPoint> (*this, dimensions(0), 452 retval = FixedMatrix (Array<FixedPoint> (*this, dim_vector (dimensions(0),
453 dimensions(1))); 453 dimensions(1))));
454 break; 454 break;
455 455
456 default: 456 default:
457 (*current_liboctave_error_handler) 457 (*current_liboctave_error_handler)
458 ("invalid conversion of FixedNDArray to FixedMatrix"); 458 ("invalid conversion of FixedNDArray to FixedMatrix");
525 return retval; 525 return retval;
526 } 526 }
527 527
528 FixedNDArray elem_pow (const FixedNDArray &a, const FixedPoint &b) 528 FixedNDArray elem_pow (const FixedNDArray &a, const FixedPoint &b)
529 { 529 {
530 return elem_pow (a, FixedNDArray(dim_vector (1), b)); 530 return elem_pow (a, FixedNDArray(dim_vector (1, 1), b));
531 } 531 }
532 532
533 FixedNDArray elem_pow (const FixedPoint &a, const FixedNDArray &b) 533 FixedNDArray elem_pow (const FixedPoint &a, const FixedNDArray &b)
534 { 534 {
535 return elem_pow (FixedNDArray(dim_vector (1), a), b); 535 return elem_pow (FixedNDArray(dim_vector (1, 1), a), b);
536 } 536 }
537 537
538 FixedNDArray atan2 (const FixedNDArray &x, const FixedNDArray &y) 538 FixedNDArray atan2 (const FixedNDArray &x, const FixedNDArray &y)
539 { 539 {
540 FixedNDArray retval; 540 FixedNDArray retval;
756 } 756 }
757 757
758 return result; 758 return result;
759 } 759 }
760 760
761 NDS_CMP_OPS(FixedNDArray, , FixedPoint, ) 761 NDS_CMP_OPS(FixedNDArray, FixedPoint)
762 NDS_BOOL_OPS(FixedNDArray, FixedPoint, FixedPoint()) 762 NDS_BOOL_OPS(FixedNDArray, FixedPoint)
763 763
764 SND_CMP_OPS(FixedPoint, , FixedNDArray, ) 764 SND_CMP_OPS(FixedPoint, FixedNDArray)
765 SND_BOOL_OPS(FixedPoint, FixedNDArray, FixedPoint()) 765 SND_BOOL_OPS(FixedPoint, FixedNDArray)
766 766
767 NDND_CMP_OPS(FixedNDArray, , FixedNDArray, ) 767 NDND_CMP_OPS(FixedNDArray, FixedNDArray)
768 NDND_BOOL_OPS(FixedNDArray, FixedNDArray, FixedPoint()) 768 NDND_BOOL_OPS(FixedNDArray, FixedNDArray)
769 769
770 /* 770 /*
771 ;;; Local Variables: *** 771 ;;; Local Variables: ***
772 ;;; mode: C++ *** 772 ;;; mode: C++ ***
773 ;;; End: *** 773 ;;; End: ***