Mercurial > forge

comparison main/fixed/src/fixedNDArray.cc @ 5655:0924c374b60d octave-forge

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Update fixed point code for 3.1.x. Minor bug in test code still present though code seems to work fine
author adb014
date Mon, 18 May 2009 03:18:11 +0000
parents 2de537641f94
children d84d2fea3c90
comparison
equal deleted inserted replaced
5654:8106adc5057c 5655:0924c374b60d
39 39
40 #include "fixedMatrix.h" 40 #include "fixedMatrix.h"
41 #include "fixedNDArray.h" 41 #include "fixedNDArray.h"
42 #include "fixedCNDArray.h" 42 #include "fixedCNDArray.h"
43 43
44 #include "fixed-inline.cc"
45
44 // Fixed Point NDArray class. 46 // Fixed Point NDArray class.
45 47
46 FixedNDArray::FixedNDArray (const MArrayN<int> &is, const MArrayN<int> &ds) 48 FixedNDArray::FixedNDArray (const MArrayN<int> &is, const MArrayN<int> &ds)
47 : MArrayN<FixedPoint> (is.dims()) 49 : MArrayN<FixedPoint> (is.dims())
48 { 50 {
355 // other operations. 357 // other operations.
356 358
357 boolNDArray 359 boolNDArray
358 FixedNDArray::all (octave_idx_type dim) const 360 FixedNDArray::all (octave_idx_type dim) const
359 { 361 {
360 #define FMX_ND_ALL_EXPR elem (iter_idx) .fixedpoint () == 0.0 362 return do_mx_red_op<boolNDArray> (*this, dim, mx_inline_all);
361 MX_ND_ANY_ALL_REDUCTION (MX_ND_ALL_EVAL (FMX_ND_ALL_EXPR), true);
362 #undef FMX_ND_ALL_EXPR
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 #define FMX_ND_ANY_EXPR elem (iter_idx) .fixedpoint () != 0.0 368 return do_mx_red_op<boolNDArray> (*this, dim, mx_inline_any);
369 MX_ND_ANY_ALL_REDUCTION (MX_ND_ANY_EVAL (FMX_ND_ANY_EXPR), false);
370 #undef FMX_ND_ANY_EXPR
371 } 369 }
372 370
373 FixedNDArray 371 FixedNDArray
374 FixedNDArray::cumprod (octave_idx_type dim) const 372 FixedNDArray::cumprod (octave_idx_type dim) const
375 { 373 {
376 FixedPoint one(1,0,1,0); 374 return do_mx_cum_op<FixedNDArray> (*this, dim, mx_inline_cumprod);
377 MX_ND_CUMULATIVE_OP (FixedNDArray, FixedPoint, one, *);
378 } 375 }
379 376
380 FixedNDArray 377 FixedNDArray
381 FixedNDArray::cumsum (octave_idx_type dim) const 378 FixedNDArray::cumsum (octave_idx_type dim) const
382 { 379 {
383 FixedPoint zero; 380 return do_mx_cum_op<FixedNDArray> (*this, dim, mx_inline_cumsum);
384 MX_ND_CUMULATIVE_OP (FixedNDArray, FixedPoint, zero, +);
385 } 381 }
386 382
387 FixedNDArray 383 FixedNDArray
388 FixedNDArray::prod (octave_idx_type dim) const 384 FixedNDArray::prod (octave_idx_type dim) const
389 { 385 {
390 FixedPoint one(1,0,1,0); 386 return do_mx_red_op<FixedNDArray> (*this, dim, mx_inline_prod);
391 MX_ND_REDUCTION (retval(result_idx) *= elem (iter_idx), one, FixedNDArray);
392 } 387 }
393 388
394 FixedNDArray 389 FixedNDArray
395 FixedNDArray::sum (octave_idx_type dim) const 390 FixedNDArray::sum (octave_idx_type dim) const
396 { 391 {
397 FixedPoint zero; 392 return do_mx_red_op<FixedNDArray> (*this, dim, mx_inline_sum);
398 MX_ND_REDUCTION (retval(result_idx) += elem (iter_idx), zero, FixedNDArray);
399 } 393 }
400 394
401 FixedNDArray 395 FixedNDArray
402 FixedNDArray::sumsq (octave_idx_type dim) const 396 FixedNDArray::sumsq (octave_idx_type dim) const
403 { 397 {
404 FixedPoint zero; 398 return do_mx_red_op<FixedNDArray> (*this, dim, mx_inline_sumsq);
405 MX_ND_REDUCTION (retval(result_idx) += pow (elem (iter_idx), 2), zero,
406 FixedNDArray);
407 } 399 }
408 400
409 FixedNDArray 401 FixedNDArray
410 FixedNDArray::max (octave_idx_type dim) const 402 FixedNDArray::max (octave_idx_type dim) const
411 { 403 {
412 ArrayN<octave_idx_type> dummy_idx; 404 return do_mx_minmax_op<FixedNDArray> (*this, dim, mx_inline_max);
413 return max (dummy_idx, dim);
414 } 405 }
415 406
416 FixedNDArray 407 FixedNDArray
417 FixedNDArray::max (ArrayN<octave_idx_type>& idx_arg, octave_idx_type dim) const 408 FixedNDArray::max (ArrayN<octave_idx_type>& idx_arg, octave_idx_type dim) const
418 { 409 {
419 dim_vector dv = dims (); 410 return do_mx_minmax_op<FixedNDArray> (*this, idx_arg, dim, mx_inline_max);
420 dim_vector dr = dims ();
421
422 if (dv.numel () == 0 || dim > dv.length () || dim < 0)
423 return FixedNDArray ();
424
425 dr(dim) = 1;
426
427 FixedNDArray result (dr);
428 idx_arg.resize (dr);
429
430 octave_idx_type x_stride = 1;
431 octave_idx_type x_len = dv(dim);
432 for (octave_idx_type i = 0; i < dim; i++)
433 x_stride *= dv(i);
434
435 for (octave_idx_type i = 0; i < dr.numel (); i++)
436 {
437 octave_idx_type x_offset;
438 if (x_stride == 1)
439 x_offset = i * x_len;
440 else
441 {
442 octave_idx_type x_offset2 = 0;
443 x_offset = i;
444 while (x_offset >= x_stride)
445 {
446 x_offset -= x_stride;
447 x_offset2++;
448 }
449 x_offset += x_offset2 * x_stride * x_len;
450 }
451
452 octave_idx_type idx_j = 0;
453 FixedPoint tmp_max = elem (x_offset);;
454
455 for (octave_idx_type j = 1; j < x_len; j++)
456 {
457 FixedPoint tmp = elem (j * x_stride + x_offset);
458
459 if (tmp > tmp_max)
460 {
461 idx_j = j;
462 tmp_max = tmp;
463 }
464 }
465
466 result.elem (i) = tmp_max;
467 idx_arg.elem (i) = idx_j;
468 }
469
470 return result;
471 } 411 }
472 412
473 FixedNDArray 413 FixedNDArray
474 FixedNDArray::min (octave_idx_type dim) const 414 FixedNDArray::min (octave_idx_type dim) const
475 { 415 {
476 ArrayN<octave_idx_type> dummy_idx; 416 return do_mx_minmax_op<FixedNDArray> (*this, dim, mx_inline_min);
477 return min (dummy_idx, dim);
478 } 417 }
479 418
480 FixedNDArray 419 FixedNDArray
481 FixedNDArray::min (ArrayN<octave_idx_type>& idx_arg, octave_idx_type dim) const 420 FixedNDArray::min (ArrayN<octave_idx_type>& idx_arg, octave_idx_type dim) const
482 { 421 {
483 dim_vector dv = dims (); 422 return do_mx_minmax_op<FixedNDArray> (*this, idx_arg, dim, mx_inline_min);
484 dim_vector dr = dims ();
485
486 if (dv.numel () == 0 || dim > dv.length () || dim < 0)
487 return FixedNDArray ();
488
489 dr(dim) = 1;
490
491 FixedNDArray result (dr);
492 idx_arg.resize (dr);
493
494 octave_idx_type x_stride = 1;
495 octave_idx_type x_len = dv(dim);
496 for (octave_idx_type i = 0; i < dim; i++)
497 x_stride *= dv(i);
498
499 for (octave_idx_type i = 0; i < dr.numel (); i++)
500 {
501 octave_idx_type x_offset;
502 if (x_stride == 1)
503 x_offset = i * x_len;
504 else
505 {
506 octave_idx_type x_offset2 = 0;
507 x_offset = i;
508 while (x_offset >= x_stride)
509 {
510 x_offset -= x_stride;
511 x_offset2++;
512 }
513 x_offset += x_offset2 * x_stride * x_len;
514 }
515
516 octave_idx_type idx_j = 0;
517 FixedPoint tmp_min = elem (x_offset);
518
519 for (octave_idx_type j = 1; j < x_len; j++)
520 {
521 FixedPoint tmp = elem (j * x_stride + x_offset);
522
523 if (tmp < tmp_min)
524 {
525 idx_j = j;
526 tmp_min = tmp;
527 }
528 }
529
530 result.elem (i) = tmp_min;
531 idx_arg.elem (i) = idx_j;
532 }
533
534 return result;
535 } 423 }
536 424
537 FixedNDArray 425 FixedNDArray
538 FixedNDArray::abs (void) const 426 FixedNDArray::abs (void) const
539 { 427 {