"Fossies" - the Fresh Open Source Software Archive

Member "PDL-2.080/GENERATED/PDL/Ufunc.pm" (28 May 2022, 41458 Bytes) of package /linux/misc/PDL-2.080.tar.gz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) Perl source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "Ufunc.pm" see the Fossies "Dox" file reference documentation and the latest Fossies "Diffs" side-by-side code changes report: 2.079_vs_2.080.

A hint: This file contains one or more very long lines, so maybe it is better readable using the pure text view mode that shows the contents as wrapped lines within the browser window.


    1 #
    2 # GENERATED WITH PDL::PP! Don't modify!
    3 #
    4 package PDL::Ufunc;
    5 
    6 our @EXPORT_OK = qw(prodover cprodover dprodover cumuprodover dcumuprodover sumover csumover dsumover cumusumover dcumusumover andover bandover borover orover zcover intover average avgover caverage cavgover daverage davgover minimum minover minimum_ind minover_ind minimum_n_ind minover_n_ind maximum maxover maximum_ind maxover_ind maximum_n_ind maxover_n_ind minmaximum minmaxover avg sum prod davg dsum dprod zcheck and band or bor min max median mode oddmedian any all minmax medover oddmedover modeover pctover oddpctover pct oddpct qsort qsorti qsortvec qsortveci );
    7 our %EXPORT_TAGS = (Func=>\@EXPORT_OK);
    8 
    9 use PDL::Core;
   10 use PDL::Exporter;
   11 use DynaLoader;
   12 
   13 
   14    
   15    our @ISA = ( 'PDL::Exporter','DynaLoader' );
   16    push @PDL::Core::PP, __PACKAGE__;
   17    bootstrap PDL::Ufunc ;
   18 
   19 
   20 
   21 
   22 
   23 
   24 #line 9 "ufunc.pd"
   25 
   26 use strict;
   27 use warnings;
   28 
   29 =head1 NAME
   30 
   31 PDL::Ufunc - primitive ufunc operations for pdl
   32 
   33 =head1 DESCRIPTION
   34 
   35 This module provides some primitive and useful functions defined
   36 using PDL::PP based on functionality of what are sometimes called
   37 I<ufuncs> (for example NumPY and Mathematica talk about these).
   38 It collects all the functions generally used to C<reduce> or
   39 C<accumulate> along a dimension. These all do their job across the
   40 first dimension but by using the slicing functions you can do it
   41 on any dimension.
   42 
   43 The L<PDL::Reduce> module provides an alternative interface
   44 to many of the functions in this module.
   45 
   46 =head1 SYNOPSIS
   47 
   48  use PDL::Ufunc;
   49 
   50 =cut
   51 
   52 use PDL::Slices;
   53 use Carp;
   54 #line 55 "Ufunc.pm"
   55 
   56 
   57 
   58 
   59 
   60 
   61 =head1 FUNCTIONS
   62 
   63 =cut
   64 
   65 
   66 
   67 
   68 #line 1058 "../../blib/lib/PDL/PP.pm"
   69 
   70 
   71 
   72 =head2 prodover
   73 
   74 =for sig
   75 
   76   Signature: (a(n); int+ [o]b())
   77 
   78 
   79 =for ref
   80 
   81 Project via product to N-1 dimensions
   82 
   83 This function reduces the dimensionality of an ndarray
   84 by one by taking the product along the 1st dimension.
   85 
   86 By using L<xchg|PDL::Slices/xchg> etc. it is possible to use
   87 I<any> dimension.
   88 
   89 =for usage
   90 
   91  $y = prodover($x);
   92 
   93 =for example
   94 
   95  $spectrum = prodover $image->transpose
   96 
   97 
   98 
   99 
  100 
  101 =for bad
  102 
  103 prodover processes bad values.
  104 It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
  105 
  106 
  107 =cut
  108 #line 109 "Ufunc.pm"
  109 
  110 
  111 
  112 #line 1060 "../../blib/lib/PDL/PP.pm"
  113 
  114 *prodover = \&PDL::prodover;
  115 #line 116 "Ufunc.pm"
  116 
  117 
  118 
  119 #line 1058 "../../blib/lib/PDL/PP.pm"
  120 
  121 
  122 
  123 =head2 cprodover
  124 
  125 =for sig
  126 
  127   Signature: (a(n); cdouble [o]b())
  128 
  129 
  130 =for ref
  131 
  132 Project via product to N-1 dimensions
  133 
  134 This function reduces the dimensionality of an ndarray
  135 by one by taking the product along the 1st dimension.
  136 
  137 By using L<xchg|PDL::Slices/xchg> etc. it is possible to use
  138 I<any> dimension.
  139 
  140 =for usage
  141 
  142  $y = cprodover($x);
  143 
  144 =for example
  145 
  146  $spectrum = cprodover $image->transpose
  147 
  148 Unlike L</prodover>, the calculations are performed in complex double
  149 precision.
  150 
  151 
  152 
  153 =for bad
  154 
  155 cprodover processes bad values.
  156 It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
  157 
  158 
  159 =cut
  160 #line 161 "Ufunc.pm"
  161 
  162 
  163 
  164 #line 1060 "../../blib/lib/PDL/PP.pm"
  165 
  166 *cprodover = \&PDL::cprodover;
  167 #line 168 "Ufunc.pm"
  168 
  169 
  170 
  171 #line 1058 "../../blib/lib/PDL/PP.pm"
  172 
  173 
  174 
  175 =head2 dprodover
  176 
  177 =for sig
  178 
  179   Signature: (a(n); double [o]b())
  180 
  181 
  182 =for ref
  183 
  184 Project via product to N-1 dimensions
  185 
  186 This function reduces the dimensionality of an ndarray
  187 by one by taking the product along the 1st dimension.
  188 
  189 By using L<xchg|PDL::Slices/xchg> etc. it is possible to use
  190 I<any> dimension.
  191 
  192 =for usage
  193 
  194  $y = dprodover($x);
  195 
  196 =for example
  197 
  198  $spectrum = dprodover $image->transpose
  199 
  200 Unlike L</prodover>, the calculations are performed in double precision.
  201 
  202 
  203 
  204 =for bad
  205 
  206 dprodover processes bad values.
  207 It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
  208 
  209 
  210 =cut
  211 #line 212 "Ufunc.pm"
  212 
  213 
  214 
  215 #line 1060 "../../blib/lib/PDL/PP.pm"
  216 
  217 *dprodover = \&PDL::dprodover;
  218 #line 219 "Ufunc.pm"
  219 
  220 
  221 
  222 #line 1058 "../../blib/lib/PDL/PP.pm"
  223 
  224 
  225 
  226 =head2 cumuprodover
  227 
  228 =for sig
  229 
  230   Signature: (a(n); int+ [o]b(n))
  231 
  232 
  233 =for ref
  234 
  235 Cumulative product
  236 
  237 This function calculates the cumulative product
  238 along the 1st dimension.
  239 
  240 By using L<xchg|PDL::Slices/xchg> etc. it is possible to use
  241 I<any> dimension.
  242 
  243 The sum is started so that the first element in the cumulative product
  244 is the first element of the parameter.
  245 
  246 =for usage
  247 
  248  $y = cumuprodover($x);
  249 
  250 =for example
  251 
  252  $spectrum = cumuprodover $image->transpose
  253 
  254 
  255 
  256 
  257 
  258 =for bad
  259 
  260 cumuprodover processes bad values.
  261 It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
  262 
  263 
  264 =cut
  265 #line 266 "Ufunc.pm"
  266 
  267 
  268 
  269 #line 1060 "../../blib/lib/PDL/PP.pm"
  270 
  271 *cumuprodover = \&PDL::cumuprodover;
  272 #line 273 "Ufunc.pm"
  273 
  274 
  275 
  276 #line 1058 "../../blib/lib/PDL/PP.pm"
  277 
  278 
  279 
  280 =head2 dcumuprodover
  281 
  282 =for sig
  283 
  284   Signature: (a(n); double [o]b(n))
  285 
  286 
  287 =for ref
  288 
  289 Cumulative product
  290 
  291 This function calculates the cumulative product
  292 along the 1st dimension.
  293 
  294 By using L<xchg|PDL::Slices/xchg> etc. it is possible to use
  295 I<any> dimension.
  296 
  297 The sum is started so that the first element in the cumulative product
  298 is the first element of the parameter.
  299 
  300 =for usage
  301 
  302  $y = dcumuprodover($x);
  303 
  304 =for example
  305 
  306  $spectrum = dcumuprodover $image->transpose
  307 
  308 Unlike L</cumuprodover>, the calculations are performed in double precision.
  309 
  310 
  311 
  312 =for bad
  313 
  314 dcumuprodover processes bad values.
  315 It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
  316 
  317 
  318 =cut
  319 #line 320 "Ufunc.pm"
  320 
  321 
  322 
  323 #line 1060 "../../blib/lib/PDL/PP.pm"
  324 
  325 *dcumuprodover = \&PDL::dcumuprodover;
  326 #line 327 "Ufunc.pm"
  327 
  328 
  329 
  330 #line 1058 "../../blib/lib/PDL/PP.pm"
  331 
  332 
  333 
  334 =head2 sumover
  335 
  336 =for sig
  337 
  338   Signature: (a(n); int+ [o]b())
  339 
  340 
  341 =for ref
  342 
  343 Project via sum to N-1 dimensions
  344 
  345 This function reduces the dimensionality of an ndarray
  346 by one by taking the sum along the 1st dimension.
  347 
  348 By using L<xchg|PDL::Slices/xchg> etc. it is possible to use
  349 I<any> dimension.
  350 
  351 =for usage
  352 
  353  $y = sumover($x);
  354 
  355 =for example
  356 
  357  $spectrum = sumover $image->transpose
  358 
  359 
  360 
  361 
  362 
  363 =for bad
  364 
  365 sumover processes bad values.
  366 It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
  367 
  368 
  369 =cut
  370 #line 371 "Ufunc.pm"
  371 
  372 
  373 
  374 #line 1060 "../../blib/lib/PDL/PP.pm"
  375 
  376 *sumover = \&PDL::sumover;
  377 #line 378 "Ufunc.pm"
  378 
  379 
  380 
  381 #line 1058 "../../blib/lib/PDL/PP.pm"
  382 
  383 
  384 
  385 =head2 csumover
  386 
  387 =for sig
  388 
  389   Signature: (a(n); cdouble [o]b())
  390 
  391 
  392 =for ref
  393 
  394 Project via sum to N-1 dimensions
  395 
  396 This function reduces the dimensionality of an ndarray
  397 by one by taking the sum along the 1st dimension.
  398 
  399 By using L<xchg|PDL::Slices/xchg> etc. it is possible to use
  400 I<any> dimension.
  401 
  402 =for usage
  403 
  404  $y = csumover($x);
  405 
  406 =for example
  407 
  408  $spectrum = csumover $image->transpose
  409 
  410 Unlike L</sumover>, the calculations are performed in complex double
  411 precision.
  412 
  413 
  414 
  415 =for bad
  416 
  417 csumover processes bad values.
  418 It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
  419 
  420 
  421 =cut
  422 #line 423 "Ufunc.pm"
  423 
  424 
  425 
  426 #line 1060 "../../blib/lib/PDL/PP.pm"
  427 
  428 *csumover = \&PDL::csumover;
  429 #line 430 "Ufunc.pm"
  430 
  431 
  432 
  433 #line 1058 "../../blib/lib/PDL/PP.pm"
  434 
  435 
  436 
  437 =head2 dsumover
  438 
  439 =for sig
  440 
  441   Signature: (a(n); double [o]b())
  442 
  443 
  444 =for ref
  445 
  446 Project via sum to N-1 dimensions
  447 
  448 This function reduces the dimensionality of an ndarray
  449 by one by taking the sum along the 1st dimension.
  450 
  451 By using L<xchg|PDL::Slices/xchg> etc. it is possible to use
  452 I<any> dimension.
  453 
  454 =for usage
  455 
  456  $y = dsumover($x);
  457 
  458 =for example
  459 
  460  $spectrum = dsumover $image->transpose
  461 
  462 Unlike L</sumover>, the calculations are performed in double precision.
  463 
  464 
  465 
  466 =for bad
  467 
  468 dsumover processes bad values.
  469 It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
  470 
  471 
  472 =cut
  473 #line 474 "Ufunc.pm"
  474 
  475 
  476 
  477 #line 1060 "../../blib/lib/PDL/PP.pm"
  478 
  479 *dsumover = \&PDL::dsumover;
  480 #line 481 "Ufunc.pm"
  481 
  482 
  483 
  484 #line 1058 "../../blib/lib/PDL/PP.pm"
  485 
  486 
  487 
  488 =head2 cumusumover
  489 
  490 =for sig
  491 
  492   Signature: (a(n); int+ [o]b(n))
  493 
  494 
  495 =for ref
  496 
  497 Cumulative sum
  498 
  499 This function calculates the cumulative sum
  500 along the 1st dimension.
  501 
  502 By using L<xchg|PDL::Slices/xchg> etc. it is possible to use
  503 I<any> dimension.
  504 
  505 The sum is started so that the first element in the cumulative sum
  506 is the first element of the parameter.
  507 
  508 =for usage
  509 
  510  $y = cumusumover($x);
  511 
  512 =for example
  513 
  514  $spectrum = cumusumover $image->transpose
  515 
  516 
  517 
  518 
  519 
  520 =for bad
  521 
  522 cumusumover processes bad values.
  523 It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
  524 
  525 
  526 =cut
  527 #line 528 "Ufunc.pm"
  528 
  529 
  530 
  531 #line 1060 "../../blib/lib/PDL/PP.pm"
  532 
  533 *cumusumover = \&PDL::cumusumover;
  534 #line 535 "Ufunc.pm"
  535 
  536 
  537 
  538 #line 1058 "../../blib/lib/PDL/PP.pm"
  539 
  540 
  541 
  542 =head2 dcumusumover
  543 
  544 =for sig
  545 
  546   Signature: (a(n); double [o]b(n))
  547 
  548 
  549 =for ref
  550 
  551 Cumulative sum
  552 
  553 This function calculates the cumulative sum
  554 along the 1st dimension.
  555 
  556 By using L<xchg|PDL::Slices/xchg> etc. it is possible to use
  557 I<any> dimension.
  558 
  559 The sum is started so that the first element in the cumulative sum
  560 is the first element of the parameter.
  561 
  562 =for usage
  563 
  564  $y = dcumusumover($x);
  565 
  566 =for example
  567 
  568  $spectrum = dcumusumover $image->transpose
  569 
  570 Unlike L</cumusumover>, the calculations are performed in double precision.
  571 
  572 
  573 
  574 =for bad
  575 
  576 dcumusumover processes bad values.
  577 It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
  578 
  579 
  580 =cut
  581 #line 582 "Ufunc.pm"
  582 
  583 
  584 
  585 #line 1060 "../../blib/lib/PDL/PP.pm"
  586 
  587 *dcumusumover = \&PDL::dcumusumover;
  588 #line 589 "Ufunc.pm"
  589 
  590 
  591 
  592 #line 1058 "../../blib/lib/PDL/PP.pm"
  593 
  594 
  595 
  596 =head2 andover
  597 
  598 =for sig
  599 
  600   Signature: (a(n); int+ [o]b())
  601 
  602 
  603 =for ref
  604 
  605 Project via and to N-1 dimensions
  606 
  607 This function reduces the dimensionality of an ndarray
  608 by one by taking the and along the 1st dimension.
  609 
  610 By using L<xchg|PDL::Slices/xchg> etc. it is possible to use
  611 I<any> dimension.
  612 
  613 =for usage
  614 
  615  $y = andover($x);
  616 
  617 =for example
  618 
  619  $spectrum = andover $image->transpose
  620 
  621 
  622 
  623 
  624 
  625 =for bad
  626 
  627 If C<a()> contains only bad data (and its bad flag is set), 
  628 C<b()> is set bad. Otherwise C<b()> will have its bad flag cleared,
  629 as it will not contain any bad values.
  630 
  631 =cut
  632 #line 633 "Ufunc.pm"
  633 
  634 
  635 
  636 #line 1060 "../../blib/lib/PDL/PP.pm"
  637 
  638 *andover = \&PDL::andover;
  639 #line 640 "Ufunc.pm"
  640 
  641 
  642 
  643 #line 1058 "../../blib/lib/PDL/PP.pm"
  644 
  645 
  646 
  647 =head2 bandover
  648 
  649 =for sig
  650 
  651   Signature: (a(n);  [o]b())
  652 
  653 
  654 =for ref
  655 
  656 Project via bitwise and to N-1 dimensions
  657 
  658 This function reduces the dimensionality of an ndarray
  659 by one by taking the bitwise and along the 1st dimension.
  660 
  661 By using L<xchg|PDL::Slices/xchg> etc. it is possible to use
  662 I<any> dimension.
  663 
  664 =for usage
  665 
  666  $y = bandover($x);
  667 
  668 =for example
  669 
  670  $spectrum = bandover $image->transpose
  671 
  672 
  673 
  674 
  675 
  676 =for bad
  677 
  678 If C<a()> contains only bad data (and its bad flag is set), 
  679 C<b()> is set bad. Otherwise C<b()> will have its bad flag cleared,
  680 as it will not contain any bad values.
  681 
  682 =cut
  683 #line 684 "Ufunc.pm"
  684 
  685 
  686 
  687 #line 1060 "../../blib/lib/PDL/PP.pm"
  688 
  689 *bandover = \&PDL::bandover;
  690 #line 691 "Ufunc.pm"
  691 
  692 
  693 
  694 #line 1058 "../../blib/lib/PDL/PP.pm"
  695 
  696 
  697 
  698 =head2 borover
  699 
  700 =for sig
  701 
  702   Signature: (a(n);  [o]b())
  703 
  704 
  705 =for ref
  706 
  707 Project via bitwise or to N-1 dimensions
  708 
  709 This function reduces the dimensionality of an ndarray
  710 by one by taking the bitwise or along the 1st dimension.
  711 
  712 By using L<xchg|PDL::Slices/xchg> etc. it is possible to use
  713 I<any> dimension.
  714 
  715 =for usage
  716 
  717  $y = borover($x);
  718 
  719 =for example
  720 
  721  $spectrum = borover $image->transpose
  722 
  723 
  724 
  725 
  726 
  727 =for bad
  728 
  729 If C<a()> contains only bad data (and its bad flag is set), 
  730 C<b()> is set bad. Otherwise C<b()> will have its bad flag cleared,
  731 as it will not contain any bad values.
  732 
  733 =cut
  734 #line 735 "Ufunc.pm"
  735 
  736 
  737 
  738 #line 1060 "../../blib/lib/PDL/PP.pm"
  739 
  740 *borover = \&PDL::borover;
  741 #line 742 "Ufunc.pm"
  742 
  743 
  744 
  745 #line 1058 "../../blib/lib/PDL/PP.pm"
  746 
  747 
  748 
  749 =head2 orover
  750 
  751 =for sig
  752 
  753   Signature: (a(n); int+ [o]b())
  754 
  755 
  756 =for ref
  757 
  758 Project via or to N-1 dimensions
  759 
  760 This function reduces the dimensionality of an ndarray
  761 by one by taking the or along the 1st dimension.
  762 
  763 By using L<xchg|PDL::Slices/xchg> etc. it is possible to use
  764 I<any> dimension.
  765 
  766 =for usage
  767 
  768  $y = orover($x);
  769 
  770 =for example
  771 
  772  $spectrum = orover $image->transpose
  773 
  774 
  775 
  776 
  777 
  778 =for bad
  779 
  780 If C<a()> contains only bad data (and its bad flag is set), 
  781 C<b()> is set bad. Otherwise C<b()> will have its bad flag cleared,
  782 as it will not contain any bad values.
  783 
  784 =cut
  785 #line 786 "Ufunc.pm"
  786 
  787 
  788 
  789 #line 1060 "../../blib/lib/PDL/PP.pm"
  790 
  791 *orover = \&PDL::orover;
  792 #line 793 "Ufunc.pm"
  793 
  794 
  795 
  796 #line 1058 "../../blib/lib/PDL/PP.pm"
  797 
  798 
  799 
  800 =head2 zcover
  801 
  802 =for sig
  803 
  804   Signature: (a(n); int+ [o]b())
  805 
  806 
  807 =for ref
  808 
  809 Project via == 0 to N-1 dimensions
  810 
  811 This function reduces the dimensionality of an ndarray
  812 by one by taking the == 0 along the 1st dimension.
  813 
  814 By using L<xchg|PDL::Slices/xchg> etc. it is possible to use
  815 I<any> dimension.
  816 
  817 =for usage
  818 
  819  $y = zcover($x);
  820 
  821 =for example
  822 
  823  $spectrum = zcover $image->transpose
  824 
  825 
  826 
  827 
  828 
  829 =for bad
  830 
  831 If C<a()> contains only bad data (and its bad flag is set), 
  832 C<b()> is set bad. Otherwise C<b()> will have its bad flag cleared,
  833 as it will not contain any bad values.
  834 
  835 =cut
  836 #line 837 "Ufunc.pm"
  837 
  838 
  839 
  840 #line 1060 "../../blib/lib/PDL/PP.pm"
  841 
  842 *zcover = \&PDL::zcover;
  843 #line 844 "Ufunc.pm"
  844 
  845 
  846 
  847 #line 1058 "../../blib/lib/PDL/PP.pm"
  848 
  849 
  850 
  851 =head2 intover
  852 
  853 =for sig
  854 
  855   Signature: (a(n); float+ [o]b())
  856 
  857 
  858 =for ref
  859 
  860 Project via integral to N-1 dimensions
  861 
  862 This function reduces the dimensionality of an ndarray
  863 by one by taking the integral along the 1st dimension.
  864 
  865 By using L<xchg|PDL::Slices/xchg> etc. it is possible to use
  866 I<any> dimension.
  867 
  868 =for usage
  869 
  870  $y = intover($x);
  871 
  872 =for example
  873 
  874  $spectrum = intover $image->transpose
  875 
  876 Notes:
  877 
  878 C<intover> uses a point spacing of one (i.e., delta-h==1).  You will
  879 need to scale the result to correct for the true point delta).
  880 
  881 For C<n E<gt> 3>, these are all C<O(h^4)> (like Simpson's rule), but are
  882 integrals between the end points assuming the pdl gives values just at
  883 these centres: for such `functions', sumover is correct to C<O(h)>, but
  884 is the natural (and correct) choice for binned data, of course.
  885 
  886 
  887 
  888 
  889 =for bad
  890 
  891 intover ignores the bad-value flag of the input ndarrays.
  892 It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
  893 
  894 
  895 =cut
  896 #line 897 "Ufunc.pm"
  897 
  898 
  899 
  900 #line 1060 "../../blib/lib/PDL/PP.pm"
  901 
  902 *intover = \&PDL::intover;
  903 #line 904 "Ufunc.pm"
  904 
  905 
  906 
  907 #line 1058 "../../blib/lib/PDL/PP.pm"
  908 
  909 
  910 
  911 =head2 average
  912 
  913 =for sig
  914 
  915   Signature: (a(n); int+ [o]b())
  916 
  917 
  918 =for ref
  919 
  920 Project via average to N-1 dimensions
  921 
  922 This function reduces the dimensionality of an ndarray
  923 by one by taking the average along the 1st dimension.
  924 
  925 By using L<xchg|PDL::Slices/xchg> etc. it is possible to use
  926 I<any> dimension.
  927 
  928 =for usage
  929 
  930  $y = average($x);
  931 
  932 =for example
  933 
  934  $spectrum = average $image->transpose
  935 
  936 
  937 
  938 
  939 
  940 =for bad
  941 
  942 average processes bad values.
  943 It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
  944 
  945 
  946 =cut
  947 #line 948 "Ufunc.pm"
  948 
  949 
  950 
  951 #line 1060 "../../blib/lib/PDL/PP.pm"
  952 
  953 *average = \&PDL::average;
  954 #line 955 "Ufunc.pm"
  955 
  956 
  957 
  958 #line 304 "ufunc.pd"
  959 
  960 =head2 avgover
  961 
  962 =for ref
  963 
  964   Synonym for average.
  965 
  966 =cut
  967 
  968 *PDL::avgover = *avgover = \&PDL::average;
  969 #line 970 "Ufunc.pm"
  970 
  971 
  972 
  973 #line 1058 "../../blib/lib/PDL/PP.pm"
  974 
  975 
  976 
  977 =head2 caverage
  978 
  979 =for sig
  980 
  981   Signature: (a(n); cdouble [o]b())
  982 
  983 
  984 =for ref
  985 
  986 Project via average to N-1 dimensions
  987 
  988 This function reduces the dimensionality of an ndarray
  989 by one by taking the average along the 1st dimension.
  990 
  991 By using L<xchg|PDL::Slices/xchg> etc. it is possible to use
  992 I<any> dimension.
  993 
  994 =for usage
  995 
  996  $y = caverage($x);
  997 
  998 =for example
  999 
 1000  $spectrum = caverage $image->transpose
 1001 
 1002 Unlike L<average|/average>, the calculation is performed in complex double
 1003 precision.
 1004 
 1005 
 1006 
 1007 =for bad
 1008 
 1009 caverage processes bad values.
 1010 It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
 1011 
 1012 
 1013 =cut
 1014 #line 1015 "Ufunc.pm"
 1015 
 1016 
 1017 
 1018 #line 1060 "../../blib/lib/PDL/PP.pm"
 1019 
 1020 *caverage = \&PDL::caverage;
 1021 #line 1022 "Ufunc.pm"
 1022 
 1023 
 1024 
 1025 #line 304 "ufunc.pd"
 1026 
 1027 =head2 cavgover
 1028 
 1029 =for ref
 1030 
 1031   Synonym for caverage.
 1032 
 1033 =cut
 1034 
 1035 *PDL::cavgover = *cavgover = \&PDL::caverage;
 1036 #line 1037 "Ufunc.pm"
 1037 
 1038 
 1039 
 1040 #line 1058 "../../blib/lib/PDL/PP.pm"
 1041 
 1042 
 1043 
 1044 =head2 daverage
 1045 
 1046 =for sig
 1047 
 1048   Signature: (a(n); double [o]b())
 1049 
 1050 
 1051 =for ref
 1052 
 1053 Project via average to N-1 dimensions
 1054 
 1055 This function reduces the dimensionality of an ndarray
 1056 by one by taking the average along the 1st dimension.
 1057 
 1058 By using L<xchg|PDL::Slices/xchg> etc. it is possible to use
 1059 I<any> dimension.
 1060 
 1061 =for usage
 1062 
 1063  $y = daverage($x);
 1064 
 1065 =for example
 1066 
 1067  $spectrum = daverage $image->transpose
 1068 
 1069 Unlike L<average|/average>, the calculation is performed in double
 1070 precision.
 1071 
 1072 
 1073 
 1074 =for bad
 1075 
 1076 daverage processes bad values.
 1077 It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
 1078 
 1079 
 1080 =cut
 1081 #line 1082 "Ufunc.pm"
 1082 
 1083 
 1084 
 1085 #line 1060 "../../blib/lib/PDL/PP.pm"
 1086 
 1087 *daverage = \&PDL::daverage;
 1088 #line 1089 "Ufunc.pm"
 1089 
 1090 
 1091 
 1092 #line 304 "ufunc.pd"
 1093 
 1094 =head2 davgover
 1095 
 1096 =for ref
 1097 
 1098   Synonym for daverage.
 1099 
 1100 =cut
 1101 
 1102 *PDL::davgover = *davgover = \&PDL::daverage;
 1103 #line 1104 "Ufunc.pm"
 1104 
 1105 
 1106 
 1107 #line 1058 "../../blib/lib/PDL/PP.pm"
 1108 
 1109 
 1110 
 1111 =head2 minimum
 1112 
 1113 =for sig
 1114 
 1115   Signature: (a(n); [o]c())
 1116 
 1117 
 1118 =for ref
 1119 
 1120 Project via minimum to N-1 dimensions
 1121 
 1122 This function reduces the dimensionality of an ndarray
 1123 by one by taking the minimum along the 1st dimension.
 1124 
 1125 By using L<xchg|PDL::Slices/xchg> etc. it is possible to use
 1126 I<any> dimension.
 1127 
 1128 =for usage
 1129 
 1130  $y = minimum($x);
 1131 
 1132 =for example
 1133 
 1134  $spectrum = minimum $image->transpose
 1135 
 1136 
 1137 
 1138 
 1139 
 1140 =for bad
 1141 
 1142 Output is set bad if no elements of the input are non-bad,
 1143 otherwise the bad flag is cleared for the output ndarray.
 1144 
 1145 Note that C<NaNs> are considered to be valid values and will "win" over non-C<NaN>;
 1146 see L<isfinite|PDL::Math/isfinite> and L<badmask|PDL::Bad/badmask>
 1147 for ways of masking NaNs.
 1148 
 1149 
 1150 =cut
 1151 #line 1152 "Ufunc.pm"
 1152 
 1153 
 1154 
 1155 #line 1060 "../../blib/lib/PDL/PP.pm"
 1156 
 1157 *minimum = \&PDL::minimum;
 1158 #line 1159 "Ufunc.pm"
 1159 
 1160 
 1161 
 1162 #line 304 "ufunc.pd"
 1163 
 1164 =head2 minover
 1165 
 1166 =for ref
 1167 
 1168   Synonym for minimum.
 1169 
 1170 =cut
 1171 
 1172 *PDL::minover = *minover = \&PDL::minimum;
 1173 #line 1174 "Ufunc.pm"
 1174 
 1175 
 1176 
 1177 #line 1058 "../../blib/lib/PDL/PP.pm"
 1178 
 1179 
 1180 
 1181 =head2 minimum_ind
 1182 
 1183 =for sig
 1184 
 1185   Signature: (a(n); indx [o] c())
 1186 
 1187 =for ref
 1188 
 1189 Like minimum but returns the index rather than the value
 1190 
 1191 =for bad
 1192 
 1193 Output is set bad if no elements of the input are non-bad,
 1194 otherwise the bad flag is cleared for the output ndarray.
 1195 
 1196 Note that C<NaNs> are considered to be valid values and will "win" over non-C<NaN>;
 1197 see L<isfinite|PDL::Math/isfinite> and L<badmask|PDL::Bad/badmask>
 1198 for ways of masking NaNs.
 1199 
 1200 
 1201 =cut
 1202 #line 1203 "Ufunc.pm"
 1203 
 1204 
 1205 
 1206 #line 1060 "../../blib/lib/PDL/PP.pm"
 1207 
 1208 *minimum_ind = \&PDL::minimum_ind;
 1209 #line 1210 "Ufunc.pm"
 1210 
 1211 
 1212 
 1213 #line 304 "ufunc.pd"
 1214 
 1215 =head2 minover_ind
 1216 
 1217 =for ref
 1218 
 1219   Synonym for minimum_ind.
 1220 
 1221 =cut
 1222 
 1223 *PDL::minover_ind = *minover_ind = \&PDL::minimum_ind;
 1224 #line 1225 "Ufunc.pm"
 1225 
 1226 
 1227 
 1228 #line 1058 "../../blib/lib/PDL/PP.pm"
 1229 
 1230 
 1231 
 1232 =head2 minimum_n_ind
 1233 
 1234 =for sig
 1235 
 1236   Signature: (a(n); indx [o]c(m); PDL_Indx m_size => m)
 1237 
 1238 =for ref
 1239 
 1240 Returns the index of C<m_size> minimum elements. As of 2.077, you can
 1241 specify how many by either passing in an ndarray of the given size
 1242 (DEPRECATED - will be converted to indx if needed and the input arg will
 1243 be set to that), or just the size, or a null and the size.
 1244 
 1245 =for usage
 1246 
 1247   minimum_n_ind($pdl, $out = zeroes(5)); # DEPRECATED
 1248   $out = minimum_n_ind($pdl, 5);
 1249   minimum_n_ind($pdl, $out = null, 5);
 1250 
 1251 
 1252 
 1253 =for bad
 1254 
 1255 Output bad flag is cleared for the output ndarray if sufficient non-bad elements found,
 1256 else remaining slots in C<$c()> are set bad.
 1257 
 1258 Note that C<NaNs> are considered to be valid values and will "win" over non-C<NaN>;
 1259 see L<isfinite|PDL::Math/isfinite> and L<badmask|PDL::Bad/badmask>
 1260 for ways of masking NaNs.
 1261 
 1262 
 1263 =cut
 1264 #line 1265 "Ufunc.pm"
 1265 
 1266 
 1267 
 1268 #line 1059 "../../blib/lib/PDL/PP.pm"
 1269 
 1270 
 1271 #line 409 "ufunc.pd"
 1272 sub PDL::minimum_n_ind {
 1273   my ($a, $c, $m_size) = @_;
 1274   $m_size //= ref($c) ? $c->dim(0) : $c; # back-compat with pre-2.077
 1275   my $set_out = 1;
 1276   $set_out = 0, $c = null if !ref $c;
 1277   $c = $c->indx if !$c->isnull;
 1278   PDL::_minimum_n_ind_int($a, $c, $m_size);
 1279   $set_out ? $_[1] = $c : $c;
 1280 }
 1281 #line 1071 "../../blib/lib/PDL/PP.pm"
 1282 #line 1283 "Ufunc.pm"
 1283 
 1284 
 1285 
 1286 #line 1060 "../../blib/lib/PDL/PP.pm"
 1287 
 1288 *minimum_n_ind = \&PDL::minimum_n_ind;
 1289 #line 1290 "Ufunc.pm"
 1290 
 1291 
 1292 
 1293 #line 304 "ufunc.pd"
 1294 
 1295 =head2 minover_n_ind
 1296 
 1297 =for ref
 1298 
 1299   Synonym for minimum_n_ind.
 1300 
 1301 =cut
 1302 
 1303 *PDL::minover_n_ind = *minover_n_ind = \&PDL::minimum_n_ind;
 1304 #line 1305 "Ufunc.pm"
 1305 
 1306 
 1307 
 1308 #line 1058 "../../blib/lib/PDL/PP.pm"
 1309 
 1310 
 1311 
 1312 =head2 maximum
 1313 
 1314 =for sig
 1315 
 1316   Signature: (a(n); [o]c())
 1317 
 1318 
 1319 =for ref
 1320 
 1321 Project via maximum to N-1 dimensions
 1322 
 1323 This function reduces the dimensionality of an ndarray
 1324 by one by taking the maximum along the 1st dimension.
 1325 
 1326 By using L<xchg|PDL::Slices/xchg> etc. it is possible to use
 1327 I<any> dimension.
 1328 
 1329 =for usage
 1330 
 1331  $y = maximum($x);
 1332 
 1333 =for example
 1334 
 1335  $spectrum = maximum $image->transpose
 1336 
 1337 
 1338 
 1339 
 1340 
 1341 =for bad
 1342 
 1343 Output is set bad if no elements of the input are non-bad,
 1344 otherwise the bad flag is cleared for the output ndarray.
 1345 
 1346 Note that C<NaNs> are considered to be valid values and will "win" over non-C<NaN>;
 1347 see L<isfinite|PDL::Math/isfinite> and L<badmask|PDL::Bad/badmask>
 1348 for ways of masking NaNs.
 1349 
 1350 
 1351 =cut
 1352 #line 1353 "Ufunc.pm"
 1353 
 1354 
 1355 
 1356 #line 1060 "../../blib/lib/PDL/PP.pm"
 1357 
 1358 *maximum = \&PDL::maximum;
 1359 #line 1360 "Ufunc.pm"
 1360 
 1361 
 1362 
 1363 #line 304 "ufunc.pd"
 1364 
 1365 =head2 maxover
 1366 
 1367 =for ref
 1368 
 1369   Synonym for maximum.
 1370 
 1371 =cut
 1372 
 1373 *PDL::maxover = *maxover = \&PDL::maximum;
 1374 #line 1375 "Ufunc.pm"
 1375 
 1376 
 1377 
 1378 #line 1058 "../../blib/lib/PDL/PP.pm"
 1379 
 1380 
 1381 
 1382 =head2 maximum_ind
 1383 
 1384 =for sig
 1385 
 1386   Signature: (a(n); indx [o] c())
 1387 
 1388 =for ref
 1389 
 1390 Like maximum but returns the index rather than the value
 1391 
 1392 =for bad
 1393 
 1394 Output is set bad if no elements of the input are non-bad,
 1395 otherwise the bad flag is cleared for the output ndarray.
 1396 
 1397 Note that C<NaNs> are considered to be valid values and will "win" over non-C<NaN>;
 1398 see L<isfinite|PDL::Math/isfinite> and L<badmask|PDL::Bad/badmask>
 1399 for ways of masking NaNs.
 1400 
 1401 
 1402 =cut
 1403 #line 1404 "Ufunc.pm"
 1404 
 1405 
 1406 
 1407 #line 1060 "../../blib/lib/PDL/PP.pm"
 1408 
 1409 *maximum_ind = \&PDL::maximum_ind;
 1410 #line 1411 "Ufunc.pm"
 1411 
 1412 
 1413 
 1414 #line 304 "ufunc.pd"
 1415 
 1416 =head2 maxover_ind
 1417 
 1418 =for ref
 1419 
 1420   Synonym for maximum_ind.
 1421 
 1422 =cut
 1423 
 1424 *PDL::maxover_ind = *maxover_ind = \&PDL::maximum_ind;
 1425 #line 1426 "Ufunc.pm"
 1426 
 1427 
 1428 
 1429 #line 1058 "../../blib/lib/PDL/PP.pm"
 1430 
 1431 
 1432 
 1433 =head2 maximum_n_ind
 1434 
 1435 =for sig
 1436 
 1437   Signature: (a(n); indx [o]c(m); PDL_Indx m_size => m)
 1438 
 1439 =for ref
 1440 
 1441 Returns the index of C<m_size> maximum elements. As of 2.077, you can
 1442 specify how many by either passing in an ndarray of the given size
 1443 (DEPRECATED - will be converted to indx if needed and the input arg will
 1444 be set to that), or just the size, or a null and the size.
 1445 
 1446 =for usage
 1447 
 1448   maximum_n_ind($pdl, $out = zeroes(5)); # DEPRECATED
 1449   $out = maximum_n_ind($pdl, 5);
 1450   maximum_n_ind($pdl, $out = null, 5);
 1451 
 1452 
 1453 
 1454 =for bad
 1455 
 1456 Output bad flag is cleared for the output ndarray if sufficient non-bad elements found,
 1457 else remaining slots in C<$c()> are set bad.
 1458 
 1459 Note that C<NaNs> are considered to be valid values and will "win" over non-C<NaN>;
 1460 see L<isfinite|PDL::Math/isfinite> and L<badmask|PDL::Bad/badmask>
 1461 for ways of masking NaNs.
 1462 
 1463 
 1464 =cut
 1465 #line 1466 "Ufunc.pm"
 1466 
 1467 
 1468 
 1469 #line 1059 "../../blib/lib/PDL/PP.pm"
 1470 
 1471 
 1472 #line 409 "ufunc.pd"
 1473 sub PDL::maximum_n_ind {
 1474   my ($a, $c, $m_size) = @_;
 1475   $m_size //= ref($c) ? $c->dim(0) : $c; # back-compat with pre-2.077
 1476   my $set_out = 1;
 1477   $set_out = 0, $c = null if !ref $c;
 1478   $c = $c->indx if !$c->isnull;
 1479   PDL::_maximum_n_ind_int($a, $c, $m_size);
 1480   $set_out ? $_[1] = $c : $c;
 1481 }
 1482 #line 1071 "../../blib/lib/PDL/PP.pm"
 1483 #line 1484 "Ufunc.pm"
 1484 
 1485 
 1486 
 1487 #line 1060 "../../blib/lib/PDL/PP.pm"
 1488 
 1489 *maximum_n_ind = \&PDL::maximum_n_ind;
 1490 #line 1491 "Ufunc.pm"
 1491 
 1492 
 1493 
 1494 #line 304 "ufunc.pd"
 1495 
 1496 =head2 maxover_n_ind
 1497 
 1498 =for ref
 1499 
 1500   Synonym for maximum_n_ind.
 1501 
 1502 =cut
 1503 
 1504 *PDL::maxover_n_ind = *maxover_n_ind = \&PDL::maximum_n_ind;
 1505 #line 1506 "Ufunc.pm"
 1506 
 1507 
 1508 
 1509 #line 1058 "../../blib/lib/PDL/PP.pm"
 1510 
 1511 
 1512 
 1513 =head2 minmaximum
 1514 
 1515 =for sig
 1516 
 1517   Signature: (a(n); [o]cmin(); [o] cmax(); indx [o]cmin_ind(); indx [o]cmax_ind())
 1518 
 1519 
 1520 =for ref
 1521 
 1522 Find minimum and maximum and their indices for a given ndarray;
 1523 
 1524 =for usage
 1525 
 1526  pdl> $x=pdl [[-2,3,4],[1,0,3]]
 1527  pdl> ($min, $max, $min_ind, $max_ind)=minmaximum($x)
 1528  pdl> p $min, $max, $min_ind, $max_ind
 1529  [-2 0] [4 3] [0 1] [2 2]
 1530 
 1531 See also L</minmax>, which clumps the ndarray together.
 1532 
 1533 
 1534 
 1535 =for bad
 1536 
 1537 If C<a()> contains only bad data, then the output ndarrays will
 1538 be set bad, along with their bad flag.
 1539 Otherwise they will have their bad flags cleared,
 1540 since they will not contain any bad values.
 1541 
 1542 =cut
 1543 #line 1544 "Ufunc.pm"
 1544 
 1545 
 1546 
 1547 #line 1060 "../../blib/lib/PDL/PP.pm"
 1548 
 1549 *minmaximum = \&PDL::minmaximum;
 1550 #line 1551 "Ufunc.pm"
 1551 
 1552 
 1553 
 1554 #line 304 "ufunc.pd"
 1555 
 1556 =head2 minmaxover
 1557 
 1558 =for ref
 1559 
 1560   Synonym for minmaximum.
 1561 
 1562 =cut
 1563 
 1564 *PDL::minmaxover = *minmaxover = \&PDL::minmaximum;
 1565 #line 1566 "Ufunc.pm"
 1566 
 1567 
 1568 
 1569 #line 543 "ufunc.pd"
 1570 
 1571 =head2 avg
 1572 
 1573 =for ref
 1574 
 1575 Return the average of all elements in an ndarray.
 1576 
 1577 See the documentation for L</average> for more information.
 1578 
 1579 =for usage
 1580 
 1581  $x = avg($data);
 1582 
 1583 =for bad
 1584 
 1585 This routine handles bad values.
 1586 
 1587 =cut
 1588 
 1589 *avg = \&PDL::avg;
 1590 sub PDL::avg {
 1591     my($x) = @_; my $tmp;
 1592     $x->clump(-1)->average( $tmp=PDL->nullcreate($x) );
 1593     $tmp;
 1594 }
 1595 #line 1596 "Ufunc.pm"
 1596 
 1597 
 1598 
 1599 #line 543 "ufunc.pd"
 1600 
 1601 =head2 sum
 1602 
 1603 =for ref
 1604 
 1605 Return the sum of all elements in an ndarray.
 1606 
 1607 See the documentation for L</sumover> for more information.
 1608 
 1609 =for usage
 1610 
 1611  $x = sum($data);
 1612 
 1613 =for bad
 1614 
 1615 This routine handles bad values.
 1616 
 1617 =cut
 1618 
 1619 *sum = \&PDL::sum;
 1620 sub PDL::sum {
 1621     my($x) = @_; my $tmp;
 1622     $x->clump(-1)->sumover( $tmp=PDL->nullcreate($x) );
 1623     $tmp;
 1624 }
 1625 #line 1626 "Ufunc.pm"
 1626 
 1627 
 1628 
 1629 #line 543 "ufunc.pd"
 1630 
 1631 =head2 prod
 1632 
 1633 =for ref
 1634 
 1635 Return the product of all elements in an ndarray.
 1636 
 1637 See the documentation for L</prodover> for more information.
 1638 
 1639 =for usage
 1640 
 1641  $x = prod($data);
 1642 
 1643 =for bad
 1644 
 1645 This routine handles bad values.
 1646 
 1647 =cut
 1648 
 1649 *prod = \&PDL::prod;
 1650 sub PDL::prod {
 1651     my($x) = @_; my $tmp;
 1652     $x->clump(-1)->prodover( $tmp=PDL->nullcreate($x) );
 1653     $tmp;
 1654 }
 1655 #line 1656 "Ufunc.pm"
 1656 
 1657 
 1658 
 1659 #line 543 "ufunc.pd"
 1660 
 1661 =head2 davg
 1662 
 1663 =for ref
 1664 
 1665 Return the average (in double precision) of all elements in an ndarray.
 1666 
 1667 See the documentation for L</daverage> for more information.
 1668 
 1669 =for usage
 1670 
 1671  $x = davg($data);
 1672 
 1673 =for bad
 1674 
 1675 This routine handles bad values.
 1676 
 1677 =cut
 1678 
 1679 *davg = \&PDL::davg;
 1680 sub PDL::davg {
 1681     my($x) = @_; my $tmp;
 1682     $x->clump(-1)->daverage( $tmp=PDL->nullcreate($x) );
 1683     $tmp;
 1684 }
 1685 #line 1686 "Ufunc.pm"
 1686 
 1687 
 1688 
 1689 #line 543 "ufunc.pd"
 1690 
 1691 =head2 dsum
 1692 
 1693 =for ref
 1694 
 1695 Return the sum (in double precision) of all elements in an ndarray.
 1696 
 1697 See the documentation for L</dsumover> for more information.
 1698 
 1699 =for usage
 1700 
 1701  $x = dsum($data);
 1702 
 1703 =for bad
 1704 
 1705 This routine handles bad values.
 1706 
 1707 =cut
 1708 
 1709 *dsum = \&PDL::dsum;
 1710 sub PDL::dsum {
 1711     my($x) = @_; my $tmp;
 1712     $x->clump(-1)->dsumover( $tmp=PDL->nullcreate($x) );
 1713     $tmp;
 1714 }
 1715 #line 1716 "Ufunc.pm"
 1716 
 1717 
 1718 
 1719 #line 543 "ufunc.pd"
 1720 
 1721 =head2 dprod
 1722 
 1723 =for ref
 1724 
 1725 Return the product (in double precision) of all elements in an ndarray.
 1726 
 1727 See the documentation for L</dprodover> for more information.
 1728 
 1729 =for usage
 1730 
 1731  $x = dprod($data);
 1732 
 1733 =for bad
 1734 
 1735 This routine handles bad values.
 1736 
 1737 =cut
 1738 
 1739 *dprod = \&PDL::dprod;
 1740 sub PDL::dprod {
 1741     my($x) = @_; my $tmp;
 1742     $x->clump(-1)->dprodover( $tmp=PDL->nullcreate($x) );
 1743     $tmp;
 1744 }
 1745 #line 1746 "Ufunc.pm"
 1746 
 1747 
 1748 
 1749 #line 543 "ufunc.pd"
 1750 
 1751 =head2 zcheck
 1752 
 1753 =for ref
 1754 
 1755 Return the check for zero of all elements in an ndarray.
 1756 
 1757 See the documentation for L</zcover> for more information.
 1758 
 1759 =for usage
 1760 
 1761  $x = zcheck($data);
 1762 
 1763 =for bad
 1764 
 1765 This routine handles bad values.
 1766 
 1767 =cut
 1768 
 1769 *zcheck = \&PDL::zcheck;
 1770 sub PDL::zcheck {
 1771     my($x) = @_; my $tmp;
 1772     $x->clump(-1)->zcover( $tmp=PDL->nullcreate($x) );
 1773     $tmp;
 1774 }
 1775 #line 1776 "Ufunc.pm"
 1776 
 1777 
 1778 
 1779 #line 543 "ufunc.pd"
 1780 
 1781 =head2 and
 1782 
 1783 =for ref
 1784 
 1785 Return the logical and of all elements in an ndarray.
 1786 
 1787 See the documentation for L</andover> for more information.
 1788 
 1789 =for usage
 1790 
 1791  $x = and($data);
 1792 
 1793 =for bad
 1794 
 1795 This routine handles bad values.
 1796 
 1797 =cut
 1798 
 1799 *and = \&PDL::and;
 1800 sub PDL::and {
 1801     my($x) = @_; my $tmp;
 1802     $x->clump(-1)->andover( $tmp=PDL->nullcreate($x) );
 1803     $tmp;
 1804 }
 1805 #line 1806 "Ufunc.pm"
 1806 
 1807 
 1808 
 1809 #line 543 "ufunc.pd"
 1810 
 1811 =head2 band
 1812 
 1813 =for ref
 1814 
 1815 Return the bitwise and of all elements in an ndarray.
 1816 
 1817 See the documentation for L</bandover> for more information.
 1818 
 1819 =for usage
 1820 
 1821  $x = band($data);
 1822 
 1823 =for bad
 1824 
 1825 This routine handles bad values.
 1826 
 1827 =cut
 1828 
 1829 *band = \&PDL::band;
 1830 sub PDL::band {
 1831     my($x) = @_; my $tmp;
 1832     $x->clump(-1)->bandover( $tmp=PDL->nullcreate($x) );
 1833     $tmp;
 1834 }
 1835 #line 1836 "Ufunc.pm"
 1836 
 1837 
 1838 
 1839 #line 543 "ufunc.pd"
 1840 
 1841 =head2 or
 1842 
 1843 =for ref
 1844 
 1845 Return the logical or of all elements in an ndarray.
 1846 
 1847 See the documentation for L</orover> for more information.
 1848 
 1849 =for usage
 1850 
 1851  $x = or($data);
 1852 
 1853 =for bad
 1854 
 1855 This routine handles bad values.
 1856 
 1857 =cut
 1858 
 1859 *or = \&PDL::or;
 1860 sub PDL::or {
 1861     my($x) = @_; my $tmp;
 1862     $x->clump(-1)->orover( $tmp=PDL->nullcreate($x) );
 1863     $tmp;
 1864 }
 1865 #line 1866 "Ufunc.pm"
 1866 
 1867 
 1868 
 1869 #line 543 "ufunc.pd"
 1870 
 1871 =head2 bor
 1872 
 1873 =for ref
 1874 
 1875 Return the bitwise or of all elements in an ndarray.
 1876 
 1877 See the documentation for L</borover> for more information.
 1878 
 1879 =for usage
 1880 
 1881  $x = bor($data);
 1882 
 1883 =for bad
 1884 
 1885 This routine handles bad values.
 1886 
 1887 =cut
 1888 
 1889 *bor = \&PDL::bor;
 1890 sub PDL::bor {
 1891     my($x) = @_; my $tmp;
 1892     $x->clump(-1)->borover( $tmp=PDL->nullcreate($x) );
 1893     $tmp;
 1894 }
 1895 #line 1896 "Ufunc.pm"
 1896 
 1897 
 1898 
 1899 #line 543 "ufunc.pd"
 1900 
 1901 =head2 min
 1902 
 1903 =for ref
 1904 
 1905 Return the minimum of all elements in an ndarray.
 1906 
 1907 See the documentation for L</minimum> for more information.
 1908 
 1909 =for usage
 1910 
 1911  $x = min($data);
 1912 
 1913 =for bad
 1914 
 1915 This routine handles bad values.
 1916 
 1917 =cut
 1918 
 1919 *min = \&PDL::min;
 1920 sub PDL::min {
 1921     my($x) = @_; my $tmp;
 1922     $x->clump(-1)->minimum( $tmp=PDL->nullcreate($x) );
 1923     $tmp;
 1924 }
 1925 #line 1926 "Ufunc.pm"
 1926 
 1927 
 1928 
 1929 #line 543 "ufunc.pd"
 1930 
 1931 =head2 max
 1932 
 1933 =for ref
 1934 
 1935 Return the maximum of all elements in an ndarray.
 1936 
 1937 See the documentation for L</maximum> for more information.
 1938 
 1939 =for usage
 1940 
 1941  $x = max($data);
 1942 
 1943 =for bad
 1944 
 1945 This routine handles bad values.
 1946 
 1947 =cut
 1948 
 1949 *max = \&PDL::max;
 1950 sub PDL::max {
 1951     my($x) = @_; my $tmp;
 1952     $x->clump(-1)->maximum( $tmp=PDL->nullcreate($x) );
 1953     $tmp;
 1954 }
 1955 #line 1956 "Ufunc.pm"
 1956 
 1957 
 1958 
 1959 #line 543 "ufunc.pd"
 1960 
 1961 =head2 median
 1962 
 1963 =for ref
 1964 
 1965 Return the median of all elements in an ndarray.
 1966 
 1967 See the documentation for L</medover> for more information.
 1968 
 1969 =for usage
 1970 
 1971  $x = median($data);
 1972 
 1973 =for bad
 1974 
 1975 This routine handles bad values.
 1976 
 1977 =cut
 1978 
 1979 *median = \&PDL::median;
 1980 sub PDL::median {
 1981     my($x) = @_; my $tmp;
 1982     $x->clump(-1)->medover( $tmp=PDL->nullcreate($x) );
 1983     $tmp;
 1984 }
 1985 #line 1986 "Ufunc.pm"
 1986 
 1987 
 1988 
 1989 #line 543 "ufunc.pd"
 1990 
 1991 =head2 mode
 1992 
 1993 =for ref
 1994 
 1995 Return the mode of all elements in an ndarray.
 1996 
 1997 See the documentation for L</modeover> for more information.
 1998 
 1999 =for usage
 2000 
 2001  $x = mode($data);
 2002 
 2003 =for bad
 2004 
 2005 This routine handles bad values.
 2006 
 2007 =cut
 2008 
 2009 *mode = \&PDL::mode;
 2010 sub PDL::mode {
 2011     my($x) = @_; my $tmp;
 2012     $x->clump(-1)->modeover( $tmp=PDL->nullcreate($x) );
 2013     $tmp;
 2014 }
 2015 #line 2016 "Ufunc.pm"
 2016 
 2017 
 2018 
 2019 #line 543 "ufunc.pd"
 2020 
 2021 =head2 oddmedian
 2022 
 2023 =for ref
 2024 
 2025 Return the oddmedian of all elements in an ndarray.
 2026 
 2027 See the documentation for L</oddmedover> for more information.
 2028 
 2029 =for usage
 2030 
 2031  $x = oddmedian($data);
 2032 
 2033 =for bad
 2034 
 2035 This routine handles bad values.
 2036 
 2037 =cut
 2038 
 2039 *oddmedian = \&PDL::oddmedian;
 2040 sub PDL::oddmedian {
 2041     my($x) = @_; my $tmp;
 2042     $x->clump(-1)->oddmedover( $tmp=PDL->nullcreate($x) );
 2043     $tmp;
 2044 }
 2045 #line 2046 "Ufunc.pm"
 2046 
 2047 
 2048 
 2049 #line 573 "ufunc.pd"
 2050 
 2051 
 2052 =head2 any
 2053 
 2054 =for ref
 2055 
 2056 Return true if any element in ndarray set
 2057 
 2058 Useful in conditional expressions:
 2059 
 2060 =for example
 2061 
 2062  if (any $x>15) { print "some values are greater than 15\n" }
 2063 
 2064 =for bad
 2065 
 2066 See L</or> for comments on what happens when all elements
 2067 in the check are bad.
 2068 
 2069 =cut
 2070 
 2071 *any = \&or;
 2072 *PDL::any = \&PDL::or;
 2073 
 2074 =head2 all
 2075 
 2076 =for ref
 2077 
 2078 Return true if all elements in ndarray set
 2079 
 2080 Useful in conditional expressions:
 2081 
 2082 =for example
 2083 
 2084  if (all $x>15) { print "all values are greater than 15\n" }
 2085 
 2086 =for bad
 2087 
 2088 See L</and> for comments on what happens when all elements
 2089 in the check are bad.
 2090 
 2091 =cut
 2092 
 2093 *all = \&and;
 2094 *PDL::all = \&PDL::and;
 2095 
 2096 =head2 minmax
 2097 
 2098 =for ref
 2099 
 2100 Returns a list with minimum and maximum values of an ndarray.
 2101 
 2102 =for usage
 2103 
 2104  ($mn, $mx) = minmax($pdl);
 2105 
 2106 This routine does I<not> broadcast over the dimensions of C<$pdl>;
 2107 it returns the minimum and maximum values of the whole ndarray.
 2108 See L</minmaximum> if this is not what is required.
 2109 The two values are returned as Perl scalars,
 2110 and therefore ignore whether the values are bad.
 2111 
 2112 =for example
 2113 
 2114  pdl> $x = pdl [1,-2,3,5,0]
 2115  pdl> ($min, $max) = minmax($x);
 2116  pdl> p "$min $max\n";
 2117  -2 5
 2118 
 2119 =cut
 2120 
 2121 *minmax = \&PDL::minmax;
 2122 sub PDL::minmax {
 2123   my ($x)=@_; my $tmp;
 2124   my @arr = $x->clump(-1)->minmaximum;
 2125   map $_->sclr, @arr[0,1]; # as scalars !
 2126 }
 2127 #line 2128 "Ufunc.pm"
 2128 
 2129 
 2130 
 2131 #line 1058 "../../blib/lib/PDL/PP.pm"
 2132 
 2133 
 2134 
 2135 =head2 medover
 2136 
 2137 =for sig
 2138 
 2139   Signature: (a(n); [o]b(); [t]tmp(n))
 2140 
 2141 
 2142 =for ref
 2143 
 2144 Project via median to N-1 dimensions
 2145 
 2146 This function reduces the dimensionality of an ndarray
 2147 by one by taking the median along the 1st dimension.
 2148 
 2149 By using L<xchg|PDL::Slices/xchg> etc. it is possible to use
 2150 I<any> dimension.
 2151 
 2152 =for usage
 2153 
 2154  $y = medover($x);
 2155 
 2156 =for example
 2157 
 2158  $spectrum = medover $image->transpose
 2159 
 2160 
 2161 
 2162 
 2163 
 2164 =for bad
 2165 
 2166 medover processes bad values.
 2167 It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
 2168 
 2169 
 2170 =cut
 2171 #line 2172 "Ufunc.pm"
 2172 
 2173 
 2174 
 2175 #line 1060 "../../blib/lib/PDL/PP.pm"
 2176 
 2177 *medover = \&PDL::medover;
 2178 #line 2179 "Ufunc.pm"
 2179 
 2180 
 2181 
 2182 #line 1058 "../../blib/lib/PDL/PP.pm"
 2183 
 2184 
 2185 
 2186 =head2 oddmedover
 2187 
 2188 =for sig
 2189 
 2190   Signature: (a(n); [o]b(); [t]tmp(n))
 2191 
 2192 
 2193 =for ref
 2194 
 2195 Project via oddmedian to N-1 dimensions
 2196 
 2197 This function reduces the dimensionality of an ndarray
 2198 by one by taking the oddmedian along the 1st dimension.
 2199 
 2200 By using L<xchg|PDL::Slices/xchg> etc. it is possible to use
 2201 I<any> dimension.
 2202 
 2203 =for usage
 2204 
 2205  $y = oddmedover($x);
 2206 
 2207 =for example
 2208 
 2209  $spectrum = oddmedover $image->transpose
 2210 
 2211 
 2212 
 2213 The median is sometimes not a good choice as if the array has
 2214 an even number of elements it lies half-way between the two
 2215 middle values - thus it does not always correspond to a data
 2216 value. The lower-odd median is just the lower of these two values
 2217 and so it ALWAYS sits on an actual data value which is useful in
 2218 some circumstances.
 2219     
 2220 
 2221 
 2222 
 2223 =for bad
 2224 
 2225 oddmedover processes bad values.
 2226 It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
 2227 
 2228 
 2229 =cut
 2230 #line 2231 "Ufunc.pm"
 2231 
 2232 
 2233 
 2234 #line 1060 "../../blib/lib/PDL/PP.pm"
 2235 
 2236 *oddmedover = \&PDL::oddmedover;
 2237 #line 2238 "Ufunc.pm"
 2238 
 2239 
 2240 
 2241 #line 1058 "../../blib/lib/PDL/PP.pm"
 2242 
 2243 
 2244 
 2245 =head2 modeover
 2246 
 2247 =for sig
 2248 
 2249   Signature: (data(n); [o]out(); [t]sorted(n))
 2250 
 2251 
 2252 =for ref
 2253 
 2254 Project via mode to N-1 dimensions
 2255 
 2256 This function reduces the dimensionality of an ndarray
 2257 by one by taking the mode along the 1st dimension.
 2258 
 2259 By using L<xchg|PDL::Slices/xchg> etc. it is possible to use
 2260 I<any> dimension.
 2261 
 2262 =for usage
 2263 
 2264  $y = modeover($x);
 2265 
 2266 =for example
 2267 
 2268  $spectrum = modeover $image->transpose
 2269 
 2270 
 2271 The mode is the single element most frequently found in a 
 2272 discrete data set.
 2273 
 2274 It I<only> makes sense for integer data types, since
 2275 floating-point types are demoted to integer before the
 2276 mode is calculated.
 2277 
 2278 C<modeover> treats BAD the same as any other value:  if
 2279 BAD is the most common element, the returned value is also BAD.
 2280 
 2281 
 2282 
 2283 
 2284 =for bad
 2285 
 2286 modeover does not process bad values.
 2287 It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
 2288 
 2289 
 2290 =cut
 2291 #line 2292 "Ufunc.pm"
 2292 
 2293 
 2294 
 2295 #line 1060 "../../blib/lib/PDL/PP.pm"
 2296 
 2297 *modeover = \&PDL::modeover;
 2298 #line 2299 "Ufunc.pm"
 2299 
 2300 
 2301 
 2302 #line 1058 "../../blib/lib/PDL/PP.pm"
 2303 
 2304 
 2305 
 2306 =head2 pctover
 2307 
 2308 =for sig
 2309 
 2310   Signature: (a(n); p(); [o]b(); [t]tmp(n))
 2311 
 2312 
 2313 =for ref
 2314 
 2315 Project via specified percentile to N-1 dimensions
 2316 
 2317 This function reduces the dimensionality of an ndarray
 2318 by one by taking the specified percentile along the 1st dimension.
 2319 
 2320 By using L<xchg|PDL::Slices/xchg> etc. it is possible to use
 2321 I<any> dimension.
 2322 
 2323 =for usage
 2324 
 2325  $y = pctover($x);
 2326 
 2327 =for example
 2328 
 2329  $spectrum = pctover $image->transpose
 2330 
 2331 The specified
 2332 percentile must be between 0.0 and 1.0.  When the specified percentile
 2333 falls between data points, the result is interpolated.  Values outside
 2334 the allowed range are clipped to 0.0 or 1.0 respectively.  The algorithm
 2335 implemented here is based on the interpolation variant described at
 2336 L<http://en.wikipedia.org/wiki/Percentile> as used by Microsoft Excel
 2337 and recommended by NIST.
 2338 
 2339 
 2340 
 2341 
 2342 =for bad
 2343 
 2344 pctover processes bad values.
 2345 It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
 2346 
 2347 
 2348 =cut
 2349 #line 2350 "Ufunc.pm"
 2350 
 2351 
 2352 
 2353 #line 1060 "../../blib/lib/PDL/PP.pm"
 2354 
 2355 *pctover = \&PDL::pctover;
 2356 #line 2357 "Ufunc.pm"
 2357 
 2358 
 2359 
 2360 #line 1058 "../../blib/lib/PDL/PP.pm"
 2361 
 2362 
 2363 
 2364 =head2 oddpctover
 2365 
 2366 =for sig
 2367 
 2368   Signature: (a(n); p(); [o]b(); [t]tmp(n))
 2369 
 2370 
 2371 =for ref
 2372 
 2373 Project via specified percentile to N-1 dimensions
 2374 
 2375 This function reduces the dimensionality of an ndarray
 2376 by one by taking the specified percentile along the 1st dimension.
 2377 
 2378 By using L<xchg|PDL::Slices/xchg> etc. it is possible to use
 2379 I<any> dimension.
 2380 
 2381 =for usage
 2382 
 2383  $y = oddpctover($x);
 2384 
 2385 =for example
 2386 
 2387  $spectrum = oddpctover $image->transpose
 2388 
 2389 The specified
 2390 percentile must be between 0.0 and 1.0.  When the specified percentile
 2391 falls between two values, the nearest data value is the result.
 2392 The algorithm implemented is from the textbook version described
 2393 first at L<http://en.wikipedia.org/wiki/Percentile>.
 2394 
 2395 
 2396 
 2397 
 2398 =for bad
 2399 
 2400 oddpctover processes bad values.
 2401 It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
 2402 
 2403 
 2404 =cut
 2405 #line 2406 "Ufunc.pm"
 2406 
 2407 
 2408 
 2409 #line 1060 "../../blib/lib/PDL/PP.pm"
 2410 
 2411 *oddpctover = \&PDL::oddpctover;
 2412 #line 2413 "Ufunc.pm"
 2413 
 2414 
 2415 
 2416 #line 934 "ufunc.pd"
 2417 
 2418 =head2 pct
 2419 
 2420 =for ref
 2421 
 2422 Return the specified percentile of all elements in an ndarray. The
 2423 specified percentile (p) must be between 0.0 and 1.0.  When the
 2424 specified percentile falls between data points, the result is interpolated.
 2425 
 2426 =for usage
 2427 
 2428  $x = pct($data, $pct);
 2429 
 2430 =cut
 2431 
 2432 *pct = \&PDL::pct;
 2433 sub PDL::pct {
 2434     my($x, $p) = @_;
 2435     $x->clump(-1)->pctover($p, my $tmp=PDL->nullcreate($x));
 2436     $tmp;
 2437 }
 2438 #line 2439 "Ufunc.pm"
 2439 
 2440 
 2441 
 2442 #line 934 "ufunc.pd"
 2443 
 2444 =head2 oddpct
 2445 
 2446 =for ref
 2447 
 2448 Return the specified percentile of all elements in an ndarray. The
 2449 specified percentile (p) must be between 0.0 and 1.0.  When the
 2450 specified percentile falls between data points, the nearest data value is the result.
 2451 
 2452 =for usage
 2453 
 2454  $x = oddpct($data, $pct);
 2455 
 2456 =cut
 2457 
 2458 *oddpct = \&PDL::oddpct;
 2459 sub PDL::oddpct {
 2460     my($x, $p) = @_;
 2461     $x->clump(-1)->oddpctover($p, my $tmp=PDL->nullcreate($x));
 2462     $tmp;
 2463 }
 2464 #line 2465 "Ufunc.pm"
 2465 
 2466 
 2467 
 2468 #line 1058 "../../blib/lib/PDL/PP.pm"
 2469 
 2470 
 2471 
 2472 =head2 qsort
 2473 
 2474 =for sig
 2475 
 2476   Signature: (a(n); [o]b(n))
 2477 
 2478 
 2479 =for ref
 2480 
 2481 Quicksort a vector into ascending order.
 2482 
 2483 =for example
 2484 
 2485  print qsort random(10);
 2486 
 2487 
 2488 
 2489 =for bad
 2490 
 2491 Bad values are moved to the end of the array:
 2492 
 2493  pdl> p $y
 2494  [42 47 98 BAD 22 96 74 41 79 76 96 BAD 32 76 25 59 BAD 96 32 BAD]
 2495  pdl> p qsort($y)
 2496  [22 25 32 32 41 42 47 59 74 76 76 79 96 96 96 98 BAD BAD BAD BAD]
 2497 
 2498 
 2499 =cut
 2500 #line 2501 "Ufunc.pm"
 2501 
 2502 
 2503 
 2504 #line 1060 "../../blib/lib/PDL/PP.pm"
 2505 
 2506 *qsort = \&PDL::qsort;
 2507 #line 2508 "Ufunc.pm"
 2508 
 2509 
 2510 
 2511 #line 1058 "../../blib/lib/PDL/PP.pm"
 2512 
 2513 
 2514 
 2515 =head2 qsorti
 2516 
 2517 =for sig
 2518 
 2519   Signature: (a(n); indx [o]indx(n))
 2520 
 2521 
 2522 =for ref
 2523 
 2524 Quicksort a vector and return index of elements in ascending order.
 2525 
 2526 =for example
 2527 
 2528  $ix = qsorti $x;
 2529  print $x->index($ix); # Sorted list
 2530 
 2531 
 2532 
 2533 =for bad
 2534 
 2535 Bad elements are moved to the end of the array:
 2536 
 2537  pdl> p $y
 2538  [42 47 98 BAD 22 96 74 41 79 76 96 BAD 32 76 25 59 BAD 96 32 BAD]
 2539  pdl> p $y->index( qsorti($y) )
 2540  [22 25 32 32 41 42 47 59 74 76 76 79 96 96 96 98 BAD BAD BAD BAD]
 2541 
 2542 
 2543 =cut
 2544 #line 2545 "Ufunc.pm"
 2545 
 2546 
 2547 
 2548 #line 1060 "../../blib/lib/PDL/PP.pm"
 2549 
 2550 *qsorti = \&PDL::qsorti;
 2551 #line 2552 "Ufunc.pm"
 2552 
 2553 
 2554 
 2555 #line 1058 "../../blib/lib/PDL/PP.pm"
 2556 
 2557 
 2558 
 2559 =head2 qsortvec
 2560 
 2561 =for sig
 2562 
 2563   Signature: (a(n,m); [o]b(n,m))
 2564 
 2565 
 2566 =for ref
 2567 
 2568 Sort a list of vectors lexicographically.
 2569 
 2570 The 0th dimension of the source ndarray is dimension in the vector;
 2571 the 1st dimension is list order.  Higher dimensions are broadcasted over.
 2572 
 2573 =for example
 2574 
 2575  print qsortvec pdl([[1,2],[0,500],[2,3],[4,2],[3,4],[3,5]]);
 2576  [
 2577   [  0 500]
 2578   [  1   2]
 2579   [  2   3]
 2580   [  3   4]
 2581   [  3   5]
 2582   [  4   2]
 2583  ]
 2584  
 2585 
 2586 
 2587 =for bad
 2588 
 2589 Vectors with bad components are moved to the end of the array:
 2590 
 2591   pdl> p $p = pdl("[0 0] [-100 0] [BAD 0] [100 0]")->qsortvec
 2592 
 2593   [
 2594    [-100    0]
 2595    [   0    0]
 2596    [ 100    0]
 2597    [ BAD    0]
 2598   ]
 2599 
 2600 
 2601 =cut
 2602 #line 2603 "Ufunc.pm"
 2603 
 2604 
 2605 
 2606 #line 1060 "../../blib/lib/PDL/PP.pm"
 2607 
 2608 *qsortvec = \&PDL::qsortvec;
 2609 #line 2610 "Ufunc.pm"
 2610 
 2611 
 2612 
 2613 #line 1058 "../../blib/lib/PDL/PP.pm"
 2614 
 2615 
 2616 
 2617 =head2 qsortveci
 2618 
 2619 =for sig
 2620 
 2621   Signature: (a(n,m); indx [o]indx(m))
 2622 
 2623 
 2624 =for ref
 2625 
 2626 Sort a list of vectors lexicographically, returning the indices of the
 2627 sorted vectors rather than the sorted list itself.
 2628 
 2629 As with C<qsortvec>, the input PDL should be an NxM array containing M
 2630 separate N-dimensional vectors.  The return value is an integer M-PDL 
 2631 containing the M-indices of original array rows, in sorted order.
 2632 
 2633 As with C<qsortvec>, the zeroth element of the vectors runs slowest in the
 2634 sorted list.  
 2635 
 2636 Additional dimensions are broadcasted over: each plane is sorted separately,
 2637 so qsortveci may be thought of as a collapse operator of sorts (groan).
 2638 
 2639 
 2640 
 2641 =for bad
 2642 
 2643 Vectors with bad components are moved to the end of the array as
 2644 for L</qsortvec>.
 2645 
 2646 
 2647 =cut
 2648 #line 2649 "Ufunc.pm"
 2649 
 2650 
 2651 
 2652 #line 1060 "../../blib/lib/PDL/PP.pm"
 2653 
 2654 *qsortveci = \&PDL::qsortveci;
 2655 #line 2656 "Ufunc.pm"
 2656 
 2657 
 2658 
 2659 
 2660 
 2661 #line 1182 "ufunc.pd"
 2662 
 2663 
 2664 =head1 AUTHOR
 2665 
 2666 Copyright (C) Tuomas J. Lukka 1997 (lukka@husc.harvard.edu).
 2667 Contributions by Christian Soeller (c.soeller@auckland.ac.nz)
 2668 and Karl Glazebrook (kgb@aaoepp.aao.gov.au).  All rights
 2669 reserved. There is no warranty. You are allowed to redistribute this
 2670 software / documentation under certain conditions. For details, see
 2671 the file COPYING in the PDL distribution. If this file is separated
 2672 from the PDL distribution, the copyright notice should be included in
 2673 the file.
 2674 
 2675 =cut
 2676 #line 2677 "Ufunc.pm"
 2677 
 2678 
 2679 
 2680 
 2681 # Exit with OK status
 2682 
 2683 1;