Ufunc.pm (PDL-2.082) | : | Ufunc.pm (PDL-2.083) | ||
---|---|---|---|---|
skipping to change at line 47 | 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 55 "Ufunc.pm" | #line 56 "Ufunc.pm" | |||
=head1 FUNCTIONS | =head1 FUNCTIONS | |||
=cut | =cut | |||
#line 958 "../../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 85 | skipping to change at line 83 | |||
=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 109 "Ufunc.pm" | ||||
#line 960 "../../blib/lib/PDL/PP.pm" | ||||
*prodover = \&PDL::prodover; | *prodover = \&PDL::prodover; | |||
#line 116 "Ufunc.pm" | ||||
#line 958 "../../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 127 | skipping to change at line 119 | |||
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. | 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 161 "Ufunc.pm" | ||||
#line 960 "../../blib/lib/PDL/PP.pm" | ||||
*cprodover = \&PDL::cprodover; | *cprodover = \&PDL::cprodover; | |||
#line 168 "Ufunc.pm" | ||||
#line 958 "../../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 168 | skipping to change at line 154 | |||
$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. | |||
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 212 "Ufunc.pm" | ||||
#line 960 "../../blib/lib/PDL/PP.pm" | ||||
*dprodover = \&PDL::dprodover; | *dprodover = \&PDL::dprodover; | |||
#line 219 "Ufunc.pm" | ||||
#line 958 "../../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 210 | skipping to change at line 190 | |||
=for example | =for example | |||
$spectrum = cumuprodover $image->transpose | $spectrum = cumuprodover $image->transpose | |||
=for bad | =for bad | |||
cumuprodover processes bad values. | cumuprodover 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 266 "Ufunc.pm" | ||||
#line 960 "../../blib/lib/PDL/PP.pm" | ||||
*cumuprodover = \&PDL::cumuprodover; | *cumuprodover = \&PDL::cumuprodover; | |||
#line 273 "Ufunc.pm" | ||||
#line 958 "../../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 254 | skipping to change at line 228 | |||
$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. | |||
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 320 "Ufunc.pm" | ||||
#line 960 "../../blib/lib/PDL/PP.pm" | ||||
*dcumuprodover = \&PDL::dcumuprodover; | *dcumuprodover = \&PDL::dcumuprodover; | |||
#line 327 "Ufunc.pm" | ||||
#line 958 "../../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 293 | skipping to change at line 261 | |||
=for example | =for example | |||
$spectrum = sumover $image->transpose | $spectrum = sumover $image->transpose | |||
=for bad | =for bad | |||
sumover processes bad values. | sumover 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 371 "Ufunc.pm" | ||||
#line 960 "../../blib/lib/PDL/PP.pm" | ||||
*sumover = \&PDL::sumover; | *sumover = \&PDL::sumover; | |||
#line 378 "Ufunc.pm" | ||||
#line 958 "../../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 335 | skipping to change at line 297 | |||
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. | |||
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 423 "Ufunc.pm" | ||||
#line 960 "../../blib/lib/PDL/PP.pm" | ||||
*csumover = \&PDL::csumover; | *csumover = \&PDL::csumover; | |||
#line 430 "Ufunc.pm" | ||||
#line 958 "../../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 376 | skipping to change at line 332 | |||
$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. | |||
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 474 "Ufunc.pm" | ||||
#line 960 "../../blib/lib/PDL/PP.pm" | ||||
*dsumover = \&PDL::dsumover; | *dsumover = \&PDL::dsumover; | |||
#line 481 "Ufunc.pm" | ||||
#line 958 "../../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 418 | skipping to change at line 368 | |||
=for example | =for example | |||
$spectrum = cumusumover $image->transpose | $spectrum = cumusumover $image->transpose | |||
=for bad | =for bad | |||
cumusumover processes bad values. | cumusumover 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 528 "Ufunc.pm" | ||||
#line 960 "../../blib/lib/PDL/PP.pm" | ||||
*cumusumover = \&PDL::cumusumover; | *cumusumover = \&PDL::cumusumover; | |||
#line 535 "Ufunc.pm" | ||||
#line 958 "../../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 462 | skipping to change at line 406 | |||
$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. | |||
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 582 "Ufunc.pm" | ||||
#line 960 "../../blib/lib/PDL/PP.pm" | ||||
*dcumusumover = \&PDL::dcumusumover; | *dcumusumover = \&PDL::dcumusumover; | |||
#line 589 "Ufunc.pm" | ||||
#line 958 "../../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 502 | skipping to change at line 440 | |||
$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 633 "Ufunc.pm" | ||||
#line 960 "../../blib/lib/PDL/PP.pm" | ||||
*andover = \&PDL::andover; | *andover = \&PDL::andover; | |||
#line 640 "Ufunc.pm" | ||||
#line 958 "../../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 542 | skipping to change at line 474 | |||
$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 684 "Ufunc.pm" | ||||
#line 960 "../../blib/lib/PDL/PP.pm" | ||||
*bandover = \&PDL::bandover; | *bandover = \&PDL::bandover; | |||
#line 691 "Ufunc.pm" | ||||
#line 958 "../../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 582 | skipping to change at line 508 | |||
$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 735 "Ufunc.pm" | ||||
#line 960 "../../blib/lib/PDL/PP.pm" | ||||
*borover = \&PDL::borover; | *borover = \&PDL::borover; | |||
#line 742 "Ufunc.pm" | ||||
#line 958 "../../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 622 | skipping to change at line 542 | |||
$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 786 "Ufunc.pm" | ||||
#line 960 "../../blib/lib/PDL/PP.pm" | ||||
*orover = \&PDL::orover; | *orover = \&PDL::orover; | |||
#line 793 "Ufunc.pm" | ||||
#line 958 "../../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 662 | skipping to change at line 576 | |||
$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 837 "Ufunc.pm" | ||||
#line 960 "../../blib/lib/PDL/PP.pm" | ||||
*zcover = \&PDL::zcover; | *zcover = \&PDL::zcover; | |||
#line 844 "Ufunc.pm" | ||||
#line 958 "../../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 711 | skipping to change at line 619 | |||
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. | |||
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 897 "Ufunc.pm" | ||||
#line 960 "../../blib/lib/PDL/PP.pm" | ||||
*intover = \&PDL::intover; | *intover = \&PDL::intover; | |||
#line 904 "Ufunc.pm" | ||||
#line 958 "../../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 750 | skipping to change at line 652 | |||
=for example | =for example | |||
$spectrum = average $image->transpose | $spectrum = average $image->transpose | |||
=for bad | =for bad | |||
average processes bad values. | average 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 948 "Ufunc.pm" | ||||
#line 960 "../../blib/lib/PDL/PP.pm" | ||||
*average = \&PDL::average; | *average = \&PDL::average; | |||
#line 955 "Ufunc.pm" | ||||
#line 304 "ufunc.pd" | #line 304 "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 970 "Ufunc.pm" | #line 815 "Ufunc.pm" | |||
#line 958 "../../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 805 | skipping to change at line 701 | |||
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. | |||
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 1015 "Ufunc.pm" | ||||
#line 960 "../../blib/lib/PDL/PP.pm" | ||||
*caverage = \&PDL::caverage; | *caverage = \&PDL::caverage; | |||
#line 1022 "Ufunc.pm" | ||||
#line 304 "ufunc.pd" | #line 304 "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 1037 "Ufunc.pm" | #line 871 "Ufunc.pm" | |||
#line 958 "../../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 860 | skipping to change at line 750 | |||
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. | |||
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 1082 "Ufunc.pm" | ||||
#line 960 "../../blib/lib/PDL/PP.pm" | ||||
*daverage = \&PDL::daverage; | *daverage = \&PDL::daverage; | |||
#line 1089 "Ufunc.pm" | ||||
#line 304 "ufunc.pd" | #line 304 "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 1104 "Ufunc.pm" | #line 927 "Ufunc.pm" | |||
#line 958 "../../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 916 | skipping to change at line 800 | |||
=for bad | =for bad | |||
Output is set bad if no elements of the input are non-bad, | Output is set bad if no elements of the input are non-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 and will "win" over non-C<Na N>; | Note that C<NaNs> are considered to be valid values and will "win" over non-C<Na N>; | |||
see L<isfinite|PDL::Math/isfinite> and L<badmask|PDL::Bad/badmask> | see L<isfinite|PDL::Math/isfinite> and L<badmask|PDL::Bad/badmask> | |||
for ways of masking NaNs. | for ways of masking NaNs. | |||
=cut | =cut | |||
#line 1152 "Ufunc.pm" | ||||
#line 960 "../../blib/lib/PDL/PP.pm" | ||||
*minimum = \&PDL::minimum; | *minimum = \&PDL::minimum; | |||
#line 1159 "Ufunc.pm" | ||||
#line 304 "ufunc.pd" | #line 304 "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 1174 "Ufunc.pm" | #line 984 "Ufunc.pm" | |||
#line 958 "../../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 | |||
skipping to change at line 958 | skipping to change at line 836 | |||
=for bad | =for bad | |||
Output is set bad if no elements of the input are non-bad, | Output is set bad if no elements of the input are non-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 and will "win" over non-C<Na N>; | Note that C<NaNs> are considered to be valid values and will "win" over non-C<Na N>; | |||
see L<isfinite|PDL::Math/isfinite> and L<badmask|PDL::Bad/badmask> | see L<isfinite|PDL::Math/isfinite> and L<badmask|PDL::Bad/badmask> | |||
for ways of masking NaNs. | for ways of masking NaNs. | |||
=cut | =cut | |||
#line 1203 "Ufunc.pm" | ||||
#line 960 "../../blib/lib/PDL/PP.pm" | ||||
*minimum_ind = \&PDL::minimum_ind; | *minimum_ind = \&PDL::minimum_ind; | |||
#line 1210 "Ufunc.pm" | ||||
#line 304 "ufunc.pd" | #line 304 "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 1225 "Ufunc.pm" | #line 1027 "Ufunc.pm" | |||
#line 958 "../../blib/lib/PDL/PP.pm" | ||||
=head2 minimum_n_ind | =head2 minimum_n_ind | |||
=for sig | =for sig | |||
Signature: (a(n); indx [o]c(m); PDL_Indx m_size => m) | Signature: (a(n); indx [o]c(m); PDL_Indx m_size => m) | |||
=for ref | =for ref | |||
Returns the index of C<m_size> minimum elements. As of 2.077, you can | Returns the index of C<m_size> minimum elements. As of 2.077, you can | |||
skipping to change at line 1009 | skipping to change at line 881 | |||
=for bad | =for bad | |||
Output bad flag is cleared for the output ndarray if sufficient non-bad elements found, | Output bad flag is cleared for the output ndarray if sufficient non-bad elements found, | |||
else remaining slots in C<$c()> are set bad. | else remaining slots in C<$c()> are set bad. | |||
Note that C<NaNs> are considered to be valid values and will "win" over non-C<Na N>; | Note that C<NaNs> are considered to be valid values and will "win" over non-C<Na N>; | |||
see L<isfinite|PDL::Math/isfinite> and L<badmask|PDL::Bad/badmask> | see L<isfinite|PDL::Math/isfinite> and L<badmask|PDL::Bad/badmask> | |||
for ways of masking NaNs. | for ways of masking NaNs. | |||
=cut | =cut | |||
#line 1265 "Ufunc.pm" | ||||
#line 959 "../../blib/lib/PDL/PP.pm" | ||||
#line 409 "ufunc.pd" | #line 409 "ufunc.pd" | |||
sub PDL::minimum_n_ind { | sub PDL::minimum_n_ind { | |||
my ($a, $c, $m_size) = @_; | my ($a, $c, $m_size) = @_; | |||
$m_size //= ref($c) ? $c->dim(0) : $c; # back-compat with pre-2.077 | $m_size //= ref($c) ? $c->dim(0) : $c; # back-compat with pre-2.077 | |||
my $set_out = 1; | my $set_out = 1; | |||
$set_out = 0, $c = null if !ref $c; | $set_out = 0, $c = null if !ref $c; | |||
$c = $c->indx if !$c->isnull; | $c = $c->indx if !$c->isnull; | |||
PDL::_minimum_n_ind_int($a, $c, $m_size); | PDL::_minimum_n_ind_int($a, $c, $m_size); | |||
$set_out ? $_[1] = $c : $c; | $set_out ? $_[1] = $c : $c; | |||
} | } | |||
#line 1282 "Ufunc.pm" | #line 1073 "Ufunc.pm" | |||
#line 1283 "Ufunc.pm" | ||||
#line 960 "../../blib/lib/PDL/PP.pm" | ||||
*minimum_n_ind = \&PDL::minimum_n_ind; | *minimum_n_ind = \&PDL::minimum_n_ind; | |||
#line 1290 "Ufunc.pm" | ||||
#line 304 "ufunc.pd" | #line 304 "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 1305 "Ufunc.pm" | #line 1092 "Ufunc.pm" | |||
#line 958 "../../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 1080 | skipping to change at line 943 | |||
=for bad | =for bad | |||
Output is set bad if no elements of the input are non-bad, | Output is set bad if no elements of the input are non-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 and will "win" over non-C<Na N>; | Note that C<NaNs> are considered to be valid values and will "win" over non-C<Na N>; | |||
see L<isfinite|PDL::Math/isfinite> and L<badmask|PDL::Bad/badmask> | see L<isfinite|PDL::Math/isfinite> and L<badmask|PDL::Bad/badmask> | |||
for ways of masking NaNs. | for ways of masking NaNs. | |||
=cut | =cut | |||
#line 1353 "Ufunc.pm" | ||||
#line 960 "../../blib/lib/PDL/PP.pm" | ||||
*maximum = \&PDL::maximum; | *maximum = \&PDL::maximum; | |||
#line 1360 "Ufunc.pm" | ||||
#line 304 "ufunc.pd" | #line 304 "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 1375 "Ufunc.pm" | #line 1149 "Ufunc.pm" | |||
#line 958 "../../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 | |||
skipping to change at line 1122 | skipping to change at line 979 | |||
=for bad | =for bad | |||
Output is set bad if no elements of the input are non-bad, | Output is set bad if no elements of the input are non-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 and will "win" over non-C<Na N>; | Note that C<NaNs> are considered to be valid values and will "win" over non-C<Na N>; | |||
see L<isfinite|PDL::Math/isfinite> and L<badmask|PDL::Bad/badmask> | see L<isfinite|PDL::Math/isfinite> and L<badmask|PDL::Bad/badmask> | |||
for ways of masking NaNs. | for ways of masking NaNs. | |||
=cut | =cut | |||
#line 1404 "Ufunc.pm" | ||||
#line 960 "../../blib/lib/PDL/PP.pm" | ||||
*maximum_ind = \&PDL::maximum_ind; | *maximum_ind = \&PDL::maximum_ind; | |||
#line 1411 "Ufunc.pm" | ||||
#line 304 "ufunc.pd" | #line 304 "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 1426 "Ufunc.pm" | #line 1192 "Ufunc.pm" | |||
#line 958 "../../blib/lib/PDL/PP.pm" | ||||
=head2 maximum_n_ind | =head2 maximum_n_ind | |||
=for sig | =for sig | |||
Signature: (a(n); indx [o]c(m); PDL_Indx m_size => m) | Signature: (a(n); indx [o]c(m); PDL_Indx m_size => m) | |||
=for ref | =for ref | |||
Returns the index of C<m_size> maximum elements. As of 2.077, you can | Returns the index of C<m_size> maximum elements. As of 2.077, you can | |||
skipping to change at line 1173 | skipping to change at line 1024 | |||
=for bad | =for bad | |||
Output bad flag is cleared for the output ndarray if sufficient non-bad elements found, | Output bad flag is cleared for the output ndarray if sufficient non-bad elements found, | |||
else remaining slots in C<$c()> are set bad. | else remaining slots in C<$c()> are set bad. | |||
Note that C<NaNs> are considered to be valid values and will "win" over non-C<Na N>; | Note that C<NaNs> are considered to be valid values and will "win" over non-C<Na N>; | |||
see L<isfinite|PDL::Math/isfinite> and L<badmask|PDL::Bad/badmask> | see L<isfinite|PDL::Math/isfinite> and L<badmask|PDL::Bad/badmask> | |||
for ways of masking NaNs. | for ways of masking NaNs. | |||
=cut | =cut | |||
#line 1466 "Ufunc.pm" | ||||
#line 959 "../../blib/lib/PDL/PP.pm" | ||||
#line 409 "ufunc.pd" | #line 409 "ufunc.pd" | |||
sub PDL::maximum_n_ind { | sub PDL::maximum_n_ind { | |||
my ($a, $c, $m_size) = @_; | my ($a, $c, $m_size) = @_; | |||
$m_size //= ref($c) ? $c->dim(0) : $c; # back-compat with pre-2.077 | $m_size //= ref($c) ? $c->dim(0) : $c; # back-compat with pre-2.077 | |||
my $set_out = 1; | my $set_out = 1; | |||
$set_out = 0, $c = null if !ref $c; | $set_out = 0, $c = null if !ref $c; | |||
$c = $c->indx if !$c->isnull; | $c = $c->indx if !$c->isnull; | |||
PDL::_maximum_n_ind_int($a, $c, $m_size); | PDL::_maximum_n_ind_int($a, $c, $m_size); | |||
$set_out ? $_[1] = $c : $c; | $set_out ? $_[1] = $c : $c; | |||
} | } | |||
#line 1483 "Ufunc.pm" | #line 1238 "Ufunc.pm" | |||
#line 1484 "Ufunc.pm" | ||||
#line 960 "../../blib/lib/PDL/PP.pm" | ||||
*maximum_n_ind = \&PDL::maximum_n_ind; | *maximum_n_ind = \&PDL::maximum_n_ind; | |||
#line 1491 "Ufunc.pm" | ||||
#line 304 "ufunc.pd" | #line 304 "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 1506 "Ufunc.pm" | #line 1257 "Ufunc.pm" | |||
#line 958 "../../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 1237 | skipping to change at line 1079 | |||
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 1544 "Ufunc.pm" | ||||
#line 960 "../../blib/lib/PDL/PP.pm" | ||||
*minmaximum = \&PDL::minmaximum; | *minmaximum = \&PDL::minmaximum; | |||
#line 1551 "Ufunc.pm" | ||||
#line 304 "ufunc.pd" | #line 304 "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 1566 "Ufunc.pm" | ||||
#line 543 "ufunc.pd" | #line 543 "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 1283 | skipping to change at line 1119 | |||
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 1596 "Ufunc.pm" | ||||
#line 543 "ufunc.pd" | #line 543 "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 1311 | skipping to change at line 1145 | |||
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 1626 "Ufunc.pm" | ||||
#line 543 "ufunc.pd" | #line 543 "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 1339 | skipping to change at line 1171 | |||
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 1656 "Ufunc.pm" | ||||
#line 543 "ufunc.pd" | #line 543 "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 1367 | skipping to change at line 1197 | |||
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 1686 "Ufunc.pm" | ||||
#line 543 "ufunc.pd" | #line 543 "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 1395 | skipping to change at line 1223 | |||
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 1716 "Ufunc.pm" | ||||
#line 543 "ufunc.pd" | #line 543 "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 1423 | skipping to change at line 1249 | |||
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 1746 "Ufunc.pm" | ||||
#line 543 "ufunc.pd" | #line 543 "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 1451 | skipping to change at line 1275 | |||
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 1776 "Ufunc.pm" | ||||
#line 543 "ufunc.pd" | #line 543 "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 1479 | skipping to change at line 1301 | |||
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 1806 "Ufunc.pm" | ||||
#line 543 "ufunc.pd" | #line 543 "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 1507 | skipping to change at line 1327 | |||
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 1836 "Ufunc.pm" | ||||
#line 543 "ufunc.pd" | #line 543 "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 1535 | skipping to change at line 1353 | |||
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 1866 "Ufunc.pm" | ||||
#line 543 "ufunc.pd" | #line 543 "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 1563 | skipping to change at line 1379 | |||
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 1896 "Ufunc.pm" | ||||
#line 543 "ufunc.pd" | #line 543 "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 1591 | skipping to change at line 1405 | |||
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 1926 "Ufunc.pm" | ||||
#line 543 "ufunc.pd" | #line 543 "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 1619 | skipping to change at line 1431 | |||
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 1956 "Ufunc.pm" | ||||
#line 543 "ufunc.pd" | #line 543 "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 1647 | skipping to change at line 1457 | |||
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 1986 "Ufunc.pm" | ||||
#line 543 "ufunc.pd" | #line 543 "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 1675 | skipping to change at line 1483 | |||
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 2016 "Ufunc.pm" | ||||
#line 543 "ufunc.pd" | #line 543 "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 1703 | skipping to change at line 1509 | |||
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 2046 "Ufunc.pm" | ||||
#line 573 "ufunc.pd" | #line 573 "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 1782 | skipping to change at line 1586 | |||
-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 2128 "Ufunc.pm" | #line 1800 "Ufunc.pm" | |||
#line 958 "../../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 1816 | skipping to change at line 1618 | |||
=for example | =for example | |||
$spectrum = medover $image->transpose | $spectrum = medover $image->transpose | |||
=for bad | =for bad | |||
medover processes bad values. | medover 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 2172 "Ufunc.pm" | ||||
#line 960 "../../blib/lib/PDL/PP.pm" | ||||
*medover = \&PDL::medover; | *medover = \&PDL::medover; | |||
#line 2179 "Ufunc.pm" | ||||
#line 958 "../../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 1862 | skipping to change at line 1658 | |||
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. | |||
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 2231 "Ufunc.pm" | ||||
#line 960 "../../blib/lib/PDL/PP.pm" | ||||
*oddmedover = \&PDL::oddmedover; | *oddmedover = \&PDL::oddmedover; | |||
#line 2238 "Ufunc.pm" | ||||
#line 958 "../../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 1911 | skipping to change at line 1701 | |||
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. | |||
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 2292 "Ufunc.pm" | ||||
#line 960 "../../blib/lib/PDL/PP.pm" | ||||
*modeover = \&PDL::modeover; | *modeover = \&PDL::modeover; | |||
#line 2299 "Ufunc.pm" | ||||
#line 958 "../../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 1958 | skipping to change at line 1742 | |||
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. | |||
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 2350 "Ufunc.pm" | ||||
#line 960 "../../blib/lib/PDL/PP.pm" | ||||
*pctover = \&PDL::pctover; | *pctover = \&PDL::pctover; | |||
#line 2357 "Ufunc.pm" | ||||
#line 958 "../../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 2003 | skipping to change at line 1781 | |||
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. | |||
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 2406 "Ufunc.pm" | ||||
#line 960 "../../blib/lib/PDL/PP.pm" | ||||
*oddpctover = \&PDL::oddpctover; | *oddpctover = \&PDL::oddpctover; | |||
#line 2413 "Ufunc.pm" | ||||
#line 934 "ufunc.pd" | #line 934 "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 interpolated. | specified percentile falls between data points, the result is interpolated. | |||
skipping to change at line 2032 | skipping to change at line 1806 | |||
$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 2439 "Ufunc.pm" | ||||
#line 934 "ufunc.pd" | #line 934 "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 (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 nearest data value is the re sult. | specified percentile falls between data points, the nearest data value is the re sult. | |||
=for usage | =for usage | |||
$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 2465 "Ufunc.pm" | #line 2082 "Ufunc.pm" | |||
#line 958 "../../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 2084 | skipping to change at line 1854 | |||
=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 2501 "Ufunc.pm" | ||||
#line 960 "../../blib/lib/PDL/PP.pm" | ||||
*qsort = \&PDL::qsort; | *qsort = \&PDL::qsort; | |||
#line 2508 "Ufunc.pm" | ||||
#line 958 "../../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 2118 | skipping to change at line 1882 | |||
=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 2545 "Ufunc.pm" | ||||
#line 960 "../../blib/lib/PDL/PP.pm" | ||||
*qsorti = \&PDL::qsorti; | *qsorti = \&PDL::qsorti; | |||
#line 2552 "Ufunc.pm" | ||||
#line 958 "../../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. | |||
skipping to change at line 2166 | skipping to change at line 1924 | |||
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 2603 "Ufunc.pm" | ||||
#line 960 "../../blib/lib/PDL/PP.pm" | ||||
*qsortvec = \&PDL::qsortvec; | *qsortvec = \&PDL::qsortvec; | |||
#line 2610 "Ufunc.pm" | ||||
#line 958 "../../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 | |||
skipping to change at line 2202 | skipping to change at line 1954 | |||
Additional dimensions are broadcasted 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 2649 "Ufunc.pm" | ||||
#line 960 "../../blib/lib/PDL/PP.pm" | ||||
*qsortveci = \&PDL::qsortveci; | *qsortveci = \&PDL::qsortveci; | |||
#line 2656 "Ufunc.pm" | ||||
#line 1182 "ufunc.pd" | #line 1182 "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 2677 "Ufunc.pm" | #line 2259 "Ufunc.pm" | |||
# Exit with OK status | # Exit with OK status | |||
1; | 1; | |||
End of changes. 122 change blocks. | ||||
267 lines changed or deleted | 15 lines changed or added |