Ufunc.pm (PDL-2.074) | : | Ufunc.pm (PDL-2.075) | ||
---|---|---|---|---|

skipping to change at line 17 | skipping to change at line 17 | |||

our %EXPORT_TAGS = (Func=>\@EXPORT_OK); | our %EXPORT_TAGS = (Func=>\@EXPORT_OK); | |||

use PDL::Core; | use PDL::Core; | |||

use PDL::Exporter; | use PDL::Exporter; | |||

use DynaLoader; | use DynaLoader; | |||

our @ISA = ( 'PDL::Exporter','DynaLoader' ); | our @ISA = ( 'PDL::Exporter','DynaLoader' ); | |||

push @PDL::Core::PP, __PACKAGE__; | push @PDL::Core::PP, __PACKAGE__; | |||

bootstrap PDL::Ufunc ; | bootstrap PDL::Ufunc ; | |||

#line 10 "ufunc.pd" | #line 9 "ufunc.pd" | |||

use strict; | use strict; | |||

use warnings; | use warnings; | |||

=head1 NAME | =head1 NAME | |||

PDL::Ufunc - primitive ufunc operations for pdl | PDL::Ufunc - primitive ufunc operations for pdl | |||

=head1 DESCRIPTION | =head1 DESCRIPTION | |||

This module provides some primitive and useful functions defined | This module provides some primitive and useful functions defined | |||

skipping to change at line 46 | skipping to change at line 47 | |||

to many of the functions in this module. | to many of the functions in this module. | |||

=head1 SYNOPSIS | =head1 SYNOPSIS | |||

use PDL::Ufunc; | use PDL::Ufunc; | |||

=cut | =cut | |||

use PDL::Slices; | use PDL::Slices; | |||

use Carp; | use Carp; | |||

#line 54 "Ufunc.pm" | #line 55 "Ufunc.pm" | |||

=head1 FUNCTIONS | =head1 FUNCTIONS | |||

=cut | =cut | |||

#line 1059 "../../blib/lib/PDL/PP.pm" | #line 1058 "../../blib/lib/PDL/PP.pm" | |||

=head2 prodover | =head2 prodover | |||

=for sig | =for sig | |||

Signature: (a(n); int+ [o]b()) | Signature: (a(n); int+ [o]b()) | |||

=for ref | =for ref | |||

Project via product to N-1 dimensions | Project via product to N-1 dimensions | |||

skipping to change at line 84 | skipping to change at line 85 | |||

=for example | =for example | |||

$spectrum = prodover $image->transpose | $spectrum = prodover $image->transpose | |||

=for bad | =for bad | |||

prodover processes bad values. | prodover processes bad values. | |||

It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays. | It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays. | |||

=cut | =cut | |||

#line 107 "Ufunc.pm" | #line 109 "Ufunc.pm" | |||

#line 1060 "../../blib/lib/PDL/PP.pm" | ||||

#line 1061 "../../blib/lib/PDL/PP.pm" | ||||

*prodover = \&PDL::prodover; | *prodover = \&PDL::prodover; | |||

#line 113 "Ufunc.pm" | #line 116 "Ufunc.pm" | |||

#line 1059 "../../blib/lib/PDL/PP.pm" | #line 1058 "../../blib/lib/PDL/PP.pm" | |||

=head2 cprodover | =head2 cprodover | |||

=for sig | =for sig | |||

Signature: (a(n); cdouble [o]b()) | Signature: (a(n); cdouble [o]b()) | |||

=for ref | =for ref | |||

Project via product to N-1 dimensions | Project via product to N-1 dimensions | |||

skipping to change at line 125 | skipping to change at line 127 | |||

Unlike L</prodover>, the calculations are performed in complex double | Unlike L</prodover>, the calculations are performed in complex double | |||

precision. | precision. | |||

=for bad | =for bad | |||

cprodover processes bad values. | cprodover processes bad values. | |||

It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays. | ||||

=cut | =cut | |||

#line 157 "Ufunc.pm" | #line 161 "Ufunc.pm" | |||

#line 1060 "../../blib/lib/PDL/PP.pm" | ||||

#line 1061 "../../blib/lib/PDL/PP.pm" | ||||

*cprodover = \&PDL::cprodover; | *cprodover = \&PDL::cprodover; | |||

#line 163 "Ufunc.pm" | #line 168 "Ufunc.pm" | |||

#line 1059 "../../blib/lib/PDL/PP.pm" | #line 1058 "../../blib/lib/PDL/PP.pm" | |||

=head2 dprodover | =head2 dprodover | |||

=for sig | =for sig | |||

Signature: (a(n); double [o]b()) | Signature: (a(n); double [o]b()) | |||

=for ref | =for ref | |||

Project via product to N-1 dimensions | Project via product to N-1 dimensions | |||

skipping to change at line 165 | skipping to change at line 168 | |||

$spectrum = dprodover $image->transpose | $spectrum = dprodover $image->transpose | |||

Unlike L</prodover>, the calculations are performed in double precision. | Unlike L</prodover>, the calculations are performed in double precision. | |||

=for bad | =for bad | |||

dprodover processes bad values. | dprodover processes bad values. | |||

=cut | =cut | |||

#line 206 "Ufunc.pm" | #line 212 "Ufunc.pm" | |||

#line 1060 "../../blib/lib/PDL/PP.pm" | ||||

#line 1061 "../../blib/lib/PDL/PP.pm" | ||||

*dprodover = \&PDL::dprodover; | *dprodover = \&PDL::dprodover; | |||

#line 212 "Ufunc.pm" | #line 219 "Ufunc.pm" | |||

#line 1059 "../../blib/lib/PDL/PP.pm" | #line 1058 "../../blib/lib/PDL/PP.pm" | |||

=head2 cumuprodover | =head2 cumuprodover | |||

=for sig | =for sig | |||

Signature: (a(n); int+ [o]b(n)) | Signature: (a(n); int+ [o]b(n)) | |||

=for ref | =for ref | |||

Cumulative product | Cumulative product | |||

skipping to change at line 206 | skipping to change at line 210 | |||

=for example | =for example | |||

$spectrum = cumuprodover $image->transpose | $spectrum = cumuprodover $image->transpose | |||

=for bad | =for bad | |||

cumuprodover processes bad values. | cumuprodover processes bad values. | |||

=cut | =cut | |||

#line 258 "Ufunc.pm" | #line 266 "Ufunc.pm" | |||

#line 1060 "../../blib/lib/PDL/PP.pm" | ||||

#line 1061 "../../blib/lib/PDL/PP.pm" | ||||

*cumuprodover = \&PDL::cumuprodover; | *cumuprodover = \&PDL::cumuprodover; | |||

#line 264 "Ufunc.pm" | #line 273 "Ufunc.pm" | |||

#line 1059 "../../blib/lib/PDL/PP.pm" | #line 1058 "../../blib/lib/PDL/PP.pm" | |||

=head2 dcumuprodover | =head2 dcumuprodover | |||

=for sig | =for sig | |||

Signature: (a(n); double [o]b(n)) | Signature: (a(n); double [o]b(n)) | |||

=for ref | =for ref | |||

Cumulative product | Cumulative product | |||

skipping to change at line 249 | skipping to change at line 254 | |||

$spectrum = dcumuprodover $image->transpose | $spectrum = dcumuprodover $image->transpose | |||

Unlike L</cumuprodover>, the calculations are performed in double precision. | Unlike L</cumuprodover>, the calculations are performed in double precision. | |||

=for bad | =for bad | |||

dcumuprodover processes bad values. | dcumuprodover processes bad values. | |||

=cut | =cut | |||

#line 310 "Ufunc.pm" | #line 320 "Ufunc.pm" | |||

#line 1060 "../../blib/lib/PDL/PP.pm" | ||||

#line 1061 "../../blib/lib/PDL/PP.pm" | ||||

*dcumuprodover = \&PDL::dcumuprodover; | *dcumuprodover = \&PDL::dcumuprodover; | |||

#line 316 "Ufunc.pm" | #line 327 "Ufunc.pm" | |||

#line 1059 "../../blib/lib/PDL/PP.pm" | #line 1058 "../../blib/lib/PDL/PP.pm" | |||

=head2 sumover | =head2 sumover | |||

=for sig | =for sig | |||

Signature: (a(n); int+ [o]b()) | Signature: (a(n); int+ [o]b()) | |||

=for ref | =for ref | |||

Project via sum to N-1 dimensions | Project via sum to N-1 dimensions | |||

skipping to change at line 287 | skipping to change at line 293 | |||

=for example | =for example | |||

$spectrum = sumover $image->transpose | $spectrum = sumover $image->transpose | |||

=for bad | =for bad | |||

sumover processes bad values. | sumover processes bad values. | |||

=cut | =cut | |||

#line 359 "Ufunc.pm" | #line 371 "Ufunc.pm" | |||

#line 1060 "../../blib/lib/PDL/PP.pm" | ||||

#line 1061 "../../blib/lib/PDL/PP.pm" | ||||

*sumover = \&PDL::sumover; | *sumover = \&PDL::sumover; | |||

#line 365 "Ufunc.pm" | #line 378 "Ufunc.pm" | |||

#line 1059 "../../blib/lib/PDL/PP.pm" | #line 1058 "../../blib/lib/PDL/PP.pm" | |||

=head2 csumover | =head2 csumover | |||

=for sig | =for sig | |||

Signature: (a(n); cdouble [o]b()) | Signature: (a(n); cdouble [o]b()) | |||

=for ref | =for ref | |||

Project via sum to N-1 dimensions | Project via sum to N-1 dimensions | |||

skipping to change at line 328 | skipping to change at line 335 | |||

Unlike L</sumover>, the calculations are performed in complex double | Unlike L</sumover>, the calculations are performed in complex double | |||

precision. | precision. | |||

=for bad | =for bad | |||

csumover processes bad values. | csumover processes bad values. | |||

=cut | =cut | |||

#line 409 "Ufunc.pm" | #line 423 "Ufunc.pm" | |||

#line 1060 "../../blib/lib/PDL/PP.pm" | ||||

#line 1061 "../../blib/lib/PDL/PP.pm" | ||||

*csumover = \&PDL::csumover; | *csumover = \&PDL::csumover; | |||

#line 415 "Ufunc.pm" | #line 430 "Ufunc.pm" | |||

#line 1059 "../../blib/lib/PDL/PP.pm" | #line 1058 "../../blib/lib/PDL/PP.pm" | |||

=head2 dsumover | =head2 dsumover | |||

=for sig | =for sig | |||

Signature: (a(n); double [o]b()) | Signature: (a(n); double [o]b()) | |||

=for ref | =for ref | |||

Project via sum to N-1 dimensions | Project via sum to N-1 dimensions | |||

skipping to change at line 368 | skipping to change at line 376 | |||

$spectrum = dsumover $image->transpose | $spectrum = dsumover $image->transpose | |||

Unlike L</sumover>, the calculations are performed in double precision. | Unlike L</sumover>, the calculations are performed in double precision. | |||

=for bad | =for bad | |||

dsumover processes bad values. | dsumover processes bad values. | |||

=cut | =cut | |||

#line 458 "Ufunc.pm" | #line 474 "Ufunc.pm" | |||

#line 1060 "../../blib/lib/PDL/PP.pm" | ||||

#line 1061 "../../blib/lib/PDL/PP.pm" | ||||

*dsumover = \&PDL::dsumover; | *dsumover = \&PDL::dsumover; | |||

#line 464 "Ufunc.pm" | #line 481 "Ufunc.pm" | |||

#line 1059 "../../blib/lib/PDL/PP.pm" | #line 1058 "../../blib/lib/PDL/PP.pm" | |||

=head2 cumusumover | =head2 cumusumover | |||

=for sig | =for sig | |||

Signature: (a(n); int+ [o]b(n)) | Signature: (a(n); int+ [o]b(n)) | |||

=for ref | =for ref | |||

Cumulative sum | Cumulative sum | |||

skipping to change at line 409 | skipping to change at line 418 | |||

=for example | =for example | |||

$spectrum = cumusumover $image->transpose | $spectrum = cumusumover $image->transpose | |||

=for bad | =for bad | |||

cumusumover processes bad values. | cumusumover processes bad values. | |||

=cut | =cut | |||

#line 510 "Ufunc.pm" | #line 528 "Ufunc.pm" | |||

#line 1060 "../../blib/lib/PDL/PP.pm" | ||||

#line 1061 "../../blib/lib/PDL/PP.pm" | ||||

*cumusumover = \&PDL::cumusumover; | *cumusumover = \&PDL::cumusumover; | |||

#line 516 "Ufunc.pm" | #line 535 "Ufunc.pm" | |||

#line 1059 "../../blib/lib/PDL/PP.pm" | #line 1058 "../../blib/lib/PDL/PP.pm" | |||

=head2 dcumusumover | =head2 dcumusumover | |||

=for sig | =for sig | |||

Signature: (a(n); double [o]b(n)) | Signature: (a(n); double [o]b(n)) | |||

=for ref | =for ref | |||

Cumulative sum | Cumulative sum | |||

skipping to change at line 452 | skipping to change at line 462 | |||

$spectrum = dcumusumover $image->transpose | $spectrum = dcumusumover $image->transpose | |||

Unlike L</cumusumover>, the calculations are performed in double precision. | Unlike L</cumusumover>, the calculations are performed in double precision. | |||

=for bad | =for bad | |||

dcumusumover processes bad values. | dcumusumover processes bad values. | |||

=cut | =cut | |||

#line 562 "Ufunc.pm" | #line 582 "Ufunc.pm" | |||

#line 1060 "../../blib/lib/PDL/PP.pm" | ||||

#line 1061 "../../blib/lib/PDL/PP.pm" | ||||

*dcumusumover = \&PDL::dcumusumover; | *dcumusumover = \&PDL::dcumusumover; | |||

#line 568 "Ufunc.pm" | #line 589 "Ufunc.pm" | |||

#line 1059 "../../blib/lib/PDL/PP.pm" | #line 1058 "../../blib/lib/PDL/PP.pm" | |||

=head2 andover | =head2 andover | |||

=for sig | =for sig | |||

Signature: (a(n); int+ [o]b()) | Signature: (a(n); int+ [o]b()) | |||

=for ref | =for ref | |||

Project via and to N-1 dimensions | Project via and to N-1 dimensions | |||

skipping to change at line 491 | skipping to change at line 502 | |||

$spectrum = andover $image->transpose | $spectrum = andover $image->transpose | |||

=for bad | =for bad | |||

If C<a()> contains only bad data (and its bad flag is set), | If C<a()> contains only bad data (and its bad flag is set), | |||

C<b()> is set bad. Otherwise C<b()> will have its bad flag cleared, | C<b()> is set bad. Otherwise C<b()> will have its bad flag cleared, | |||

as it will not contain any bad values. | as it will not contain any bad values. | |||

=cut | =cut | |||

#line 611 "Ufunc.pm" | #line 633 "Ufunc.pm" | |||

#line 1060 "../../blib/lib/PDL/PP.pm" | ||||

#line 1061 "../../blib/lib/PDL/PP.pm" | ||||

*andover = \&PDL::andover; | *andover = \&PDL::andover; | |||

#line 617 "Ufunc.pm" | #line 640 "Ufunc.pm" | |||

#line 1059 "../../blib/lib/PDL/PP.pm" | #line 1058 "../../blib/lib/PDL/PP.pm" | |||

=head2 bandover | =head2 bandover | |||

=for sig | =for sig | |||

Signature: (a(n); [o]b()) | Signature: (a(n); [o]b()) | |||

=for ref | =for ref | |||

Project via bitwise and to N-1 dimensions | Project via bitwise and to N-1 dimensions | |||

skipping to change at line 530 | skipping to change at line 542 | |||

$spectrum = bandover $image->transpose | $spectrum = bandover $image->transpose | |||

=for bad | =for bad | |||

If C<a()> contains only bad data (and its bad flag is set), | If C<a()> contains only bad data (and its bad flag is set), | |||

C<b()> is set bad. Otherwise C<b()> will have its bad flag cleared, | C<b()> is set bad. Otherwise C<b()> will have its bad flag cleared, | |||

as it will not contain any bad values. | as it will not contain any bad values. | |||

=cut | =cut | |||

#line 660 "Ufunc.pm" | #line 684 "Ufunc.pm" | |||

#line 1060 "../../blib/lib/PDL/PP.pm" | ||||

#line 1061 "../../blib/lib/PDL/PP.pm" | ||||

*bandover = \&PDL::bandover; | *bandover = \&PDL::bandover; | |||

#line 666 "Ufunc.pm" | #line 691 "Ufunc.pm" | |||

#line 1059 "../../blib/lib/PDL/PP.pm" | #line 1058 "../../blib/lib/PDL/PP.pm" | |||

=head2 borover | =head2 borover | |||

=for sig | =for sig | |||

Signature: (a(n); [o]b()) | Signature: (a(n); [o]b()) | |||

=for ref | =for ref | |||

Project via bitwise or to N-1 dimensions | Project via bitwise or to N-1 dimensions | |||

skipping to change at line 569 | skipping to change at line 582 | |||

$spectrum = borover $image->transpose | $spectrum = borover $image->transpose | |||

=for bad | =for bad | |||

If C<a()> contains only bad data (and its bad flag is set), | If C<a()> contains only bad data (and its bad flag is set), | |||

C<b()> is set bad. Otherwise C<b()> will have its bad flag cleared, | C<b()> is set bad. Otherwise C<b()> will have its bad flag cleared, | |||

as it will not contain any bad values. | as it will not contain any bad values. | |||

=cut | =cut | |||

#line 709 "Ufunc.pm" | #line 735 "Ufunc.pm" | |||

#line 1060 "../../blib/lib/PDL/PP.pm" | ||||

#line 1061 "../../blib/lib/PDL/PP.pm" | ||||

*borover = \&PDL::borover; | *borover = \&PDL::borover; | |||

#line 715 "Ufunc.pm" | #line 742 "Ufunc.pm" | |||

#line 1059 "../../blib/lib/PDL/PP.pm" | #line 1058 "../../blib/lib/PDL/PP.pm" | |||

=head2 orover | =head2 orover | |||

=for sig | =for sig | |||

Signature: (a(n); int+ [o]b()) | Signature: (a(n); int+ [o]b()) | |||

=for ref | =for ref | |||

Project via or to N-1 dimensions | Project via or to N-1 dimensions | |||

skipping to change at line 608 | skipping to change at line 622 | |||

$spectrum = orover $image->transpose | $spectrum = orover $image->transpose | |||

=for bad | =for bad | |||

If C<a()> contains only bad data (and its bad flag is set), | If C<a()> contains only bad data (and its bad flag is set), | |||

C<b()> is set bad. Otherwise C<b()> will have its bad flag cleared, | C<b()> is set bad. Otherwise C<b()> will have its bad flag cleared, | |||

as it will not contain any bad values. | as it will not contain any bad values. | |||

=cut | =cut | |||

#line 758 "Ufunc.pm" | #line 786 "Ufunc.pm" | |||

#line 1060 "../../blib/lib/PDL/PP.pm" | ||||

#line 1061 "../../blib/lib/PDL/PP.pm" | ||||

*orover = \&PDL::orover; | *orover = \&PDL::orover; | |||

#line 764 "Ufunc.pm" | #line 793 "Ufunc.pm" | |||

#line 1059 "../../blib/lib/PDL/PP.pm" | #line 1058 "../../blib/lib/PDL/PP.pm" | |||

=head2 zcover | =head2 zcover | |||

=for sig | =for sig | |||

Signature: (a(n); int+ [o]b()) | Signature: (a(n); int+ [o]b()) | |||

=for ref | =for ref | |||

Project via == 0 to N-1 dimensions | Project via == 0 to N-1 dimensions | |||

skipping to change at line 647 | skipping to change at line 662 | |||

$spectrum = zcover $image->transpose | $spectrum = zcover $image->transpose | |||

=for bad | =for bad | |||

If C<a()> contains only bad data (and its bad flag is set), | If C<a()> contains only bad data (and its bad flag is set), | |||

C<b()> is set bad. Otherwise C<b()> will have its bad flag cleared, | C<b()> is set bad. Otherwise C<b()> will have its bad flag cleared, | |||

as it will not contain any bad values. | as it will not contain any bad values. | |||

=cut | =cut | |||

#line 807 "Ufunc.pm" | #line 837 "Ufunc.pm" | |||

#line 1060 "../../blib/lib/PDL/PP.pm" | ||||

#line 1061 "../../blib/lib/PDL/PP.pm" | ||||

*zcover = \&PDL::zcover; | *zcover = \&PDL::zcover; | |||

#line 813 "Ufunc.pm" | #line 844 "Ufunc.pm" | |||

#line 1059 "../../blib/lib/PDL/PP.pm" | #line 1058 "../../blib/lib/PDL/PP.pm" | |||

=head2 intover | =head2 intover | |||

=for sig | =for sig | |||

Signature: (a(n); float+ [o]b()) | Signature: (a(n); float+ [o]b()) | |||

=for ref | =for ref | |||

Project via integral to N-1 dimensions | Project via integral to N-1 dimensions | |||

skipping to change at line 695 | skipping to change at line 711 | |||

integrals between the end points assuming the pdl gives values just at | integrals between the end points assuming the pdl gives values just at | |||

these centres: for such `functions', sumover is correct to C<O(h)>, but | these centres: for such `functions', sumover is correct to C<O(h)>, but | |||

is the natural (and correct) choice for binned data, of course. | is the natural (and correct) choice for binned data, of course. | |||

=for bad | =for bad | |||

intover ignores the bad-value flag of the input ndarrays. | intover ignores the bad-value flag of the input ndarrays. | |||

=cut | =cut | |||

#line 865 "Ufunc.pm" | #line 897 "Ufunc.pm" | |||

#line 1060 "../../blib/lib/PDL/PP.pm" | ||||

#line 1061 "../../blib/lib/PDL/PP.pm" | ||||

*intover = \&PDL::intover; | *intover = \&PDL::intover; | |||

#line 871 "Ufunc.pm" | #line 904 "Ufunc.pm" | |||

#line 1059 "../../blib/lib/PDL/PP.pm" | #line 1058 "../../blib/lib/PDL/PP.pm" | |||

=head2 average | =head2 average | |||

=for sig | =for sig | |||

Signature: (a(n); int+ [o]b()) | Signature: (a(n); int+ [o]b()) | |||

=for ref | =for ref | |||

Project via average to N-1 dimensions | Project via average to N-1 dimensions | |||

skipping to change at line 733 | skipping to change at line 750 | |||

=for example | =for example | |||

$spectrum = average $image->transpose | $spectrum = average $image->transpose | |||

=for bad | =for bad | |||

average processes bad values. | average processes bad values. | |||

=cut | =cut | |||

#line 914 "Ufunc.pm" | #line 948 "Ufunc.pm" | |||

#line 1060 "../../blib/lib/PDL/PP.pm" | ||||

#line 1061 "../../blib/lib/PDL/PP.pm" | ||||

*average = \&PDL::average; | *average = \&PDL::average; | |||

#line 920 "Ufunc.pm" | #line 955 "Ufunc.pm" | |||

#line 309 "ufunc.pd" | ||||

#line 317 "ufunc.pd" | ||||

=head2 avgover | =head2 avgover | |||

=for ref | =for ref | |||

Synonym for average. | Synonym for average. | |||

=cut | =cut | |||

*PDL::avgover = *avgover = \&PDL::average; | *PDL::avgover = *avgover = \&PDL::average; | |||

#line 934 "Ufunc.pm" | #line 970 "Ufunc.pm" | |||

#line 1059 "../../blib/lib/PDL/PP.pm" | #line 1058 "../../blib/lib/PDL/PP.pm" | |||

=head2 caverage | =head2 caverage | |||

=for sig | =for sig | |||

Signature: (a(n); cdouble [o]b()) | Signature: (a(n); cdouble [o]b()) | |||

=for ref | =for ref | |||

Project via average to N-1 dimensions | Project via average to N-1 dimensions | |||

skipping to change at line 786 | skipping to change at line 805 | |||

Unlike L<average|/average>, the calculation is performed in complex double | Unlike L<average|/average>, the calculation is performed in complex double | |||

precision. | precision. | |||

=for bad | =for bad | |||

caverage processes bad values. | caverage processes bad values. | |||

=cut | =cut | |||

#line 978 "Ufunc.pm" | #line 1015 "Ufunc.pm" | |||

#line 1060 "../../blib/lib/PDL/PP.pm" | ||||

#line 1061 "../../blib/lib/PDL/PP.pm" | ||||

*caverage = \&PDL::caverage; | *caverage = \&PDL::caverage; | |||

#line 984 "Ufunc.pm" | #line 1022 "Ufunc.pm" | |||

#line 309 "ufunc.pd" | ||||

#line 317 "ufunc.pd" | ||||

=head2 cavgover | =head2 cavgover | |||

=for ref | =for ref | |||

Synonym for caverage. | Synonym for caverage. | |||

=cut | =cut | |||

*PDL::cavgover = *cavgover = \&PDL::caverage; | *PDL::cavgover = *cavgover = \&PDL::caverage; | |||

#line 998 "Ufunc.pm" | #line 1037 "Ufunc.pm" | |||

#line 1059 "../../blib/lib/PDL/PP.pm" | #line 1058 "../../blib/lib/PDL/PP.pm" | |||

=head2 daverage | =head2 daverage | |||

=for sig | =for sig | |||

Signature: (a(n); double [o]b()) | Signature: (a(n); double [o]b()) | |||

=for ref | =for ref | |||

Project via average to N-1 dimensions | Project via average to N-1 dimensions | |||

skipping to change at line 839 | skipping to change at line 860 | |||

Unlike L<average|/average>, the calculation is performed in double | Unlike L<average|/average>, the calculation is performed in double | |||

precision. | precision. | |||

=for bad | =for bad | |||

daverage processes bad values. | daverage processes bad values. | |||

=cut | =cut | |||

#line 1042 "Ufunc.pm" | #line 1082 "Ufunc.pm" | |||

#line 1060 "../../blib/lib/PDL/PP.pm" | ||||

#line 1061 "../../blib/lib/PDL/PP.pm" | ||||

*daverage = \&PDL::daverage; | *daverage = \&PDL::daverage; | |||

#line 1048 "Ufunc.pm" | #line 1089 "Ufunc.pm" | |||

#line 309 "ufunc.pd" | ||||

#line 317 "ufunc.pd" | ||||

=head2 davgover | =head2 davgover | |||

=for ref | =for ref | |||

Synonym for daverage. | Synonym for daverage. | |||

=cut | =cut | |||

*PDL::davgover = *davgover = \&PDL::daverage; | *PDL::davgover = *davgover = \&PDL::daverage; | |||

#line 1062 "Ufunc.pm" | #line 1104 "Ufunc.pm" | |||

#line 1059 "../../blib/lib/PDL/PP.pm" | #line 1058 "../../blib/lib/PDL/PP.pm" | |||

=head2 minimum | =head2 minimum | |||

=for sig | =for sig | |||

Signature: (a(n); [o]c()) | Signature: (a(n); [o]c()) | |||

=for ref | =for ref | |||

Project via minimum to N-1 dimensions | Project via minimum to N-1 dimensions | |||

skipping to change at line 893 | skipping to change at line 916 | |||

=for bad | =for bad | |||

Output is set bad if all elements of the input are bad, | Output is set bad if all elements of the input are bad, | |||

otherwise the bad flag is cleared for the output ndarray. | otherwise the bad flag is cleared for the output ndarray. | |||

Note that C<NaNs> are considered to be valid values; | Note that C<NaNs> are considered to be valid values; | |||

see L<isfinite|PDL::Math/isfinite> and L<badmask|PDL::Math/badmask> | see L<isfinite|PDL::Math/isfinite> and L<badmask|PDL::Math/badmask> | |||

for ways of masking NaNs. | for ways of masking NaNs. | |||

=cut | =cut | |||

#line 1109 "Ufunc.pm" | #line 1152 "Ufunc.pm" | |||

#line 1060 "../../blib/lib/PDL/PP.pm" | ||||

#line 1061 "../../blib/lib/PDL/PP.pm" | ||||

*minimum = \&PDL::minimum; | *minimum = \&PDL::minimum; | |||

#line 1115 "Ufunc.pm" | #line 1159 "Ufunc.pm" | |||

#line 309 "ufunc.pd" | ||||

#line 317 "ufunc.pd" | ||||

=head2 minover | =head2 minover | |||

=for ref | =for ref | |||

Synonym for minimum. | Synonym for minimum. | |||

=cut | =cut | |||

*PDL::minover = *minover = \&PDL::minimum; | *PDL::minover = *minover = \&PDL::minimum; | |||

#line 1129 "Ufunc.pm" | #line 1174 "Ufunc.pm" | |||

#line 1059 "../../blib/lib/PDL/PP.pm" | #line 1058 "../../blib/lib/PDL/PP.pm" | |||

=head2 minimum_ind | =head2 minimum_ind | |||

=for sig | =for sig | |||

Signature: (a(n); indx [o] c()) | Signature: (a(n); indx [o] c()) | |||

=for ref | =for ref | |||

Like minimum but returns the index rather than the value | Like minimum but returns the index rather than the value | |||

=for bad | =for bad | |||

Output is set bad if all elements of the input are bad, | Output is set bad if all elements of the input are bad, | |||

otherwise the bad flag is cleared for the output ndarray. | otherwise the bad flag is cleared for the output ndarray. | |||

=cut | =cut | |||

#line 1152 "Ufunc.pm" | #line 1198 "Ufunc.pm" | |||

#line 1060 "../../blib/lib/PDL/PP.pm" | ||||

#line 1061 "../../blib/lib/PDL/PP.pm" | ||||

*minimum_ind = \&PDL::minimum_ind; | *minimum_ind = \&PDL::minimum_ind; | |||

#line 1158 "Ufunc.pm" | #line 1205 "Ufunc.pm" | |||

#line 309 "ufunc.pd" | ||||

#line 317 "ufunc.pd" | ||||

=head2 minover_ind | =head2 minover_ind | |||

=for ref | =for ref | |||

Synonym for minimum_ind. | Synonym for minimum_ind. | |||

=cut | =cut | |||

*PDL::minover_ind = *minover_ind = \&PDL::minimum_ind; | *PDL::minover_ind = *minover_ind = \&PDL::minimum_ind; | |||

#line 1172 "Ufunc.pm" | #line 1220 "Ufunc.pm" | |||

#line 1059 "../../blib/lib/PDL/PP.pm" | #line 1058 "../../blib/lib/PDL/PP.pm" | |||

=head2 minimum_n_ind | =head2 minimum_n_ind | |||

=for sig | =for sig | |||

Signature: (a(n); indx [o]c(m)) | Signature: (a(n); indx [o]c(m)) | |||

=for ref | =for ref | |||

Returns the index of C<m> minimum elements | Returns the index of C<m> minimum elements | |||

=for bad | =for bad | |||

Not yet been converted to ignore bad values | Not yet been converted to ignore bad values | |||

=cut | =cut | |||

#line 1194 "Ufunc.pm" | #line 1243 "Ufunc.pm" | |||

#line 1060 "../../blib/lib/PDL/PP.pm" | ||||

#line 1061 "../../blib/lib/PDL/PP.pm" | ||||

*minimum_n_ind = \&PDL::minimum_n_ind; | *minimum_n_ind = \&PDL::minimum_n_ind; | |||

#line 1200 "Ufunc.pm" | #line 1250 "Ufunc.pm" | |||

#line 309 "ufunc.pd" | ||||

#line 317 "ufunc.pd" | ||||

=head2 minover_n_ind | =head2 minover_n_ind | |||

=for ref | =for ref | |||

Synonym for minimum_n_ind. | Synonym for minimum_n_ind. | |||

=cut | =cut | |||

*PDL::minover_n_ind = *minover_n_ind = \&PDL::minimum_n_ind; | *PDL::minover_n_ind = *minover_n_ind = \&PDL::minimum_n_ind; | |||

#line 1214 "Ufunc.pm" | #line 1265 "Ufunc.pm" | |||

#line 1059 "../../blib/lib/PDL/PP.pm" | #line 1058 "../../blib/lib/PDL/PP.pm" | |||

=head2 maximum | =head2 maximum | |||

=for sig | =for sig | |||

Signature: (a(n); [o]c()) | Signature: (a(n); [o]c()) | |||

=for ref | =for ref | |||

Project via maximum to N-1 dimensions | Project via maximum to N-1 dimensions | |||

skipping to change at line 1018 | skipping to change at line 1047 | |||

=for bad | =for bad | |||

Output is set bad if all elements of the input are bad, | Output is set bad if all elements of the input are bad, | |||

otherwise the bad flag is cleared for the output ndarray. | otherwise the bad flag is cleared for the output ndarray. | |||

Note that C<NaNs> are considered to be valid values; | Note that C<NaNs> are considered to be valid values; | |||

see L<isfinite|PDL::Math/isfinite> and L<badmask|PDL::Math/badmask> | see L<isfinite|PDL::Math/isfinite> and L<badmask|PDL::Math/badmask> | |||

for ways of masking NaNs. | for ways of masking NaNs. | |||

=cut | =cut | |||

#line 1261 "Ufunc.pm" | #line 1313 "Ufunc.pm" | |||

#line 1060 "../../blib/lib/PDL/PP.pm" | ||||

#line 1061 "../../blib/lib/PDL/PP.pm" | ||||

*maximum = \&PDL::maximum; | *maximum = \&PDL::maximum; | |||

#line 1267 "Ufunc.pm" | #line 1320 "Ufunc.pm" | |||

#line 309 "ufunc.pd" | ||||

#line 317 "ufunc.pd" | ||||

=head2 maxover | =head2 maxover | |||

=for ref | =for ref | |||

Synonym for maximum. | Synonym for maximum. | |||

=cut | =cut | |||

*PDL::maxover = *maxover = \&PDL::maximum; | *PDL::maxover = *maxover = \&PDL::maximum; | |||

#line 1281 "Ufunc.pm" | #line 1335 "Ufunc.pm" | |||

#line 1059 "../../blib/lib/PDL/PP.pm" | #line 1058 "../../blib/lib/PDL/PP.pm" | |||

=head2 maximum_ind | =head2 maximum_ind | |||

=for sig | =for sig | |||

Signature: (a(n); indx [o] c()) | Signature: (a(n); indx [o] c()) | |||

=for ref | =for ref | |||

Like maximum but returns the index rather than the value | Like maximum but returns the index rather than the value | |||

=for bad | =for bad | |||

Output is set bad if all elements of the input are bad, | Output is set bad if all elements of the input are bad, | |||

otherwise the bad flag is cleared for the output ndarray. | otherwise the bad flag is cleared for the output ndarray. | |||

=cut | =cut | |||

#line 1304 "Ufunc.pm" | #line 1359 "Ufunc.pm" | |||

#line 1060 "../../blib/lib/PDL/PP.pm" | ||||

#line 1061 "../../blib/lib/PDL/PP.pm" | ||||

*maximum_ind = \&PDL::maximum_ind; | *maximum_ind = \&PDL::maximum_ind; | |||

#line 1310 "Ufunc.pm" | #line 1366 "Ufunc.pm" | |||

#line 309 "ufunc.pd" | ||||

#line 317 "ufunc.pd" | ||||

=head2 maxover_ind | =head2 maxover_ind | |||

=for ref | =for ref | |||

Synonym for maximum_ind. | Synonym for maximum_ind. | |||

=cut | =cut | |||

*PDL::maxover_ind = *maxover_ind = \&PDL::maximum_ind; | *PDL::maxover_ind = *maxover_ind = \&PDL::maximum_ind; | |||

#line 1324 "Ufunc.pm" | #line 1381 "Ufunc.pm" | |||

#line 1059 "../../blib/lib/PDL/PP.pm" | #line 1058 "../../blib/lib/PDL/PP.pm" | |||

=head2 maximum_n_ind | =head2 maximum_n_ind | |||

=for sig | =for sig | |||

Signature: (a(n); indx [o]c(m)) | Signature: (a(n); indx [o]c(m)) | |||

=for ref | =for ref | |||

Returns the index of C<m> maximum elements | Returns the index of C<m> maximum elements | |||

=for bad | =for bad | |||

Not yet been converted to ignore bad values | Not yet been converted to ignore bad values | |||

=cut | =cut | |||

#line 1346 "Ufunc.pm" | #line 1404 "Ufunc.pm" | |||

#line 1060 "../../blib/lib/PDL/PP.pm" | ||||

#line 1061 "../../blib/lib/PDL/PP.pm" | ||||

*maximum_n_ind = \&PDL::maximum_n_ind; | *maximum_n_ind = \&PDL::maximum_n_ind; | |||

#line 1352 "Ufunc.pm" | #line 1411 "Ufunc.pm" | |||

#line 309 "ufunc.pd" | ||||

#line 317 "ufunc.pd" | ||||

=head2 maxover_n_ind | =head2 maxover_n_ind | |||

=for ref | =for ref | |||

Synonym for maximum_n_ind. | Synonym for maximum_n_ind. | |||

=cut | =cut | |||

*PDL::maxover_n_ind = *maxover_n_ind = \&PDL::maximum_n_ind; | *PDL::maxover_n_ind = *maxover_n_ind = \&PDL::maximum_n_ind; | |||

#line 1366 "Ufunc.pm" | #line 1426 "Ufunc.pm" | |||

#line 1059 "../../blib/lib/PDL/PP.pm" | #line 1058 "../../blib/lib/PDL/PP.pm" | |||

=head2 minmaximum | =head2 minmaximum | |||

=for sig | =for sig | |||

Signature: (a(n); [o]cmin(); [o] cmax(); indx [o]cmin_ind(); indx [o]cmax_ind( )) | Signature: (a(n); [o]cmin(); [o] cmax(); indx [o]cmin_ind(); indx [o]cmax_ind( )) | |||

=for ref | =for ref | |||

Find minimum and maximum and their indices for a given ndarray; | Find minimum and maximum and their indices for a given ndarray; | |||

skipping to change at line 1136 | skipping to change at line 1171 | |||

See also L</minmax>, which clumps the ndarray together. | See also L</minmax>, which clumps the ndarray together. | |||

=for bad | =for bad | |||

If C<a()> contains only bad data, then the output ndarrays will | If C<a()> contains only bad data, then the output ndarrays will | |||

be set bad, along with their bad flag. | be set bad, along with their bad flag. | |||

Otherwise they will have their bad flags cleared, | Otherwise they will have their bad flags cleared, | |||

since they will not contain any bad values. | since they will not contain any bad values. | |||

=cut | =cut | |||

#line 1403 "Ufunc.pm" | #line 1464 "Ufunc.pm" | |||

#line 1060 "../../blib/lib/PDL/PP.pm" | ||||

#line 1061 "../../blib/lib/PDL/PP.pm" | ||||

*minmaximum = \&PDL::minmaximum; | *minmaximum = \&PDL::minmaximum; | |||

#line 1409 "Ufunc.pm" | #line 1471 "Ufunc.pm" | |||

#line 309 "ufunc.pd" | ||||

#line 317 "ufunc.pd" | ||||

=head2 minmaxover | =head2 minmaxover | |||

=for ref | =for ref | |||

Synonym for minmaximum. | Synonym for minmaximum. | |||

=cut | =cut | |||

*PDL::minmaxover = *minmaxover = \&PDL::minmaximum; | *PDL::minmaxover = *minmaxover = \&PDL::minmaximum; | |||

#line 1423 "Ufunc.pm" | #line 1486 "Ufunc.pm" | |||

#line 550 "ufunc.pd" | ||||

#line 565 "ufunc.pd" | ||||

=head2 avg | =head2 avg | |||

=for ref | =for ref | |||

Return the average of all elements in an ndarray. | Return the average of all elements in an ndarray. | |||

See the documentation for L</average> for more information. | See the documentation for L</average> for more information. | |||

=for usage | =for usage | |||

skipping to change at line 1179 | skipping to change at line 1217 | |||

This routine handles bad values. | This routine handles bad values. | |||

=cut | =cut | |||

*avg = \&PDL::avg; | *avg = \&PDL::avg; | |||

sub PDL::avg { | sub PDL::avg { | |||

my($x) = @_; my $tmp; | my($x) = @_; my $tmp; | |||

$x->clump(-1)->average( $tmp=PDL->nullcreate($x) ); | $x->clump(-1)->average( $tmp=PDL->nullcreate($x) ); | |||

$tmp; | $tmp; | |||

} | } | |||

#line 1452 "Ufunc.pm" | #line 1516 "Ufunc.pm" | |||

#line 550 "ufunc.pd" | ||||

#line 565 "ufunc.pd" | ||||

=head2 sum | =head2 sum | |||

=for ref | =for ref | |||

Return the sum of all elements in an ndarray. | Return the sum of all elements in an ndarray. | |||

See the documentation for L</sumover> for more information. | See the documentation for L</sumover> for more information. | |||

=for usage | =for usage | |||

skipping to change at line 1206 | skipping to change at line 1245 | |||

This routine handles bad values. | This routine handles bad values. | |||

=cut | =cut | |||

*sum = \&PDL::sum; | *sum = \&PDL::sum; | |||

sub PDL::sum { | sub PDL::sum { | |||

my($x) = @_; my $tmp; | my($x) = @_; my $tmp; | |||

$x->clump(-1)->sumover( $tmp=PDL->nullcreate($x) ); | $x->clump(-1)->sumover( $tmp=PDL->nullcreate($x) ); | |||

$tmp; | $tmp; | |||

} | } | |||

#line 1481 "Ufunc.pm" | #line 1546 "Ufunc.pm" | |||

#line 550 "ufunc.pd" | ||||

#line 565 "ufunc.pd" | ||||

=head2 prod | =head2 prod | |||

=for ref | =for ref | |||

Return the product of all elements in an ndarray. | Return the product of all elements in an ndarray. | |||

See the documentation for L</prodover> for more information. | See the documentation for L</prodover> for more information. | |||

=for usage | =for usage | |||

skipping to change at line 1233 | skipping to change at line 1273 | |||

This routine handles bad values. | This routine handles bad values. | |||

=cut | =cut | |||

*prod = \&PDL::prod; | *prod = \&PDL::prod; | |||

sub PDL::prod { | sub PDL::prod { | |||

my($x) = @_; my $tmp; | my($x) = @_; my $tmp; | |||

$x->clump(-1)->prodover( $tmp=PDL->nullcreate($x) ); | $x->clump(-1)->prodover( $tmp=PDL->nullcreate($x) ); | |||

$tmp; | $tmp; | |||

} | } | |||

#line 1510 "Ufunc.pm" | #line 1576 "Ufunc.pm" | |||

#line 550 "ufunc.pd" | ||||

#line 565 "ufunc.pd" | ||||

=head2 davg | =head2 davg | |||

=for ref | =for ref | |||

Return the average (in double precision) of all elements in an ndarray. | Return the average (in double precision) of all elements in an ndarray. | |||

See the documentation for L</daverage> for more information. | See the documentation for L</daverage> for more information. | |||

=for usage | =for usage | |||

skipping to change at line 1260 | skipping to change at line 1301 | |||

This routine handles bad values. | This routine handles bad values. | |||

=cut | =cut | |||

*davg = \&PDL::davg; | *davg = \&PDL::davg; | |||

sub PDL::davg { | sub PDL::davg { | |||

my($x) = @_; my $tmp; | my($x) = @_; my $tmp; | |||

$x->clump(-1)->daverage( $tmp=PDL->nullcreate($x) ); | $x->clump(-1)->daverage( $tmp=PDL->nullcreate($x) ); | |||

$tmp; | $tmp; | |||

} | } | |||

#line 1539 "Ufunc.pm" | #line 1606 "Ufunc.pm" | |||

#line 550 "ufunc.pd" | ||||

#line 565 "ufunc.pd" | ||||

=head2 dsum | =head2 dsum | |||

=for ref | =for ref | |||

Return the sum (in double precision) of all elements in an ndarray. | Return the sum (in double precision) of all elements in an ndarray. | |||

See the documentation for L</dsumover> for more information. | See the documentation for L</dsumover> for more information. | |||

=for usage | =for usage | |||

skipping to change at line 1287 | skipping to change at line 1329 | |||

This routine handles bad values. | This routine handles bad values. | |||

=cut | =cut | |||

*dsum = \&PDL::dsum; | *dsum = \&PDL::dsum; | |||

sub PDL::dsum { | sub PDL::dsum { | |||

my($x) = @_; my $tmp; | my($x) = @_; my $tmp; | |||

$x->clump(-1)->dsumover( $tmp=PDL->nullcreate($x) ); | $x->clump(-1)->dsumover( $tmp=PDL->nullcreate($x) ); | |||

$tmp; | $tmp; | |||

} | } | |||

#line 1568 "Ufunc.pm" | #line 1636 "Ufunc.pm" | |||

#line 550 "ufunc.pd" | ||||

#line 565 "ufunc.pd" | ||||

=head2 dprod | =head2 dprod | |||

=for ref | =for ref | |||

Return the product (in double precision) of all elements in an ndarray. | Return the product (in double precision) of all elements in an ndarray. | |||

See the documentation for L</dprodover> for more information. | See the documentation for L</dprodover> for more information. | |||

=for usage | =for usage | |||

skipping to change at line 1314 | skipping to change at line 1357 | |||

This routine handles bad values. | This routine handles bad values. | |||

=cut | =cut | |||

*dprod = \&PDL::dprod; | *dprod = \&PDL::dprod; | |||

sub PDL::dprod { | sub PDL::dprod { | |||

my($x) = @_; my $tmp; | my($x) = @_; my $tmp; | |||

$x->clump(-1)->dprodover( $tmp=PDL->nullcreate($x) ); | $x->clump(-1)->dprodover( $tmp=PDL->nullcreate($x) ); | |||

$tmp; | $tmp; | |||

} | } | |||

#line 1597 "Ufunc.pm" | #line 1666 "Ufunc.pm" | |||

#line 550 "ufunc.pd" | ||||

#line 565 "ufunc.pd" | ||||

=head2 zcheck | =head2 zcheck | |||

=for ref | =for ref | |||

Return the check for zero of all elements in an ndarray. | Return the check for zero of all elements in an ndarray. | |||

See the documentation for L</zcover> for more information. | See the documentation for L</zcover> for more information. | |||

=for usage | =for usage | |||

skipping to change at line 1341 | skipping to change at line 1385 | |||

This routine handles bad values. | This routine handles bad values. | |||

=cut | =cut | |||

*zcheck = \&PDL::zcheck; | *zcheck = \&PDL::zcheck; | |||

sub PDL::zcheck { | sub PDL::zcheck { | |||

my($x) = @_; my $tmp; | my($x) = @_; my $tmp; | |||

$x->clump(-1)->zcover( $tmp=PDL->nullcreate($x) ); | $x->clump(-1)->zcover( $tmp=PDL->nullcreate($x) ); | |||

$tmp; | $tmp; | |||

} | } | |||

#line 1626 "Ufunc.pm" | #line 1696 "Ufunc.pm" | |||

#line 550 "ufunc.pd" | ||||

#line 565 "ufunc.pd" | ||||

=head2 and | =head2 and | |||

=for ref | =for ref | |||

Return the logical and of all elements in an ndarray. | Return the logical and of all elements in an ndarray. | |||

See the documentation for L</andover> for more information. | See the documentation for L</andover> for more information. | |||

=for usage | =for usage | |||

skipping to change at line 1368 | skipping to change at line 1413 | |||

This routine handles bad values. | This routine handles bad values. | |||

=cut | =cut | |||

*and = \&PDL::and; | *and = \&PDL::and; | |||

sub PDL::and { | sub PDL::and { | |||

my($x) = @_; my $tmp; | my($x) = @_; my $tmp; | |||

$x->clump(-1)->andover( $tmp=PDL->nullcreate($x) ); | $x->clump(-1)->andover( $tmp=PDL->nullcreate($x) ); | |||

$tmp; | $tmp; | |||

} | } | |||

#line 1655 "Ufunc.pm" | #line 1726 "Ufunc.pm" | |||

#line 550 "ufunc.pd" | ||||

#line 565 "ufunc.pd" | ||||

=head2 band | =head2 band | |||

=for ref | =for ref | |||

Return the bitwise and of all elements in an ndarray. | Return the bitwise and of all elements in an ndarray. | |||

See the documentation for L</bandover> for more information. | See the documentation for L</bandover> for more information. | |||

=for usage | =for usage | |||

skipping to change at line 1395 | skipping to change at line 1441 | |||

This routine handles bad values. | This routine handles bad values. | |||

=cut | =cut | |||

*band = \&PDL::band; | *band = \&PDL::band; | |||

sub PDL::band { | sub PDL::band { | |||

my($x) = @_; my $tmp; | my($x) = @_; my $tmp; | |||

$x->clump(-1)->bandover( $tmp=PDL->nullcreate($x) ); | $x->clump(-1)->bandover( $tmp=PDL->nullcreate($x) ); | |||

$tmp; | $tmp; | |||

} | } | |||

#line 1684 "Ufunc.pm" | #line 1756 "Ufunc.pm" | |||

#line 550 "ufunc.pd" | ||||

#line 565 "ufunc.pd" | ||||

=head2 or | =head2 or | |||

=for ref | =for ref | |||

Return the logical or of all elements in an ndarray. | Return the logical or of all elements in an ndarray. | |||

See the documentation for L</orover> for more information. | See the documentation for L</orover> for more information. | |||

=for usage | =for usage | |||

skipping to change at line 1422 | skipping to change at line 1469 | |||

This routine handles bad values. | This routine handles bad values. | |||

=cut | =cut | |||

*or = \&PDL::or; | *or = \&PDL::or; | |||

sub PDL::or { | sub PDL::or { | |||

my($x) = @_; my $tmp; | my($x) = @_; my $tmp; | |||

$x->clump(-1)->orover( $tmp=PDL->nullcreate($x) ); | $x->clump(-1)->orover( $tmp=PDL->nullcreate($x) ); | |||

$tmp; | $tmp; | |||

} | } | |||

#line 1713 "Ufunc.pm" | #line 1786 "Ufunc.pm" | |||

#line 550 "ufunc.pd" | ||||

#line 565 "ufunc.pd" | ||||

=head2 bor | =head2 bor | |||

=for ref | =for ref | |||

Return the bitwise or of all elements in an ndarray. | Return the bitwise or of all elements in an ndarray. | |||

See the documentation for L</borover> for more information. | See the documentation for L</borover> for more information. | |||

=for usage | =for usage | |||

skipping to change at line 1449 | skipping to change at line 1497 | |||

This routine handles bad values. | This routine handles bad values. | |||

=cut | =cut | |||

*bor = \&PDL::bor; | *bor = \&PDL::bor; | |||

sub PDL::bor { | sub PDL::bor { | |||

my($x) = @_; my $tmp; | my($x) = @_; my $tmp; | |||

$x->clump(-1)->borover( $tmp=PDL->nullcreate($x) ); | $x->clump(-1)->borover( $tmp=PDL->nullcreate($x) ); | |||

$tmp; | $tmp; | |||

} | } | |||

#line 1742 "Ufunc.pm" | #line 1816 "Ufunc.pm" | |||

#line 550 "ufunc.pd" | ||||

#line 565 "ufunc.pd" | ||||

=head2 min | =head2 min | |||

=for ref | =for ref | |||

Return the minimum of all elements in an ndarray. | Return the minimum of all elements in an ndarray. | |||

See the documentation for L</minimum> for more information. | See the documentation for L</minimum> for more information. | |||

=for usage | =for usage | |||

skipping to change at line 1476 | skipping to change at line 1525 | |||

This routine handles bad values. | This routine handles bad values. | |||

=cut | =cut | |||

*min = \&PDL::min; | *min = \&PDL::min; | |||

sub PDL::min { | sub PDL::min { | |||

my($x) = @_; my $tmp; | my($x) = @_; my $tmp; | |||

$x->clump(-1)->minimum( $tmp=PDL->nullcreate($x) ); | $x->clump(-1)->minimum( $tmp=PDL->nullcreate($x) ); | |||

$tmp; | $tmp; | |||

} | } | |||

#line 1771 "Ufunc.pm" | #line 1846 "Ufunc.pm" | |||

#line 550 "ufunc.pd" | ||||

#line 565 "ufunc.pd" | ||||

=head2 max | =head2 max | |||

=for ref | =for ref | |||

Return the maximum of all elements in an ndarray. | Return the maximum of all elements in an ndarray. | |||

See the documentation for L</maximum> for more information. | See the documentation for L</maximum> for more information. | |||

=for usage | =for usage | |||

skipping to change at line 1503 | skipping to change at line 1553 | |||

This routine handles bad values. | This routine handles bad values. | |||

=cut | =cut | |||

*max = \&PDL::max; | *max = \&PDL::max; | |||

sub PDL::max { | sub PDL::max { | |||

my($x) = @_; my $tmp; | my($x) = @_; my $tmp; | |||

$x->clump(-1)->maximum( $tmp=PDL->nullcreate($x) ); | $x->clump(-1)->maximum( $tmp=PDL->nullcreate($x) ); | |||

$tmp; | $tmp; | |||

} | } | |||

#line 1800 "Ufunc.pm" | #line 1876 "Ufunc.pm" | |||

#line 550 "ufunc.pd" | ||||

#line 565 "ufunc.pd" | ||||

=head2 median | =head2 median | |||

=for ref | =for ref | |||

Return the median of all elements in an ndarray. | Return the median of all elements in an ndarray. | |||

See the documentation for L</medover> for more information. | See the documentation for L</medover> for more information. | |||

=for usage | =for usage | |||

skipping to change at line 1530 | skipping to change at line 1581 | |||

This routine handles bad values. | This routine handles bad values. | |||

=cut | =cut | |||

*median = \&PDL::median; | *median = \&PDL::median; | |||

sub PDL::median { | sub PDL::median { | |||

my($x) = @_; my $tmp; | my($x) = @_; my $tmp; | |||

$x->clump(-1)->medover( $tmp=PDL->nullcreate($x) ); | $x->clump(-1)->medover( $tmp=PDL->nullcreate($x) ); | |||

$tmp; | $tmp; | |||

} | } | |||

#line 1829 "Ufunc.pm" | #line 1906 "Ufunc.pm" | |||

#line 550 "ufunc.pd" | ||||

#line 565 "ufunc.pd" | ||||

=head2 mode | =head2 mode | |||

=for ref | =for ref | |||

Return the mode of all elements in an ndarray. | Return the mode of all elements in an ndarray. | |||

See the documentation for L</modeover> for more information. | See the documentation for L</modeover> for more information. | |||

=for usage | =for usage | |||

skipping to change at line 1557 | skipping to change at line 1609 | |||

This routine handles bad values. | This routine handles bad values. | |||

=cut | =cut | |||

*mode = \&PDL::mode; | *mode = \&PDL::mode; | |||

sub PDL::mode { | sub PDL::mode { | |||

my($x) = @_; my $tmp; | my($x) = @_; my $tmp; | |||

$x->clump(-1)->modeover( $tmp=PDL->nullcreate($x) ); | $x->clump(-1)->modeover( $tmp=PDL->nullcreate($x) ); | |||

$tmp; | $tmp; | |||

} | } | |||

#line 1858 "Ufunc.pm" | #line 1936 "Ufunc.pm" | |||

#line 550 "ufunc.pd" | ||||

#line 565 "ufunc.pd" | ||||

=head2 oddmedian | =head2 oddmedian | |||

=for ref | =for ref | |||

Return the oddmedian of all elements in an ndarray. | Return the oddmedian of all elements in an ndarray. | |||

See the documentation for L</oddmedover> for more information. | See the documentation for L</oddmedover> for more information. | |||

=for usage | =for usage | |||

skipping to change at line 1584 | skipping to change at line 1637 | |||

This routine handles bad values. | This routine handles bad values. | |||

=cut | =cut | |||

*oddmedian = \&PDL::oddmedian; | *oddmedian = \&PDL::oddmedian; | |||

sub PDL::oddmedian { | sub PDL::oddmedian { | |||

my($x) = @_; my $tmp; | my($x) = @_; my $tmp; | |||

$x->clump(-1)->oddmedover( $tmp=PDL->nullcreate($x) ); | $x->clump(-1)->oddmedover( $tmp=PDL->nullcreate($x) ); | |||

$tmp; | $tmp; | |||

} | } | |||

#line 1887 "Ufunc.pm" | #line 1966 "Ufunc.pm" | |||

#line 595 "ufunc.pd" | #line 580 "ufunc.pd" | |||

=head2 any | =head2 any | |||

=for ref | =for ref | |||

Return true if any element in ndarray set | Return true if any element in ndarray set | |||

Useful in conditional expressions: | Useful in conditional expressions: | |||

=for example | =for example | |||

skipping to change at line 1642 | skipping to change at line 1695 | |||

=head2 minmax | =head2 minmax | |||

=for ref | =for ref | |||

Returns a list with minimum and maximum values of an ndarray. | Returns a list with minimum and maximum values of an ndarray. | |||

=for usage | =for usage | |||

($mn, $mx) = minmax($pdl); | ($mn, $mx) = minmax($pdl); | |||

This routine does I<not> thread over the dimensions of C<$pdl>; | This routine does I<not> broadcast over the dimensions of C<$pdl>; | |||

it returns the minimum and maximum values of the whole ndarray. | it returns the minimum and maximum values of the whole ndarray. | |||

See L</minmaximum> if this is not what is required. | See L</minmaximum> if this is not what is required. | |||

The two values are returned as Perl scalars similar to min/max, | The two values are returned as Perl scalars similar to min/max, | |||

and therefore ignore whether the values are bad. | and therefore ignore whether the values are bad. | |||

=for example | =for example | |||

pdl> $x = pdl [1,-2,3,5,0] | pdl> $x = pdl [1,-2,3,5,0] | |||

pdl> ($min, $max) = minmax($x); | pdl> ($min, $max) = minmax($x); | |||

pdl> p "$min $max\n"; | pdl> p "$min $max\n"; | |||

-2 5 | -2 5 | |||

=cut | =cut | |||

*minmax = \&PDL::minmax; | *minmax = \&PDL::minmax; | |||

sub PDL::minmax { | sub PDL::minmax { | |||

my ($x)=@_; my $tmp; | my ($x)=@_; my $tmp; | |||

my @arr = $x->clump(-1)->minmaximum; | my @arr = $x->clump(-1)->minmaximum; | |||

map $_->sclr, @arr[0,1]; # as scalars ! | map $_->sclr, @arr[0,1]; # as scalars ! | |||

} | } | |||

#line 1968 "Ufunc.pm" | #line 2048 "Ufunc.pm" | |||

#line 1059 "../../blib/lib/PDL/PP.pm" | #line 1058 "../../blib/lib/PDL/PP.pm" | |||

=head2 medover | =head2 medover | |||

=for sig | =for sig | |||

Signature: (a(n); [o]b(); [t]tmp(n)) | Signature: (a(n); [o]b(); [t]tmp(n)) | |||

=for ref | =for ref | |||

Project via median to N-1 dimensions | Project via median to N-1 dimensions | |||

skipping to change at line 1697 | skipping to change at line 1750 | |||

=for example | =for example | |||

$spectrum = medover $image->transpose | $spectrum = medover $image->transpose | |||

=for bad | =for bad | |||

medover processes bad values. | medover processes bad values. | |||

=cut | =cut | |||

#line 2011 "Ufunc.pm" | #line 2092 "Ufunc.pm" | |||

#line 1060 "../../blib/lib/PDL/PP.pm" | ||||

#line 1061 "../../blib/lib/PDL/PP.pm" | ||||

*medover = \&PDL::medover; | *medover = \&PDL::medover; | |||

#line 2017 "Ufunc.pm" | #line 2099 "Ufunc.pm" | |||

#line 1059 "../../blib/lib/PDL/PP.pm" | #line 1058 "../../blib/lib/PDL/PP.pm" | |||

=head2 oddmedover | =head2 oddmedover | |||

=for sig | =for sig | |||

Signature: (a(n); [o]b(); [t]tmp(n)) | Signature: (a(n); [o]b(); [t]tmp(n)) | |||

=for ref | =for ref | |||

Project via oddmedian to N-1 dimensions | Project via oddmedian to N-1 dimensions | |||

skipping to change at line 1742 | skipping to change at line 1796 | |||

value. The lower-odd median is just the lower of these two values | value. The lower-odd median is just the lower of these two values | |||

and so it ALWAYS sits on an actual data value which is useful in | and so it ALWAYS sits on an actual data value which is useful in | |||

some circumstances. | some circumstances. | |||

=for bad | =for bad | |||

oddmedover processes bad values. | oddmedover processes bad values. | |||

=cut | =cut | |||

#line 2068 "Ufunc.pm" | #line 2151 "Ufunc.pm" | |||

#line 1060 "../../blib/lib/PDL/PP.pm" | ||||

#line 1061 "../../blib/lib/PDL/PP.pm" | ||||

*oddmedover = \&PDL::oddmedover; | *oddmedover = \&PDL::oddmedover; | |||

#line 2074 "Ufunc.pm" | #line 2158 "Ufunc.pm" | |||

#line 1059 "../../blib/lib/PDL/PP.pm" | #line 1058 "../../blib/lib/PDL/PP.pm" | |||

=head2 modeover | =head2 modeover | |||

=for sig | =for sig | |||

Signature: (data(n); [o]out(); [t]sorted(n)) | Signature: (data(n); [o]out(); [t]sorted(n)) | |||

=for ref | =for ref | |||

Project via mode to N-1 dimensions | Project via mode to N-1 dimensions | |||

skipping to change at line 1790 | skipping to change at line 1845 | |||

C<modeover> treats BAD the same as any other value: if | C<modeover> treats BAD the same as any other value: if | |||

BAD is the most common element, the returned value is also BAD. | BAD is the most common element, the returned value is also BAD. | |||

=for bad | =for bad | |||

modeover does not process bad values. | modeover does not process bad values. | |||

=cut | =cut | |||

#line 2127 "Ufunc.pm" | #line 2212 "Ufunc.pm" | |||

#line 1060 "../../blib/lib/PDL/PP.pm" | ||||

#line 1061 "../../blib/lib/PDL/PP.pm" | ||||

*modeover = \&PDL::modeover; | *modeover = \&PDL::modeover; | |||

#line 2133 "Ufunc.pm" | #line 2219 "Ufunc.pm" | |||

#line 1059 "../../blib/lib/PDL/PP.pm" | #line 1058 "../../blib/lib/PDL/PP.pm" | |||

=head2 pctover | =head2 pctover | |||

=for sig | =for sig | |||

Signature: (a(n); p(); [o]b(); [t]tmp(n)) | Signature: (a(n); p(); [o]b(); [t]tmp(n)) | |||

=for ref | =for ref | |||

Project via specified percentile to N-1 dimensions | Project via specified percentile to N-1 dimensions | |||

skipping to change at line 1836 | skipping to change at line 1892 | |||

implemented here is based on the interpolation variant described at | implemented here is based on the interpolation variant described at | |||

L<http://en.wikipedia.org/wiki/Percentile> as used by Microsoft Excel | L<http://en.wikipedia.org/wiki/Percentile> as used by Microsoft Excel | |||

and recommended by NIST. | and recommended by NIST. | |||

=for bad | =for bad | |||

pctover processes bad values. | pctover processes bad values. | |||

=cut | =cut | |||

#line 2183 "Ufunc.pm" | #line 2270 "Ufunc.pm" | |||

#line 1060 "../../blib/lib/PDL/PP.pm" | ||||

#line 1061 "../../blib/lib/PDL/PP.pm" | ||||

*pctover = \&PDL::pctover; | *pctover = \&PDL::pctover; | |||

#line 2189 "Ufunc.pm" | #line 2277 "Ufunc.pm" | |||

#line 1059 "../../blib/lib/PDL/PP.pm" | #line 1058 "../../blib/lib/PDL/PP.pm" | |||

=head2 oddpctover | =head2 oddpctover | |||

=for sig | =for sig | |||

Signature: (a(n); p(); [o]b(); [t]tmp(n)) | Signature: (a(n); p(); [o]b(); [t]tmp(n)) | |||

=for ref | =for ref | |||

Project via specified percentile to N-1 dimensions | Project via specified percentile to N-1 dimensions | |||

skipping to change at line 1880 | skipping to change at line 1937 | |||

falls between two values, the nearest data value is the result. | falls between two values, the nearest data value is the result. | |||

The algorithm implemented is from the textbook version described | The algorithm implemented is from the textbook version described | |||

first at L<http://en.wikipedia.org/wiki/Percentile>. | first at L<http://en.wikipedia.org/wiki/Percentile>. | |||

=for bad | =for bad | |||

oddpctover processes bad values. | oddpctover processes bad values. | |||

=cut | =cut | |||

#line 2237 "Ufunc.pm" | #line 2326 "Ufunc.pm" | |||

#line 1060 "../../blib/lib/PDL/PP.pm" | ||||

#line 1061 "../../blib/lib/PDL/PP.pm" | ||||

*oddpctover = \&PDL::oddpctover; | *oddpctover = \&PDL::oddpctover; | |||

#line 2243 "Ufunc.pm" | #line 2333 "Ufunc.pm" | |||

#line 985 "ufunc.pd" | ||||

#line 1008 "ufunc.pd" | ||||

=head2 pct | =head2 pct | |||

=for ref | =for ref | |||

Return the specified percentile of all elements in an ndarray. The | Return the specified percentile of all elements in an ndarray. The | |||

specified percentile (p) must be between 0.0 and 1.0. When the | specified percentile (p) must be between 0.0 and 1.0. When the | |||

specified percentile falls between data points, the result is | specified percentile falls between data points, the result is | |||

interpolated. | interpolated. | |||

=for usage | =for usage | |||

skipping to change at line 1908 | skipping to change at line 1967 | |||

$x = pct($data, $pct); | $x = pct($data, $pct); | |||

=cut | =cut | |||

*pct = \&PDL::pct; | *pct = \&PDL::pct; | |||

sub PDL::pct { | sub PDL::pct { | |||

my($x, $p) = @_; | my($x, $p) = @_; | |||

$x->clump(-1)->pctover($p, my $tmp=PDL->nullcreate($x)); | $x->clump(-1)->pctover($p, my $tmp=PDL->nullcreate($x)); | |||

$tmp; | $tmp; | |||

} | } | |||

#line 2269 "Ufunc.pm" | #line 2360 "Ufunc.pm" | |||

#line 1010 "ufunc.pd" | ||||

#line 1033 "ufunc.pd" | ||||

=head2 oddpct | =head2 oddpct | |||

=for ref | =for ref | |||

Return the specified percentile of all elements in an ndarray. The | Return the specified percentile of all elements in an ndarray. The | |||

specified percentile must be between 0.0 and 1.0. When the specified | specified percentile must be between 0.0 and 1.0. When the specified | |||

percentile falls between two values, the nearest data value is the | percentile falls between two values, the nearest data value is the | |||

result. | result. | |||

=for usage | =for usage | |||

skipping to change at line 1932 | skipping to change at line 1992 | |||

$x = oddpct($data, $pct); | $x = oddpct($data, $pct); | |||

=cut | =cut | |||

*oddpct = \&PDL::oddpct; | *oddpct = \&PDL::oddpct; | |||

sub PDL::oddpct { | sub PDL::oddpct { | |||

my($x, $p) = @_; | my($x, $p) = @_; | |||

$x->clump(-1)->oddpctover($p, my $tmp=PDL->nullcreate($x)); | $x->clump(-1)->oddpctover($p, my $tmp=PDL->nullcreate($x)); | |||

$tmp; | $tmp; | |||

} | } | |||

#line 2295 "Ufunc.pm" | #line 2387 "Ufunc.pm" | |||

#line 1059 "../../blib/lib/PDL/PP.pm" | #line 1058 "../../blib/lib/PDL/PP.pm" | |||

=head2 qsort | =head2 qsort | |||

=for sig | =for sig | |||

Signature: (a(n); [o]b(n)) | Signature: (a(n); [o]b(n)) | |||

=for ref | =for ref | |||

Quicksort a vector into ascending order. | Quicksort a vector into ascending order. | |||

skipping to change at line 1960 | skipping to change at line 2020 | |||

=for bad | =for bad | |||

Bad values are moved to the end of the array: | Bad values are moved to the end of the array: | |||

pdl> p $y | pdl> p $y | |||

[42 47 98 BAD 22 96 74 41 79 76 96 BAD 32 76 25 59 BAD 96 32 BAD] | [42 47 98 BAD 22 96 74 41 79 76 96 BAD 32 76 25 59 BAD 96 32 BAD] | |||

pdl> p qsort($y) | pdl> p qsort($y) | |||

[22 25 32 32 41 42 47 59 74 76 76 79 96 96 96 98 BAD BAD BAD BAD] | [22 25 32 32 41 42 47 59 74 76 76 79 96 96 96 98 BAD BAD BAD BAD] | |||

=cut | =cut | |||

#line 2330 "Ufunc.pm" | #line 2423 "Ufunc.pm" | |||

#line 1060 "../../blib/lib/PDL/PP.pm" | ||||

#line 1061 "../../blib/lib/PDL/PP.pm" | ||||

*qsort = \&PDL::qsort; | *qsort = \&PDL::qsort; | |||

#line 2336 "Ufunc.pm" | #line 2430 "Ufunc.pm" | |||

#line 1059 "../../blib/lib/PDL/PP.pm" | #line 1058 "../../blib/lib/PDL/PP.pm" | |||

=head2 qsorti | =head2 qsorti | |||

=for sig | =for sig | |||

Signature: (a(n); indx [o]indx(n)) | Signature: (a(n); indx [o]indx(n)) | |||

=for ref | =for ref | |||

Quicksort a vector and return index of elements in ascending order. | Quicksort a vector and return index of elements in ascending order. | |||

skipping to change at line 1993 | skipping to change at line 2054 | |||

=for bad | =for bad | |||

Bad elements are moved to the end of the array: | Bad elements are moved to the end of the array: | |||

pdl> p $y | pdl> p $y | |||

[42 47 98 BAD 22 96 74 41 79 76 96 BAD 32 76 25 59 BAD 96 32 BAD] | [42 47 98 BAD 22 96 74 41 79 76 96 BAD 32 76 25 59 BAD 96 32 BAD] | |||

pdl> p $y->index( qsorti($y) ) | pdl> p $y->index( qsorti($y) ) | |||

[22 25 32 32 41 42 47 59 74 76 76 79 96 96 96 98 BAD BAD BAD BAD] | [22 25 32 32 41 42 47 59 74 76 76 79 96 96 96 98 BAD BAD BAD BAD] | |||

=cut | =cut | |||

#line 2372 "Ufunc.pm" | #line 2467 "Ufunc.pm" | |||

#line 1060 "../../blib/lib/PDL/PP.pm" | ||||

#line 1061 "../../blib/lib/PDL/PP.pm" | ||||

*qsorti = \&PDL::qsorti; | *qsorti = \&PDL::qsorti; | |||

#line 2378 "Ufunc.pm" | #line 2474 "Ufunc.pm" | |||

#line 1059 "../../blib/lib/PDL/PP.pm" | #line 1058 "../../blib/lib/PDL/PP.pm" | |||

=head2 qsortvec | =head2 qsortvec | |||

=for sig | =for sig | |||

Signature: (a(n,m); [o]b(n,m)) | Signature: (a(n,m); [o]b(n,m)) | |||

=for ref | =for ref | |||

Sort a list of vectors lexicographically. | Sort a list of vectors lexicographically. | |||

The 0th dimension of the source ndarray is dimension in the vector; | The 0th dimension of the source ndarray is dimension in the vector; | |||

the 1st dimension is list order. Higher dimensions are threaded over. | the 1st dimension is list order. Higher dimensions are broadcasted over. | |||

=for example | =for example | |||

print qsortvec pdl([[1,2],[0,500],[2,3],[4,2],[3,4],[3,5]]); | print qsortvec pdl([[1,2],[0,500],[2,3],[4,2],[3,4],[3,5]]); | |||

[ | [ | |||

[ 0 500] | [ 0 500] | |||

[ 1 2] | [ 1 2] | |||

[ 2 3] | [ 2 3] | |||

[ 3 4] | [ 3 4] | |||

[ 3 5] | [ 3 5] | |||

skipping to change at line 2040 | skipping to change at line 2102 | |||

pdl> p $p = pdl("[0 0] [-100 0] [BAD 0] [100 0]")->qsortvec | pdl> p $p = pdl("[0 0] [-100 0] [BAD 0] [100 0]")->qsortvec | |||

[ | [ | |||

[-100 0] | [-100 0] | |||

[ 0 0] | [ 0 0] | |||

[ 100 0] | [ 100 0] | |||

[ BAD 0] | [ BAD 0] | |||

] | ] | |||

=cut | =cut | |||

#line 2428 "Ufunc.pm" | #line 2525 "Ufunc.pm" | |||

#line 1060 "../../blib/lib/PDL/PP.pm" | ||||

#line 1061 "../../blib/lib/PDL/PP.pm" | ||||

*qsortvec = \&PDL::qsortvec; | *qsortvec = \&PDL::qsortvec; | |||

#line 2434 "Ufunc.pm" | #line 2532 "Ufunc.pm" | |||

#line 1059 "../../blib/lib/PDL/PP.pm" | #line 1058 "../../blib/lib/PDL/PP.pm" | |||

=head2 qsortveci | =head2 qsortveci | |||

=for sig | =for sig | |||

Signature: (a(n,m); indx [o]indx(m)) | Signature: (a(n,m); indx [o]indx(m)) | |||

=for ref | =for ref | |||

Sort a list of vectors lexicographically, returning the indices of the | Sort a list of vectors lexicographically, returning the indices of the | |||

sorted vectors rather than the sorted list itself. | sorted vectors rather than the sorted list itself. | |||

As with C<qsortvec>, the input PDL should be an NxM array containing M | As with C<qsortvec>, the input PDL should be an NxM array containing M | |||

separate N-dimensional vectors. The return value is an integer M-PDL | separate N-dimensional vectors. The return value is an integer M-PDL | |||

containing the M-indices of original array rows, in sorted order. | containing the M-indices of original array rows, in sorted order. | |||

As with C<qsortvec>, the zeroth element of the vectors runs slowest in the | As with C<qsortvec>, the zeroth element of the vectors runs slowest in the | |||

sorted list. | sorted list. | |||

Additional dimensions are threaded over: each plane is sorted separately, | Additional dimensions are broadcasted over: each plane is sorted separately, | |||

so qsortveci may be thought of as a collapse operator of sorts (groan). | so qsortveci may be thought of as a collapse operator of sorts (groan). | |||

=for bad | =for bad | |||

Vectors with bad components are moved to the end of the array as | Vectors with bad components are moved to the end of the array as | |||

for L</qsortvec>. | for L</qsortvec>. | |||

=cut | =cut | |||

#line 2472 "Ufunc.pm" | #line 2571 "Ufunc.pm" | |||

#line 1060 "../../blib/lib/PDL/PP.pm" | ||||

#line 1061 "../../blib/lib/PDL/PP.pm" | ||||

*qsortveci = \&PDL::qsortveci; | *qsortveci = \&PDL::qsortveci; | |||

#line 2478 "Ufunc.pm" | #line 2578 "Ufunc.pm" | |||

#line 1302 "ufunc.pd" | #line 1280 "ufunc.pd" | |||

=head1 AUTHOR | =head1 AUTHOR | |||

Copyright (C) Tuomas J. Lukka 1997 (lukka@husc.harvard.edu). | Copyright (C) Tuomas J. Lukka 1997 (lukka@husc.harvard.edu). | |||

Contributions by Christian Soeller (c.soeller@auckland.ac.nz) | Contributions by Christian Soeller (c.soeller@auckland.ac.nz) | |||

and Karl Glazebrook (kgb@aaoepp.aao.gov.au). All rights | and Karl Glazebrook (kgb@aaoepp.aao.gov.au). All rights | |||

reserved. There is no warranty. You are allowed to redistribute this | reserved. There is no warranty. You are allowed to redistribute this | |||

software / documentation under certain conditions. For details, see | software / documentation under certain conditions. For details, see | |||

the file COPYING in the PDL distribution. If this file is separated | the file COPYING in the PDL distribution. If this file is separated | |||

from the PDL distribution, the copyright notice should be included in | from the PDL distribution, the copyright notice should be included in | |||

the file. | the file. | |||

=cut | =cut | |||

#line 2498 "Ufunc.pm" | #line 2599 "Ufunc.pm" | |||

# Exit with OK status | # Exit with OK status | |||

1; | 1; | |||

End of changes. 205 change blocks. | ||||

205 lines changed or deleted | | 269 lines changed or added |