PDL::Ufunc 2.4.3

PDL::Ufunc Perl module contains primitive ufunc operations for pdl.

This module provides some primitive and useful functions defined using PDL::PP based on functionality of what are sometimes called ufuncs (for example NumPY and Mathematica talk about these). It collects all the functions generally used to reduce or accumulate along a dimension. These all do their job across the first dimension but by using the slicing functions you can do it on any dimension.

The PDL::Reduce module provides an alternative interface to many of the functions in this module.

SYNOPSIS

use PDL::Ufunc;

Project via $name to N-1 dimensions

This function reduces the dimensionality of a piddle by one by taking the $name along the 1st dimension.

By using xchg etc. it is possible to use any dimension.

$a = $op($b);
$spectrum = $op $image->xchg(0,1)
$extras
EOD
} # sub: projectdocs()
sub cumuprojectdocs { my $name = shift; my $op = shift; my $extras = shift; return <<EOD;
Cumulative $name

This function calculates the cumulative $name along the 1st dimension.

By using xchg etc. it is possible to use any dimension.

The sum is started so that the first element in the cumulative $name is the first element of the parameter.

$a = $op($b);
$spectrum = $op $image->xchg(0,1)
$extras
EOD
} # sub: cumuprojectdocs()

# its a bit unclear what to do with the comparison operators, # since the return value could be bad because all elements are bad, # which needs checking for since the bad value could evaluate to # true or false (eg if the user has set it to 0) # # by setting CopyBadStatusCode to , we stop the output piddle # from automatically being set bad if any of the input piddles are bad. # - we can set the flag within BadCode if necessary # # This may NOT be sensible. Only time, and comments, will tell... #

my %over = ( sumover => { name => sum, op => +=, init => 0, }, prodover => { name => product, op => *=, init => 1, }, );
foreach my $func ( keys %over ) {

# creates $func and cumu$func functions
# and d$func and dcumu$func functions, which
# perform the calculations in double precision

my $name = $over{$func}{name};
my $op = $over{$func}{op};
my $init = $over{$func}{init};

pp_def(
$func,
HandleBad => 1,
Pars => a(n); int+ [o]b();,
Code =>
$GENERIC(b) tmp = . $init . ;
loop(n) %{ tmp . $op . $a(); %}
$b() = tmp;,
BadCode =>
$GENERIC(b) tmp = . $init . ;
int flag = 0;
loop(n) %{
if ( $ISGOOD(a()) ) { tmp . $op . $a(); flag = 1; }
%}
if ( flag ) { $b() = tmp; }
else { $SETBAD(b()); },
Doc => projectdocs( $name, $func, ),
);

# as above, but in double precision
pp_def(
"d$func",
HandleBad => 1,
Pars => a(n); double [o]b();,
Code =>
double tmp = . $init . ;
loop(n) %{ tmp . $op . $a(); %}
$b() = tmp;,
BadCode =>
double tmp = . $init . ;
int flag = 0;
loop(n) %{
if ( $ISGOOD(a()) ) { tmp . $op . $a(); flag = 1; }
%}
if ( flag ) { $b() = tmp; }
else { $SETBAD(b()); },
Doc => projectdocs( $name, "d$func",
"Unlike L<$func|/$func>, the calculations are performed in doublen" .
"precision." ),
);

my $cfunc = "cumu${func}";
pp_def(
$cfunc,
HandleBad => 1,
Pars => a(n); int+ [o]b(n);,
Code =>
$GENERIC(b) tmp = . $init . ;
loop(n) %{
tmp . $op . $a();
$b() = tmp;
%},
BadCode =>
$GENERIC(b) tmp = . $init . ;
loop(n) %{
if ( $ISBAD(a()) ) { $SETBAD(b()); }
else {
tmp . $op . $a();
$b() = tmp;
}
%},
Doc => cumuprojectdocs( $name, $cfunc, ),
);

# as above but in double precision
pp_def(
"d$cfunc",
HandleBad => 1,
Pars => a(n); double [o]b(n);,
Code =>
double tmp = . $init . ;
loop(n) %{
tmp . $op . $a();
$b() = tmp;
%},
BadCode =>
double tmp = . $init . ;
loop(n) %{
if ( $ISBAD(a()) ) { $SETBAD(b()); }
else {
tmp . $op . $a();
$b() = tmp;
}
%},
Doc => cumuprojectdocs( $name, $cfunc,
"Unlike L , the calculations are performed in doublen" .
"precision." ),
);