a PDL::Image2D PDL::Image2D File Image2D.pm Ref Module: Miscellaneous 2D image processing functions�uniqvec PDL::Primitive Bad If a vector contains all bad values, it is ignored as in L</uniq>.
If some of the values are good, it is treated as a normal vector. For
example, [1 2 BAD] and [BAD 2 3] could be returned, but [BAD BAD BAD]
could not. Vectors containing BAD values will be returned after any
non-NaN and non-BAD containing vectors, followed by the NaN vectors. Module PDL::Primitive File Primitive.pm Ref Return all unique vectors out of a collectione PDL::Demos::Prima PDL::Demos::Prima Ref Module: PDL demo for PDL::Graphics::Prima File Demos/Prima.pmr PDL::Graphics::Limits PDL::Graphics::Limits Ref Module: derive limits for display purposes File Graphics/Limits.pm$ran_chisq PDL::GSL::RNG File GSL/RNG.pm Ref Fills output piddle with random variates from the chi-squared distribution with
C<$nu> degrees of freedom. Module PDL::GSL::RNG Usage $piddle = $rng->ran_chisq($nu,[list of integers = output piddle dims]);
$rng->ran_chisq($nu,$output_piddle);�qawc_meat PDL::GSL::INTEG Bad qawc_meat does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. File GSL/INTEG.pm Ref info not available Sig (double a(); double b(); double c(); double epsabs();double epsrel();int limit();
double [o] result(); double [o] abserr();int n();int [o] ierr();int gslwarn();; SV* function) Module PDL::GSL::INTEG7 Image PDL::Modules Module PDL::Modules File Modules.pod� polycoef PDL::Slatec Module PDL::Slatec File Slatec.pm Ref Convert the C<polyfit>/C<polfit> coefficients to Taylor series form. Usage $tc = polycoef($l, $c, $x);> gdImageColorExact PDL::IO::GD Module PDL::IO::GD File IO/GD.pm� PDL::Perldl2::Plugin::NiceSlice PDL::Perldl2::Plugin::NiceSlice Ref Module: enable PDL NiceSlice syntax File Perldl2/Plugin/NiceSlice.pm< gdImageStringUp PDL::IO::GD File IO/GD.pm Module PDL::IO::GD\gsl_sf_clausen PDL::GSLSF::CLAUSEN Bad gsl_sf_clausen does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::GSLSF::CLAUSEN Sig double x(); double [o]y(); double [o]e() Ref Clausen Integral. Cl_2(x) := Integrate[-Log[2 Sin[t/2]], {t,0,x}] File GSLSF/CLAUSEN.pm� listindices PDL::Core Usage @tmp = listindices $x; File Core.pm Ref Convert piddle indices to perl list Module PDL::Core Example for $i (listindices $x) {
# Do something on each value...
}� kroneckerproduct PDL::Matrix File Matrix.pm Ref returns kroneckerproduct of two matrices. This is not efficiently
implemented. Module PDL::Matrix� rdsa PDL::IO::Misc Usage ([$xaxis],$data) = rdsa($file) Example $x = rdsa 'file.sdf' Module PDL::IO::Misc Ref Read a FIGARO/NDF format file. File IO/Misc.pm> gdImageRectangles PDL::IO::GD File IO/GD.pm Module PDL::IO::GDv datatypes_switch PDL::Core::Dev Module PDL::Core::Dev File Core/Dev.pm Ref prints on C<STDOUT> XS text for F<Core.xs>.? TrueColorToPalette PDL::IO::GD File IO/GD.pm Module PDL::IO::GD)sequence PDL::Basic File Basic.pm Ref Create array filled with a sequence of values Example pdl> p sequence(10)
[0 1 2 3 4 5 6 7 8 9]
pdl> p sequence(3,4)
[
[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 9 10 11]
] Module PDL::Basic Usage $w = sequence($y); $w = sequence [OPTIONAL TYPE], @dims;�gsl_sf_legendre_array PDL::GSLSF::LEGENDRE Sig double x(); double [o]y(n); double [t]work(wn); char norm; int lmax; int csphase File GSLSF/LEGENDRE.pm Ref Calculate all normalized associated Legendre polynomials. Module PDL::GSLSF::LEGENDRE Bad gsl_sf_legendre_array processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Usage $Plm = gsl_sf_legendre_array($x,'P',4,-1);k copy PDL::Core File Core.pm Ref Make a physical copy of a piddle Module PDL::Core Usage $new = $old->copy;circ_mean_p PDL::ImageND Usage $cmean=circ_mean_p($im);
$cmean=circ_mean_p($im,{Center => [10,10]}); Module PDL::ImageND File ImageND.pm Ref Calculates the circular mean of an n-dim image and returns
the projection. Optionally takes the center to be used.� gedi PDL::Slatec File Slatec.pm Sig a(n,n);int [o]ipvt(n);[o]det(two=2);[o]work(n);int job() Module PDL::Slatec Bad gedi does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.qgsl_sf_hydrogenicR PDL::GSLSF::COULOMB Bad gsl_sf_hydrogenicR does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::GSLSF::COULOMB Sig double x(); double [o]y(); double [o]e(); int n; int l; double z Ref Normalized Hydrogenic bound states. Radial dipendence. File GSLSF/COULOMB.pm� bor PDL::Ufunc Usage $x = bor($data); Bad This routine handles bad values. Module PDL::Ufunc File Ufunc.pm Ref Return the bitwise or of all elements in a piddle.C gdImageColorExactAlpha PDL::IO::GD File IO/GD.pm Module PDL::IO::GDDdsumover PDL::Ufunc Bad dsumover processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Usage $y = dsumover($x); Sig a(n); double [o]b() Ref Project via sum to N-1 dimensions File Ufunc.pm Module PDL::Ufunc Example $spectrum = dsumover $image->xchg(0,1)5Cr2p PDL::Complex Sig r(m=2); float+ [o]p(m=2) Ref convert complex numbers in rectangular form to polar (mod,arg) form. Works inplace File Complex.pm Module PDL::Complex Bad Cr2p does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. xlinvals PDL::Basic Ref X axis values between endpoints (see L</xvals>). File Basic.pm Module PDL::Basic Usage $w = zeroes(100,100);
$x = $w->xlinvals(0.5,1.5);
$y = $w->ylinvals(-2,-1);
# calculate Z for X between 0.5 and 1.5 and
# Y between -2 and -1.
$z = f($x,$y); h PDL::IO::FlexRaw PDL::IO::FlexRaw Ref Module: A flexible binary I/O format for PerlDL File IO/FlexRaw.pm@ ColorAllocateAlphas PDL::IO::GD Module PDL::IO::GD File IO/GD.pm`zcover PDL::Ufunc Usage $y = zcover($x); Bad 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,
as it will not contain any bad values. Module PDL::Ufunc Example $spectrum = zcover $image->xchg(0,1) Sig a(n); int+ [o]b() File Ufunc.pm Ref Project via == 0 to N-1 dimensions�ran_discrete_preproc PDL::GSL::RNG Usage $discrete_dist_handle = $rng->ran_discrete_preproc($double_piddle_prob); Example $prob = pdl [0.1,0.3,0.6];
$ddh = $rng->ran_discrete_preproc($prob);
$o = $rng->ran_discrete($discrete_dist_handle,100); Module PDL::GSL::RNG File GSL/RNG.pm Ref This method returns a handle that must be used when calling
L</ran_discrete>. You specify the probability of the integer number
that are returned by L</ran_discrete>.= ColorTransparent PDL::IO::GD File IO/GD.pm Module PDL::IO::GDran_rayleigh_var PDL::GSL::RNG Ref Similar to L</ran_rayleigh> except that it takes the distribution
parameters as a piddle and returns a piddle of equal dimensions. File GSL/RNG.pm Module PDL::GSL::RNG Usage $piddle = $rng->ran_rayleigh_var($sigma_piddle);>pnminascii PDL::IO::Pnm Bad pnminascii does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. File IO/Pnm.pm Ref Read in an ascii pnm file. Sig (type(); byte+ [o] im(m,n); int ms => m; int ns => n;
int format; char* fd) Module PDL::IO::Pnm� imag3d PDL::Graphics::TriD File Graphics/TriD.pm Ref 3D rendered image plot, defined by a variety of contexts Example Example: Module PDL::Graphics::TriD Usage imag3d piddle(3,x,y), {OPTIONS}
imag3d [piddle,...], {OPTIONS}K gdImageSetAntiAliasedDontBlend PDL::IO::GD File IO/GD.pm Module PDL::IO::GD, byte PDL::Core Module PDL::Core File Core.pm� gesl PDL::Slatec Module PDL::Slatec File Slatec.pm Sig a(lda,n);int ipvt(n);b(n);int job() Bad gesl does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.*ran_hypergeometric_var PDL::GSL::RNG Usage $piddle = $rng->ran_hypergeometric_var($n1_piddle, $n2_piddle, $t_piddle); Module PDL::GSL::RNG Ref Similar to L</ran_hypergeometric> except that it takes the distribution
parameters as a piddle and returns a piddle of equal dimensions. File GSL/RNG.pmfitwarp2d PDL::Image2D Ref Find the best-fit 2D polynomial to describe
a coordinate transformation. File Image2D.pm Example # points in original image
$x = pdl( 0, 0, 100, 100 );
$y = pdl( 0, 100, 100, 0 );
# get warped to these positions
$u = pdl( 10, 10, 90, 90 );
$v = pdl( 10, 90, 90, 10 );
#
# shift of origin + scale x/y axis only
$fit = byte( [ [1,1], [0,0] ], [ [1,0], [1,0] ] );
( $px, $py ) = fitwarp2d( $x, $y, $u, $v, 2, { FIT => $fit } );
print "px = ${px}py = $py";
px =
[
[-12.5 1.25]
[ 0 0]
]
py =
[
[-12.5 0]
[ 1.25 0]
]
#
# Compared to allowing all 4 terms
( $px, $py ) = fitwarp2d( $x, $y, $u, $v, 2 );
print "px = ${px}py = $py";
px =
[
[ -12.5 1.25]
[ 1.110223e-16 -1.1275703e-17]
]
py =
[
[ -12.5 1.6653345e-16]
[ 1.25 -5.8546917e-18]
] Module PDL::Image2D Usage ( $px, $py ) = fitwarp2d( $x, $y, $u, $v, $nf, { options } ) Opt FIT - which terms to fit? default ones(byte,$nf,$nf)O davgover PDL::Ufunc Ref Synonym for daverage. File Ufunc.pm Module PDL::Ufunch trace PDL::Matrix Module PDL::Matrix File Matrix.pm Ref returns the trace of a matrix (sum of diagonals)� mn_cierra PDL::Minuit Module PDL::Minuit Ref info not available File Minuit.pm Sig int l() Bad mn_cierra does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.9 FillToBorder PDL::IO::GD File IO/GD.pm Module PDL::IO::GD| PDL::Doc::Perldl PDL::Doc::Perldl Ref Module: commands for accessing PDL doc database from 'perldl' shell File Doc/Perldl.pm� erf PDL::Math Bad erf processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Sig a(); [o]b() File Math.pm Ref The error function. Works inplace. Module PDL::Math5 write_Gd PDL::IO::GD Module PDL::IO::GD File IO/GD.pmUgsl_sf_fermi_dirac_half PDL::GSLSF::FERMI_DIRAC Sig double x(); double [o]y(); double [o]e() Ref Complete integral F_{1/2}(x) File GSLSF/FERMI_DIRAC.pm Module PDL::GSLSF::FERMI_DIRAC Bad gsl_sf_fermi_dirac_half does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.mv PDL::Slices Module PDL::Slices Example $y = $x->mv(4,1); File Slices.pm Ref move a dimension to another position Sig P(); C(); int n1; int n2 Bad mv does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.0gsl_sf_pow_int PDL::GSLSF::POW_INT File GSLSF/POW_INT.pm Ref Calculate x^n. Sig double x(); double [o]y(); double [o]e(); int n Module PDL::GSLSF::POW_INT Bad gsl_sf_pow_int does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.Otwiddle PDL::Graphics2D Module PDL::Graphics2D Ref Enable GUI interaction with a FreeGLUT display window. With an argument, it sets
the default value for the auto-twiddling state. C< 0 > will disable the automatic
twiddling and C< 1 >, or true, will enable twiddling. File Graphics2D.pm Usage twiddle(); # same as twiddle(undef)� cimag PDL::Ops Module PDL::Ops Sig a(); [o]b() Ref Returns the imaginary part of a complex number. File Ops.pm Bad cimag processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.Pstring PDL::Char Usage $char = PDL::Char->new( [['abc', 'def', 'ghi'], ['jkl', 'mno', 'pqr']] );
print $char; # 'string' bound to "", perl stringify function
# Prints:
# [
# ['abc' 'def' 'ghi']
# ['jkl' 'mno' 'pqr']
# ] File Char.pm Ref Function to print a character PDL (created by 'char') in a pretty format. Module PDL::Char� store PDL::IO::Storable Ref store a piddle using L<Storable> File IO/Storable.pm Example $x = random 12,10;
$x->store('myfile'); Module PDL::IO::Storablefgsl_sf_coupling_6j PDL::GSLSF::COUPLING File GSLSF/COUPLING.pm Ref 6j Symbols: (ja jb jc) over (jd je jf). Sig ja(); jb(); jc(); jd(); je(); jf(); double [o]y(); double [o]e() Module PDL::GSLSF::COUPLING Bad gsl_sf_coupling_6j does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.= gdImageInterlace PDL::IO::GD File IO/GD.pm Module PDL::IO::GD` PDL::Constants PDL::Constants File Constants.pm Ref Module: basic compile time constants for PDL� _prep_table PDL::IO::FITS Module PDL::IO::FITS File IO/FITS.pm Ref Accept a hash ref containing a table, and return a header describing the table
and a string to be written out as the table, or barf.ybadflag PDL::Bad Bad This function works with piddles that have bad values. It
always returns a Perl scalar, so it never returns bad values. Example if ( $x->badflag() ) {
print "Data may contain bad values.\n";
}
$x->badflag(1); # set bad data flag
$x->badflag(0); # unset bad data flag Module PDL::Bad File Bad.pm Ref getter/setter for the bad data flag� minmax PDL::Ufunc Usage ($mn, $mx) = minmax($pdl); Module PDL::Ufunc Example pdl> $x = pdl [1,-2,3,5,0]
pdl> ($min, $max) = minmax($x);
pdl> p "$min $max\n";
-2 5 File Ufunc.pm Ref Returns an array with minimum and maximum values of a piddle.� bswap4 PDL::IO::Misc Bad bswap4 does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Ref Swaps quads of bytes in argument x() File IO/Misc.pm Sig x(); Module PDL::IO::Misc�gsl_sf_legendre_H3d PDL::GSLSF::LEGENDRE Module PDL::GSLSF::LEGENDRE File GSLSF/LEGENDRE.pm Ref lth radial eigenfunction of the Laplacian on the 3-dimensional hyperbolic space. Sig double [o]y(); double [o]e(); int l; double lambda; double eta Bad gsl_sf_legendre_H3d does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.�gsl_sf_gamma_inc_Q PDL::GSLSF::GAMMA Bad gsl_sf_gamma_inc_Q does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Sig double x(); double [o]y(); double [o]e(); double a File GSLSF/GAMMA.pm Ref Normalized Incomplete Gamma Function Q(a,x) = 1/Gamma(a) Integral[ t^(a-1) e^(-t), {t,x,Infinity} ] Module PDL::GSLSF::GAMMA\ PDL::DiskCache PDL::DiskCache File DiskCache.pm Ref Module: Non-memory-resident array objectA gdImageColorAllocate PDL::IO::GD File IO/GD.pm Module PDL::IO::GD� PDL::Graphics::TriD::Rout PDL::Graphics::TriD::Rout Ref Module: Helper routines for Three-dimensional graphics File Graphics/TriD/Rout.pm�rice_compress PDL::Compression Usage $out = $pdl->rice_compress($blocksize);
($out, $len, $blocksize, $dim0) = $pdl->rice_compress; Bad rice_compress ignores the bad-value flag of the input piddles.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::Compression File Compression.pm Ref Squishes an input PDL along the 0 dimension by Rice compression. In
scalar context, you get back only the compressed PDL; in list context,
you also get back ancillary information that is required to uncompress
the data with rice_uncompress. Sig in(n); [o]out(m); int[o]len(); lbuf(n); int blocksize� PDL::Graphics::OpenGL::Perl::OpenGL PDL::Graphics::OpenGL::Perl::OpenGL File Graphics/OpenGL/Perl/OpenGL.pm Ref Module: PDL TriD OpenGL interface using POGL� t_rot_sphere PDL::Transform::Cartography Ref (Cartography) Generate oblique projections File Transform/Cartography.pm Module PDL::Transform::Cartography Usage $t = t_rot_sphere({origin=>[<theta>,<phi>],roll=>[<roll>]}); ran_logarithmic_var PDL::GSL::RNG Usage $piddle = $rng->ran_logarithmic_var($p_piddle); Module PDL::GSL::RNG File GSL/RNG.pm Ref Similar to L</ran_logarithmic> except that it takes the distribution
parameters as a piddle and returns a piddle of equal dimensions.q PDL::Internals PDL::Internals Ref Manual: description of some aspects of the current internals File Internals.pod
ran_exponential_var PDL::GSL::RNG Usage $piddle = $rng->ran_exponential_var($mu_piddle); Module PDL::GSL::RNG File GSL/RNG.pm Ref Similar to L</ran_exponential> except that it takes the distribution
parameters as a piddle and returns a piddle of equal dimensions.d pp_add_boot PDL::PP Module PDL::PP Ref Add code to the BOOT section of generated XS file File PP.pod1diff_forward PDL::GSL::DIFF Sig double x(); double [o] res(); double [o] abserr(); SV* function Ref info not available File GSL/DIFF.pm Module PDL::GSL::DIFF Bad diff_forward does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.mn_abre PDL::Minuit Bad mn_abre does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Sig int l(); char* nombre; char* mode File Minuit.pm Ref info not available Module PDL::Minuit� pvalue PDL::Slatec Bad pvalue does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. File Slatec.pm Sig int l();x();[o]yfit();[o]yp(nder);a(foo) Module PDL::Slatec� median PDL::Ufunc Usage $x = median($data); Bad This routine handles bad values. Module PDL::Ufunc File Ufunc.pm Ref Return the median of all elements in a piddle.$gsl_sf_sin PDL::GSLSF::TRIG Bad gsl_sf_sin does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Ref Sin(x) with GSL semantics. File GSLSF/TRIG.pm Sig double x(); double [o]y(); double [o]e() Module PDL::GSLSF::TRIG� t_wrap PDL::Transform Module PDL::Transform Ref Shift a transform into a different space by 'wrapping' it with a second. File Transform.pm Usage $g1fg = $f->wrap($g);
$g1fg = t_wrap($f,$g); realifft PDL::FFT File FFT.pm Ref Inverse of one-dimensional realfft routine [inplace]. Module PDL::FFT Usage realifft($real);�qagiu_meat PDL::GSL::INTEG Bad qagiu_meat does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::GSL::INTEG File GSL/INTEG.pm Ref info not available Sig (double a(); double epsabs();double epsrel();int limit();
double [o] result(); double [o] abserr();int n();int [o] ierr();int gslwarn();; SV* function):ran_levy PDL::GSL::RNG Ref Fills output piddle with random variates from the Levy symmetric stable
distribution with scale C<$c> and exponent C<$alpha>. File GSL/RNG.pm Module PDL::GSL::RNG Usage $piddle = $rng->ran_levy($mu,$x,[list of integers = output piddle dims]);
$rng->ran_levy($mu,$x,$output_piddle);� nelem PDL::Core Module PDL::Core Example $mean = sum($data)/nelem($data); File Core.pm Ref Return the number of elements in a piddle Usage $n = nelem($piddle); $n = $piddle->nelem;�clip PDL::Primitive Module PDL::Primitive Sig a(); l(); h(); [o] c() Ref Clip (threshold) a piddle by (optional) upper or lower bounds.info not available File Primitive.pm Usage $y = $x->clip(0,3);
$c = $x->clip(undef, $x); Bad clip handles bad values since it is just a
wrapper around L</hclip> and
L</lclip>.clip processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.4gsl_sf_Si PDL::GSLSF::EXPINT Bad gsl_sf_Si does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::GSLSF::EXPINT File GSLSF/EXPINT.pm Ref Si(x) := Integrate[ Sin[t]/t, {t,0,x}] Sig double x(); double [o]y(); double [o]e()^convolve PDL::ImageND Usage $new = convolve $x, $kernel Bad convolve does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::ImageND Sig a(m); b(n); indx adims(p); indx bdims(q); [o]c(m) File ImageND.pm Ref N-dimensional convolution (Deprecated; use convolveND)~ status PDL::Func File Func.pm Ref Returns the status of a PDL::Func object. Module PDL::Func Usage my $status = $obj->status;E gdImageColorResolveAlpha PDL::IO::GD File IO/GD.pm Module PDL::IO::GD�dog PDL::Core Opt Break => 1 Break dataflow connection (new copy) Bad The output piddles are set bad if the original piddle has its bad flag set. Module PDL::Core Example pdl> $p = ones 3,3,3
pdl> ($x,$y,$c) = dog $p
pdl> $y++; p $p
[
[
[1 1 1]
[1 1 1]
[1 1 1]
]
[
[2 2 2]
[2 2 2]
[2 2 2]
]
[
[1 1 1]
[1 1 1]
[1 1 1]
]
] Ref Opposite of 'cat' :). Split N dim piddle to list of N-1 dim piddles File Core.pmran_gumbel1_var PDL::GSL::RNG Usage $piddle = $rng->ran_gumbel1_var($a_piddle, $b_piddle); Ref Similar to L</ran_gumbel1> except that it takes the distribution
parameters as a piddle and returns a piddle of equal dimensions. File GSL/RNG.pm Module PDL::GSL::RNG: FilledPolygon PDL::IO::GD File IO/GD.pm Module PDL::IO::GDD SetAntiAliasedDontBlend PDL::IO::GD Module PDL::IO::GD File IO/GD.pmtge PDL::Ops File Ops.pm Ref the binary E<gt>= (greater equal) operation Sig a(); b(); [o]c(); int swap Example $c = ge $x, $y, 0; # explicit call with trailing 0
$c = $x >= $y; # overloaded call
$x->inplace->ge($y,0); # modify $x inplace Module PDL::Ops Bad ge processes bad values.
The state of the bad-value flag of the output piddles is unknown.�qagil_meat PDL::GSL::INTEG Ref info not available File GSL/INTEG.pm Sig (double b(); double epsabs();double epsrel();int limit();
double [o] result(); double [o] abserr();int n();int [o] ierr();int gslwarn();; SV* function) Module PDL::GSL::INTEG Bad qagil_meat does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.K PDL::Exporter PDL::Exporter File Exporter.pm Ref Module: PDL export control� unpdl PDL::Core Usage $arrayref = unpdl $x; Bad unpdl converts any bad values into the string 'BAD'. Module PDL::Core Example use JSON;
my $json = encode_json unpdl $pdl; Ref Convert piddle to nested Perl array references File Core.pm� saoimage PDL::Graphics::IIS Usage saoimage[(command line options)] Module PDL::Graphics::IIS Example pdl> saoimage
pdl> saoimage( -geometry => '800x800' ) File Graphics/IIS.pm Ref Starts the SAOimage external programmpolyroots PDL::Math Usage ($rr, $ri) = polyroots($cr, $ci); Bad polyroots does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::Math Ref Complex roots of a complex polynomial, given coefficients in order
of decreasing powers. File Math.pm Sig cr(n); ci(n); [o]rr(m); [o]ri(m)~ rfitshdr PDL::IO::FITS File IO/FITS.pm Ref Read only the header of a FITS file or an extension within it. Module PDL::IO::FITS7 gdImageArc PDL::IO::GD File IO/GD.pm Module PDL::IO::GDA gdImageAlphaBlending PDL::IO::GD File IO/GD.pm Module PDL::IO::GD
bessy0 PDL::Math Bad bessy0 processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::Math File Math.pm Ref The regular Bessel function of the second kind, Y_n. Works inplace. Sig a(); [o]b()fgsl_sf_bessel_lnKnu PDL::GSLSF::BESSEL Bad gsl_sf_bessel_lnKnu does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. File GSLSF/BESSEL.pm Ref Logarithm of Modified Cylindrical Bessel Function K_nu(x). Sig double x(); double [o]y(); double [o]e(); double n Module PDL::GSLSF::BESSELlclip PDL::Primitive Bad lclip processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::Primitive Sig a(); b(); [o] c() File Primitive.pm Ref clip (threshold) C<$a> by C<$b> (C<$b> is lower bound)� t_identity PDL::Transform File Transform.pm Ref Generic constructor generates the identity transform. Module PDL::Transform Usage my $xform = t_identity
my $xform = new PDL::Transform;� eval PDL::GSL::INTERP Usage Ref The function eval returns the interpolating function at a given point.
It will barf with an "input domain error" if you try to extrapolate. File GSL/INTERP.pm Example Example: Module PDL::GSL::INTERP� gradient PDL::Func Ref Returns the derivative and, optionally,
the interpolated function for the C<Hermite>
scheme (PDL::Func). File Func.pm Module PDL::Func Usage my $gi = $obj->gradient( $xi );
my ( $yi, $gi ) = $obj->gradient( $xi );=gsl_poly_eval PDL::GSLSF::POLY Sig double x(); double c(m); double [o]y() Ref c[0] + c[1] x + c[2] x^2 + ... + c[m-1] x^(m-1) File GSLSF/POLY.pm Module PDL::GSLSF::POLY Bad gsl_poly_eval does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.R PDL::Ufunc PDL::Ufunc Ref Module: primitive ufunc operations for pdl File Ufunc.pme PDL::Matrix PDL::Matrix File Matrix.pm Ref Module: a convenience matrix class for column-major access�gsl_sf_hyperg_2F1 PDL::GSLSF::HYPERG Module PDL::GSLSF::HYPERG Sig double x(); double [o]y(); double [o]e(); double a; double b; double c File GSLSF/HYPERG.pm Ref Confluent hypergeometric function for integer parameters. 2F1[a,b,c,x] Bad gsl_sf_hyperg_2F1 does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.� t_az_eqd PDL::Transform::Cartography Usage $t = t_az_eqd(<options>); Module PDL::Transform::Cartography File Transform/Cartography.pm Ref (Cartography) Azimuthal equidistant projection (az.; equi.)�gsl_sf_ellint_RJ PDL::GSLSF::ELLINT Bad gsl_sf_ellint_RJ does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::GSLSF::ELLINT File GSLSF/ELLINT.pm Ref Carlsons symmetric basis of functions RJ(x,y,z,p) = 3/2 Integral[(t+x)^(-1/2) (t+y)^(-1/2) (t+z)^(-1/2) (t+p)^(-1), {t,0,Inf}] Sig double x(); double yy(); double z(); double p(); double [o]y(); double [o]e()� t_quadratic PDL::Transform File Transform.pm Ref Quadratic scaling -- cylindrical pincushion (n-d; with inverse) Module PDL::Transform Usage $t = t_quadratic(<options>);� complex PDL::Complex Usage complex($real_valued_pdl) File Complex.pm Ref Cast a real-valued piddle to the complex datatype I<without> dataflow
and I<inplace>. Module PDL::Complexran_feed_poisson PDL::GSL::RNG Example $rng->ran_feed_poisson($image); Module PDL::GSL::RNG File GSL/RNG.pm Ref This method simulates shot noise, taking the values of piddle as
values for C<$mu> to be fed in the poissonian RNG. Usage $rng->ran_feed_poisson($piddle);dran_geometric PDL::GSL::RNG Usage $piddle = $rng->ran_geometric($p,[list of integers = output piddle dims]);
$rng->ran_geometric($p,$output_piddle); Ref Fills output piddle with random integer values from the geometric distribution,
the number of independent trials with probability C<$p> until the first success. File GSL/RNG.pm Module PDL::GSL::RNG? im PDL::Complex File Complex.pm Module PDL::Complex Crossref re�shiftright PDL::Ops Example $c = shiftright $x, $y, 0; # explicit call with trailing 0
$c = $x >> $y; # overloaded call
$x->inplace->shiftright($y,0); # modify $x inplace Module PDL::Ops File Ops.pm Ref rightshift C<$a> by C<$b> Sig a(); b(); [o]c(); int swap Bad shiftright processes bad values.
The state of the bad-value flag of the output piddles is unknown.�gsl_sf_bessel_k_scaled_array PDL::GSLSF::BESSEL Bad gsl_sf_bessel_k_scaled_array does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. File GSLSF/BESSEL.pm Ref Array of Scaled IrRegular Modified Spherical Bessel Functions exp(-|x|) k_{s}(x) to exp(-|x|) k_{s+n-1}(x). Sig double x(); double [o]y(num); int n=>num Module PDL::GSLSF::BESSELa PDL::NiceSlice PDL::NiceSlice Ref Module: toward a nicer slicing syntax for PDL File NiceSlice.pm� acosh PDL::Math Bad acosh processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. File Math.pm Sig a(); [o]b() Module PDL::MathQpx PDL::Dbg Example pdl> PDL->px
pdl> $y += $x->clump(2)->px('clumptest')->sumover
pdl> $x->px('%C (%A) Type: %T') # prints nothing unless $PDL::debug
pdl> $PDL::debug = 1
pdl> $x->px('%C (%A) Type: %T')
PDL (52433464) Type: Double Module PDL::Dbg File Dbg.pm Ref Print info about a piddle (or all known piddles)f pp_add_exported PDL::PP Ref Add functions to the list of exported functions File PP.pod Module PDL::PPbadvalue PDL::Bad Bad This method does not care if you call it on an input piddle
that has bad values. It always returns a Perl scalar
with the current or new bad value. Ref returns the value used to indicate a missing (or bad) element
for the given piddle type. You can give it a piddle,
a PDL::Type object, or one of C<$PDL_B>, C<$PDL_S>, etc. File Bad.pm Example $badval = badvalue( float );
$x = ones(ushort,10);
print "The bad data value for ushort is: ",
$x->badvalue(), "\n"; Module PDL::Bad�allaxisvals PDL::Basic File Basic.pm Ref Synonym for L</ndcoords> - enumerates all coordinates in a
PDL or dim list, adding an extra dim on the front to accommodate
the vector coordinate index (the form expected by L</indexND>,
L</range>, and L</interpND>). See L</ndcoords> for more detail. Module PDL::Basic Usage $indices = allaxisvals($pdl);
$indices = allaxisvals(@dimlist);
$indices = allaxisvals($type,@dimlist);� prod PDL::Ufunc Module PDL::Ufunc File Ufunc.pm Ref Return the product of all elements in a piddle. Usage $x = prod($data); Bad This routine handles bad values.3dice_axis PDL::Slices Ref Dice rows/columns/planes from a single PDL axis (dimension)
using index along a specified axis File Slices.pm Example pdl> $x = sequence(10,4)
pdl> $idx = pdl(1,2)
pdl> p $x->dice_axis(0,$idx) # Select columns
[
[ 1 2]
[11 12]
[21 22]
[31 32]
]
pdl> $t = $x->dice_axis(1,$idx) # Select rows
pdl> $t.=0
pdl> p $x
[
[ 0 1 2 3 4 5 6 7 8 9]
[ 0 0 0 0 0 0 0 0 0 0]
[ 0 0 0 0 0 0 0 0 0 0]
[30 31 32 33 34 35 36 37 38 39]
] Module PDL::Slices Usage $slice = $data->dice_axis($axis,$index);� PDL::Graphics::OpenGLQ PDL::Graphics::OpenGLQ Ref Module: quick routines to plot lots of stuff from piddles. File Graphics/OpenGLQ.pm�qaws_meat PDL::GSL::INTEG Sig (double a(); double b();double epsabs();double epsrel();int limit();
double [o] result(); double [o] abserr();int n();
double alpha(); double beta(); int mu(); int nu();int [o] ierr();int gslwarn();; SV* function) File GSL/INTEG.pm Ref info not available Module PDL::GSL::INTEG Bad qaws_meat does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.> DESTROY PDL::DiskCache File DiskCache.pm Module PDL::DiskCache0map PDL::Transform Module PDL::Transform Sig (k0(); SV *in; SV *out; SV *map; SV *boundary; SV *method;
SV *big; SV *blur; SV *sv_min; SV *flux; SV *bv) Ref Resample an image or N-D dataset using a coordinate transform. File Transform.pm Usage $y = $x->map($xform,[<template>],[\%opt]); # Distort $x with transform $xform
$y = $x->map(t_identity,[$pdl],[\%opt]); # rescale $x to match $pdl's dims. Bad map does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.qle PDL::Ops Bad le processes bad values.
The state of the bad-value flag of the output piddles is unknown. Sig a(); b(); [o]c(); int swap Ref the binary E<lt>= (less equal) operation File Ops.pm Module PDL::Ops Example $c = le $x, $y, 0; # explicit call with trailing 0
$c = $x <= $y; # overloaded call
$x->inplace->le($y,0); # modify $x inplace� frestore PDL::IO::Dumper Usage use PDL::IO::Dumper;
fdump(<VAR>,$filename);
...
<VAR> = frestore($filename); Ref Restore a dumped file File IO/Dumper.pm Module PDL::IO::Dumper� PDL::Transform::Cartography PDL::Transform::Cartography Ref Module: Useful cartographic projections File Transform/Cartography.pm�wfits PDL::IO::FITS Bad For integer types (ie C<BITPIX E<gt> 0>), the C<BLANK> keyword is set
to the bad value. For floating-point types, the bad value is
converted to NaN (if necessary) before writing. Module PDL::IO::FITS Example wfits $pdl, 'filename.fits', [$BITPIX], [$COMPRESSION_OPTIONS];
wfits $hash, 'filename.fits', [$OPTIONS];
$pdl->wfits('foo.fits',-32); File IO/FITS.pm Ref Simple PDL FITS writerk PDL::ImageRGB PDL::ImageRGB File ImageRGB.pm Ref Module: some utility functions for RGB image data handlingbsetnantobad PDL::Bad File Bad.pm Ref Sets NaN/Inf values in the input piddle bad
(only relevant for floating-point piddles).
Can be done inplace. Sig a(); [o]b() Module PDL::Bad Bad This method can process piddles with bad values: those bad values
are propagated into the output piddle. Any value that is not finite
is also set to bad in the output piddle. If all values from the input
piddle are good and finite, the output piddle will B<not> have its
bad flag set. One more caveat: if done inplace, and if the input piddle's
bad flag is set, it will no Usage $y = $x->setnantobad;
$x->inplace->setnantobad;sgsl_sf_legendre_array_index PDL::GSLSF::LEGENDRE Usage Note that this function is called differently than the corresponding GSL function, to make it more useful for PDL: here you just input the maximum l (lmax) that was used in C<gsl_sf_legendre_array> and it calculates all l and m values. Bad gsl_sf_legendre_array_index does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::GSLSF::LEGENDRE Sig int [o]l(n); int [o]m(n); int lmax File GSLSF/LEGENDRE.pm Ref Calculate the relation between gsl_sf_legendre_arrays index and l and m values.� t_orthographic PDL::Transform::Cartography Usage $t = t_orthographic(<options>); Module PDL::Transform::Cartography Ref (Cartography) Ortho. projection (azimuthal; perspective) File Transform/Cartography.pm9 gdImageGreen PDL::IO::GD Module PDL::IO::GD File IO/GD.pm8 write_PngEx PDL::IO::GD Module PDL::IO::GD File IO/GD.pmqgsl_sf_hyperg_U PDL::GSLSF::HYPERG Module PDL::GSLSF::HYPERG File GSLSF/HYPERG.pm Ref Confluent hypergeometric function for integer parameters. U(a,b,x) Sig double x(); double [o]y(); double [o]e(); double a; double b Bad gsl_sf_hyperg_U does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.Ccosh PDL::Complex Module PDL::Complex Sig a(m=2); [o]c(m=2) File Complex.pm Ref cosh (a) = (exp (a) + exp (-a)) / 2. Works inplace Bad Ccosh does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.c PDL::QuickStart PDL::QuickStart File QuickStart.pod Ref Manual: Quick introduction to PDL features.ran_logistic PDL::GSL::RNG Usage $piddle = $rng->ran_logistic($m,[list of integers = output piddle dims]u)
$rng->ran_logistic($m,$output_piddle) Module PDL::GSL::RNG Ref Fills output piddle with random random variates from the logistic distribution. File GSL/RNG.pmdet_general PDL::Matrix Ref returns a generalized determinant of a matrix. If the matrix is not
regular, one can specify the rank of the matrix and the corresponding
subdeterminant is returned. This is implemented using the C<eigens>
function. File Matrix.pm Module PDL::Matrix�gsl_sf_dilog PDL::GSLSF::DILOG Bad gsl_sf_dilog does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::GSLSF::DILOG Sig double x(); double [o]y(); double [o]e() File GSLSF/DILOG.pm Ref /* Real part of DiLogarithm(x), for real argument. In Lewins notation, this is Li_2(x). Li_2(x) = - Re[ Integrate[ Log[1-s] / s, {s, 0, x}] ]*ran_bernoulli PDL::GSL::RNG Module PDL::GSL::RNG File GSL/RNG.pm Ref Fills output piddle with random values 0 or 1, the result of a Bernoulli trial with probability C<$p>. Usage $piddle = $rng->ran_bernoulli($p,[list of integers = output piddle dims]);
$rng->ran_bernoulli($p,$output_piddle);� t_lookup PDL::Transform Usage $f = t_lookup($lookup, {<options>}); Module PDL::Transform Ref Transform by lookup into an explicit table. File Transform.pm�qawo_meat PDL::GSL::INTEG Bad qawo_meat does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Sig (double a(); double b();double epsabs();double epsrel();int limit();
double [o] result(); double [o] abserr();int n();
int sincosopt(); double omega(); double L(); int nlevels();int [o] ierr();int gslwarn();; SV* function) File GSL/INTEG.pm Ref info not available Module PDL::GSL::INTEG� real PDL::Complex File Complex.pm Ref Cast a complex valued pdl back to the "normal" pdl datatype. Module PDL::Complex Usage real($cplx_valued_pdl)jpower PDL::Ops Bad power processes bad values.
The state of the bad-value flag of the output piddles is unknown. Example $c = $x->power($y,0); # explicit function call
$c = $a ** $b; # overloaded use
$x->inplace->power($y,0); # modify $x inplace Module PDL::Ops Sig a(); b(); [o]c(); int swap File Ops.pm Ref raise piddle C<$a> to the power C<$b>Fgsl_sf_debye_2 PDL::GSLSF::DEBYE Bad gsl_sf_debye_2 does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::GSLSF::DEBYE Ref D_n(x) := n/x^n Integrate[t^n/(e^t - 1), {t,0,x}] File GSLSF/DEBYE.pm Sig double x(); double [o]y(); double [o]e()�gsl_sf_coupling_9j PDL::GSLSF::COUPLING Bad gsl_sf_coupling_9j does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::GSLSF::COUPLING Sig ja(); jb(); jc(); jd(); je(); jf(); jg(); jh(); ji(); double [o]y(); double [o]e() File GSLSF/COUPLING.pm Ref 9j Symbols: (ja jb jc) over (jd je jf) over (jg jh ji).� PDL::Perldl2::Plugin::PrintControl PDL::Perldl2::Plugin::PrintControl Ref Module: disable default print output File Perldl2/Plugin/PrintControl.pm{ AUTOLOAD PDL::Graphics::OpenGL::Perl::OpenGL Module PDL::Graphics::OpenGL::Perl::OpenGL File Graphics/OpenGL/Perl/OpenGL.pms PDL::Transform PDL::Transform Ref Module: Coordinate transforms, image warping, and N-D functions File Transform.pm�qawf_meat PDL::GSL::INTEG Module PDL::GSL::INTEG Sig (double a(); double epsabs();int limit();
double [o] result(); double [o] abserr();int n();
int sincosopt(); double omega(); int nlevels();int [o] ierr();int gslwarn();; SV* function) Ref info not available File GSL/INTEG.pm Bad qawf_meat does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.� info PDL::Core File Core.pm Ref Return formatted information about a piddle. Module PDL::Core Example print $x->info("Type: %T Dim: %-15D State: %S"); Usage $x->info($format_string);z default PDL::Graphics::OpenGL::Perl::OpenGL Module PDL::Graphics::OpenGL::Perl::OpenGL File Graphics/OpenGL/Perl/OpenGL.pmVoddmedover PDL::Ufunc Bad oddmedover processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Usage $y = oddmedover($x); File Ufunc.pm Ref Project via oddmedian to N-1 dimensions Sig a(n); [o]b(); [t]tmp(n) Module PDL::Ufunc Example $spectrum = oddmedover $image->xchg(0,1)� PDL::IO::Dumper::uudecode_PDL PDL::IO::Dumper File IO/Dumper.pm Ref Recover a PDL from a uuencoded string [Internal routine] Module PDL::IO::Dumper� writeflexhdr PDL::IO::FlexRaw Usage Module PDL::IO::FlexRaw Ref Write the header file corresponding to a previous writeflex call File IO/FlexRaw.pm�isbad PDL::Bad Bad This method works with input piddles that are bad. The output piddle
will never contain bad values, but its bad value flag will be the
same as the input piddle's flag. Example $x = pdl(1,2,3);
$x->badflag(1);
set($x,1,$x->badvalue);
$y = isbad($x);
print $y, "\n";
[0 1 0] Module PDL::Bad Sig a(); int [o]b() Ref Returns a binary mask indicating which values of
the input are bad values File Bad.pm� t_conic PDL::Transform::Cartography Usage $t = t_conic(<options>) File Transform/Cartography.pm Ref (Cartography) Simple conic projection (conic; equidistant) Module PDL::Transform::Cartography Ccmp PDL::Complex Bad Ccmp does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::Complex Sig a(m=2); b(m=2); [o]c() Ref Complex comparison operator (spaceship). File Complex.pma pp_core_importList PDL::PP Ref Specify what is imported from PDL::Core File PP.pod Module PDL::PP5 SetBrush PDL::IO::GD File IO/GD.pm Module PDL::IO::GDX minover_n_ind PDL::Ufunc Ref Synonym for minimum_n_ind File Ufunc.pm Module PDL::Ufunc`gsl_sf_erfc PDL::GSLSF::ERF Bad gsl_sf_erfc does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Ref Complementary Error Function erfc(x) := 2/Sqrt[Pi] Integrate[Exp[-t^2], {t,x,Infinity}] File GSLSF/ERF.pm Sig double x(); double [o]y(); double [o]e() Module PDL::GSLSF::ERFosetbadtoval PDL::Bad Bad The output always has its bad flag cleared.
If the input piddle does not have its bad flag set, then
values are copied with no replacement. Sig a(); [o]b(); double newval File Bad.pm Ref Replace any bad values by a (non-bad) value. Example $x->inplace->setbadtoval(23);
print "a badflag: ", $x->badflag, "\n";
a badflag: 0 Module PDL::Bad� set_inplace PDL::Core Ref Set the in-place flag on a piddle File Core.pm Module PDL::Core Usage $out = ($in->is_inplace) ? $in : zeroes($in);
$in->set_inplace(0);�qags_meat PDL::GSL::INTEG Module PDL::GSL::INTEG File GSL/INTEG.pm Ref info not available Sig (double a(); double b(); double epsabs();double epsrel(); int limit();
double [o] result(); double [o] abserr();int n();int [o] ierr();int gslwarn();; SV* function) Bad qags_meat does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.� ran_flat_var PDL::GSL::RNG Usage $piddle = $rng->ran_flat_var($a_piddle, $b_piddle); Ref Similar to L</ran_flat> except that it takes the distribution
parameters as a piddle and returns a piddle of equal dimensions. File GSL/RNG.pm Module PDL::GSL::RNGqspaceship PDL::Ops Module PDL::Ops Example $c = $x->spaceship($y,0); # explicit function call
$c = $a <=> $b; # overloaded use
$x->inplace->spaceship($y,0); # modify $x inplace Sig a(); b(); [o]c(); int swap File Ops.pm Ref elementwise "<=>" operation Bad spaceship processes bad values.
The state of the bad-value flag of the output piddles is unknown.m PDL::GSLSF::ELLJAC PDL::GSLSF::ELLJAC File GSLSF/ELLJAC.pm Ref Module: PDL interface to GSL Special Functions_lags PDL::Slices Usage $lags = $x->lags($nthdim,$step,$nlags); Bad lags does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Example $y = $x->lags(0,2,2); Module PDL::Slices Ref Returns a piddle of lags to parent. File Slices.pm Sig P(); C(); int nthdim; int step; int n� bswap8 PDL::IO::Misc Module PDL::IO::Misc Sig x(); Ref Swaps octets of bytes in argument x() File IO/Misc.pm Bad bswap8 does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.6chfd PDL::Slatec Bad chfd does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::Slatec Sig x(n);f(n);d(n);int check();xe(ne);[o]fe(ne);[o]de(ne);int [o]ierr() Ref Interpolate function and derivative values. File Slatec.pm� ButtonPressed PDL::Graphics::TriD::ButtonControl Module PDL::Graphics::TriD::ButtonControl File Graphics/TriD/ButtonControl.pm Ref Activates the viewport the mouse is inside when pressedM PDL::Scilab PDL::Scilab File Scilab.pod Ref Manual: A guide for Scilab users.8 CopyRotated PDL::IO::GD File IO/GD.pm Module PDL::IO::GDJbox2d PDL::Image2D Module PDL::Image2D Example $smoothim = $im->box2d($wx,$wy,$edgezero=1); File Image2D.pm Ref fast 2D boxcar average Sig a(n,m); [o] b(n,m); int wx; int wy; int edgezero Bad box2d does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.� vpdl PDL::Matrix Module PDL::Matrix Example print $v = vpdl [0,1];
[
[0]
[1]
] Ref constructs an object of class PDL::Matrix which is of matrix
dimensions (n x 1) File Matrix.pm,crossp PDL::Primitive Module PDL::Primitive Example $c = crossp $x, $y Ref Cross product of two 3D vectors File Primitive.pm Sig a(tri=3); b(tri); [o] c(tri) Bad crossp does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.� cdiv PDL::FFT Sig ar(); ai(); br(); bi(); [o]cr(); [o]ci() Ref Complex division File FFT.pm Module PDL::FFT Bad cdiv does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.:reshape PDL::Core Ref Change the shape (i.e. dimensions) of a piddle, preserving contents. File Core.pm Example pdl> $x = sequence(10)
pdl> reshape $x,3,4; p $x
[
[0 1 2]
[3 4 5]
[6 7 8]
[9 0 0]
]
pdl> reshape $x,5; p $x
[0 1 2 3 4] Module PDL::Core Usage $x->reshape(NEWDIMS); reshape($x, NEWDIMS);� rint PDL::Math Module PDL::Math File Math.pm Ref Round to integer values in floating-point format. Sig a(); [o]b() Bad rint processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.� getdim PDL::Core Example pdl> p zeroes(10,3,22)->getdim(1)
3 Module PDL::Core File Core.pm Ref Returns the size of the given dimension. Usage $dim0 = $piddle->getdim(0);<index PDL::Slices Bad index barfs if any of the index values are bad. File Slices.pm Ref C<index>, C<index1d>, and C<index2d> provide rudimentary index indirection. Sig a(n); indx ind(); [oca] c() Example $c = index($source,$ind);
$c = index1d($source,$ind);
$c = index2d($source2,$ind1,$ind2); Module PDL::Slicesjdivide PDL::Ops Example $c = divide $x, $y, 0; # explicit call with trailing 0
$c = $x / $y; # overloaded call
$x->inplace->divide($y,0); # modify $x inplace Module PDL::Ops Sig a(); b(); [o]c(); int swap Ref divide two piddles File Ops.pm Bad divide processes bad values.
The state of the bad-value flag of the output piddles is unknown.� and PDL::Ufunc Bad This routine handles bad values. Usage $x = and($data); File Ufunc.pm Ref Return the logical and of all elements in a piddle. Module PDL::Ufunc] PDL::IO::Dicom PDL::IO::Dicom Ref Module: a module for reading DICOM images. File IO/Dicom.pm� interpolate PDL::Primitive Usage ( $yi, $err ) = interpolate($xi, $x, $y) Bad needs major (?) work to handles bad values Module PDL::Primitive Sig xi(); x(n); y(n); [o] yi(); int [o] err() Ref routine for 1D linear interpolation File Primitive.pm� interpolate PDL::Func Ref Returns the interpolated function at a given set of points
(PDL::Func). File Func.pm Module PDL::Func Usage my $yi = $obj->interpolate( $xi );�rvals PDL::Basic Usage $r = rvals $piddle,{OPTIONS};
$r = rvals [OPTIONAL TYPE],$nx,$ny,...{OPTIONS}; Opt Options: File Basic.pm Ref Fills a piddle with radial distance values from some centre. Module PDL::Basic Example pdl> print rvals long,7,7,{Centre=>[2,2]}
[
[2 2 2 2 2 3 4]
[2 1 1 1 2 3 4]
[2 1 0 1 2 3 4]
[2 1 1 1 2 3 4]
[2 2 2 2 2 3 4]
[3 3 3 3 3 4 5]
[4 4 4 4 4 5 5]
]~ PDL::Install::Files PDL::Install::Files Ref Module: Module for use by L<ExtUtils::Depends> and L<Inline> File Install/Files.pm� t_vertical PDL::Transform::Cartography Ref (Cartography) Vertical perspective projection (az.; persp.) File Transform/Cartography.pm Module PDL::Transform::Cartography Usage $t = t_vertical(<options>);s PDL::GSLSF::LAGUERRE PDL::GSLSF::LAGUERRE Ref Module: PDL interface to GSL Special Functions File GSLSF/LAGUERRE.pmWchic PDL::Slatec Bad chic does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::Slatec Sig int ic(two=2);vc(two=2);mflag();x(n);f(n);[o]d(n);wk(nwk);int [o]ierr() File Slatec.pm Ref Calculate the derivatives of (x,f(x)) using cubic Hermite interpolation.C gdImageColorDeallocate PDL::IO::GD Module PDL::IO::GD File IO/GD.pm� squeeze PDL::Core Example $y = $w(0,0)->squeeze; Module PDL::Core File Core.pm Ref eliminate all singleton dimensions (dims of size 1)lgsl_sf_bessel_Kn_scaled PDL::GSLSF::BESSEL Ref Scaled IrRegular Modified Bessel Function exp(-|x|) K_n(x). File GSLSF/BESSEL.pm Sig double x(); double [o]y(); double [o]e(); int n Module PDL::GSLSF::BESSEL Bad gsl_sf_bessel_Kn_scaled does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.� dsum PDL::Ufunc Usage $x = dsum($data); Bad This routine handles bad values. Module PDL::Ufunc File Ufunc.pm Ref Return the sum (in double precision) of all elements in a piddle.|gsl_sf_multiply_err PDL::GSLSF::ELEMENTARY Module PDL::GSLSF::ELEMENTARY Sig double x(); double xe(); double xx(); double xxe(); double [o]y(); double [o]e() File GSLSF/ELEMENTARY.pm Ref Multiplication with associated errors. Bad gsl_sf_multiply_err does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.� gethdr PDL::Core Example $pdl=rfits('file.fits');
$h=$pdl->gethdr;
print "Number of pixels in the X-direction=$$h{NAXIS1}\n"; Module PDL::Core Ref Retrieve header information from a piddle File Core.pmhclip PDL::Primitive Bad hclip processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::Primitive Sig a(); b(); [o] c() File Primitive.pm Ref clip (threshold) C<$a> by C<$b> (C<$b> is upper bound)fgsl_sf_coupling_3j PDL::GSLSF::COUPLING Sig ja(); jb(); jc(); ma(); mb(); mc(); double [o]y(); double [o]e() Ref 3j Symbols: (ja jb jc) over (ma mb mc). File GSLSF/COUPLING.pm Module PDL::GSLSF::COUPLING Bad gsl_sf_coupling_3j does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.6whatis PDL::Doc::Perldl Usage whatis $var
whatis <expression> Ref Describe a perl and/or PDL variable or expression. Useful for
determining the type of an expression, identifying the keys in a hash
or a data structure, or examining WTF an unknown object is. File Doc/Perldl.pm Module PDL::Doc::Perldl< gdImageStringFT PDL::IO::GD Module PDL::IO::GD File IO/GD.pm/ SY PDL::IO::GD Module PDL::IO::GD File IO/GD.pm� shape PDL::Core Usage $shape = $piddle->shape; $shape = shape($piddle); Module PDL::Core Example pdl> p $shape = shape zeroes 10,3,22
[10 3 22] Ref Return piddle dimensions as a piddle File Core.pm� apply PDL::Transform Usage $out = $data->apply($t);
$out = $t->apply($data); Module PDL::Transform Sig data(); PDL::Transform t Ref Apply a transformation to some input coordinates. File Transform.pm> gdImageDashedLine PDL::IO::GD Module PDL::IO::GD File IO/GD.pmbgsl_sf_gegenpoly_n PDL::GSLSF::GEGENBAUER Module PDL::GSLSF::GEGENBAUER File GSLSF/GEGENBAUER.pm Ref Evaluate Gegenbauer polynomials. Sig double x(); double [o]y(); double [o]e(); int n; double lambda Bad gsl_sf_gegenpoly_n does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.� _cabs PDL::Ops Bad _cabs processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::Ops File Ops.pm Ref Returns the absolute (length) of a complex number. Sig a(); [o]b()� ifftnd PDL::FFT Example ifftnd($real,$imag); Module PDL::FFT Ref N-dimensional inverse FFT over all pdl dims of input (inplace) File FFT.pm8 get_Gd_data PDL::IO::GD File IO/GD.pm Module PDL::IO::GD> gdImageStringUp16 PDL::IO::GD Module PDL::IO::GD File IO/GD.pmQrle PDL::Slices Bad rle does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Example $c = floor(4*random(10));
rle($c,$x=null,$y=null);
#or
($x,$y) = rle($c); Module PDL::Slices Ref Run-length encode a vector File Slices.pm Sig c(n); indx [o]a(m); [o]b(m)� sinh PDL::Math Bad sinh processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Sig a(); [o]b() File Math.pm Module PDL::Math sethdr PDL::Core Example $pdl = zeroes(100,100);
$h = {NAXIS=>2, NAXIS1=>100, NAXIS=>100, COMMENT=>"Sample FITS-style header"};
# add a FILENAME field to the header
$$h{FILENAME} = 'file.fits';
$pdl->sethdr( $h ); Module PDL::Core File Core.pm Ref Set header information of a piddleTgsl_sf_Chi PDL::GSLSF::EXPINT File GSLSF/EXPINT.pm Ref Chi(x) := Re[ M_EULER + log(x) + Integrate[(Cosh[t]-1)/t, {t,0,x}] ] Sig double x(); double [o]y(); double [o]e() Module PDL::GSLSF::EXPINT Bad gsl_sf_Chi does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.� warp2d_kernel PDL::Image2D Usage ( $x, $k ) = warp2d_kernel( $name ) Example line warp2d_kernel( "hamming" ); Module PDL::Image2D Ref Return the specified kernel, as used by L</warp2d> File Image2D.pmUindex2d PDL::Slices Bad index2d barfs if either of the index values are bad. Sig a(na,nb); indx inda(); indx indb(); [oca] c() Ref C<index>, C<index1d>, and C<index2d> provide rudimentary index indirection. File Slices.pm Module PDL::Slices Example $c = index($source,$ind);
$c = index1d($source,$ind);
$c = index2d($source2,$ind1,$ind2);� ran_dir PDL::GSL::RNG Usage $piddle = $rng->ran_dir($ndim,$n); Ref Returns C<$n> random vectors in C<$ndim> dimensions. File GSL/RNG.pm Module PDL::GSL::RNG Example $o = $rng->ran_dir($ndim,$n);Wset_autopthread_size PDL::Core File Core.pm Ref Set the minimum size (in M-elements or 2^20 elements) of the largest PDL involved in a function where auto-pthreading will
be performed. For small PDLs, it probably isn't worth starting multiple pthreads, so this function
is used to define a minimum threshold where auto-pthreading won't be attempted. Module PDL::Core Example # Example turning on auto-pthreading for a target of 2 pthreads and for functions involving
# PDLs with greater than 1M elements
set_autopthread_targ(2);
set_autopthread_size(1); Usage set_autopthread_size($size);^ PDL::AutoLoader PDL::AutoLoader Ref Module: MatLab style AutoLoader for PDL File AutoLoader.pmt PDL::GSL::INTEG PDL::GSL::INTEG Ref Module: PDL interface to numerical integration routines in GSL File GSL/INTEG.pmXpctover PDL::Ufunc Usage $y = pctover($x, $p); Bad pctover processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::Ufunc Example $spectrum = pctover $image->xchg(0,1), $p Sig a(n); p(); [o]b(); [t]tmp(n) Ref Project via percentile to N-1 dimensions File Ufunc.pm� det PDL::MatrixOps Usage $det = det($a,{opt}); Ref Determinant of a square matrix using LU decomposition (for large matrices) File MatrixOps.pm Sig a(m,m); sv opt Module PDL::MatrixOps? mn_contour PDL::Minuit Module PDL::Minuit File Minuit.pm Usage qne PDL::Ops Module PDL::Ops Example $c = ne $x, $y, 0; # explicit call with trailing 0
$c = $x != $y; # overloaded call
$x->inplace->ne($y,0); # modify $x inplace Sig a(); b(); [o]c(); int swap Ref binary I<not equal to> operation (C<!=>) File Ops.pm Bad ne processes bad values.
The state of the bad-value flag of the output piddles is unknown.tgsl_sf_bessel_Knu_scaled PDL::GSLSF::BESSEL Ref Scaled Modified Cylindrical Bessel Function exp(-|x|) K_nu(x). File GSLSF/BESSEL.pm Sig double x(); double [o]y(); double [o]e(); double n Module PDL::GSLSF::BESSEL Bad gsl_sf_bessel_Knu_scaled does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.1 Fill PDL::IO::GD File IO/GD.pm Module PDL::IO::GD� rgrep PDL::IO::Misc Module PDL::IO::Misc Example ($x,$y) = rgrep {/Foo (.*) Bar (.*) Mumble/} $file; Ref Read columns into piddles using full regexp pattern matching. File IO/Misc.pm Usage ($x,$y,...) = rgrep(sub, *HANDLE|"filename")gsl_sf_elljac PDL::GSLSF::ELLJAC Bad gsl_sf_elljac does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. File GSLSF/ELLJAC.pm Ref Jacobian elliptic functions sn, dn, cn by descending Landen transformations Sig double u(); double m(); double [o]sn(); double [o]cn(); double [o]dn() Module PDL::GSLSF::ELLJAC_simq PDL::MatrixOps Bad simq ignores the bad-value flag of the input piddles.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Sig [phys]a(n,n); [phys]b(n); [o,phys]x(n); int [o,phys]ips(n); int flag Ref Solution of simultaneous linear equations, C<a x = b>. File MatrixOps.pm Module PDL::MatrixOps%minmaximum PDL::Ufunc Ref Find minimum and maximum and their indices for a given piddle; File Ufunc.pm Sig a(n); [o]cmin(); [o] cmax(); indx [o]cmin_ind(); indx [o]cmax_ind() Module PDL::Ufunc Bad If C<a()> contains only bad data, then the output piddles will
be set bad, along with their bad flag.
Otherwise they will have their bad flags cleared,
since they will not contain any bad values. Usage pdl> $x=pdl [[-2,3,4],[1,0,3]]
pdl> ($min, $max, $min_ind, $max_ind)=minmaximum($x)
pdl> p $min, $max, $min_ind, $max_ind
[-2 0] [4 3] [0 1] [2 2]2 Alpha PDL::IO::GD File IO/GD.pm Module PDL::IO::GD+gsl_sf_erf_Q PDL::GSLSF::ERF Bad gsl_sf_erf_Q does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::GSLSF::ERF File GSLSF/ERF.pm Ref Q(x) : Abramowitz+Stegun 26.2.1 Sig double x(); double [o]y(); double [o]e()W PDL::Compression PDL::Compression Ref Module: compression utilities File Compression.pm� applywarp2d PDL::Image2D Usage ( $x, $y ) = applywarp2d( $px, $py, $u, $v ) Module PDL::Image2D File Image2D.pm Ref Transform a set of points using a 2-D polynomial mapping; sync PDL::DiskCache File DiskCache.pm Module PDL::DiskCache� getndims PDL::Core Example pdl> p zeroes(10,3,22)->getndims
3 Module PDL::Core Ref Returns the number of dimensions in a piddle File Core.pm Usage $ndims = $piddle->getndims;�gsl_sf_ellint_Kcomp PDL::GSLSF::ELLINT Bad gsl_sf_ellint_Kcomp does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Ref Legendre form of complete elliptic integrals K(k) = Integral[1/Sqrt[1 - k^2 Sin[t]^2], {t, 0, Pi/2}]. File GSLSF/ELLINT.pm Sig double k(); double [o]y(); double [o]e() Module PDL::GSLSF::ELLINT@ gdImageSetThickness PDL::IO::GD Module PDL::IO::GD File IO/GD.pm� scheme PDL::Func Usage my $scheme = $obj->scheme; File Func.pm Ref Return the type of interpolation of a PDL::Func object. Module PDL::Func�rice_expand PDL::Compression Usage ($out, $len, $blocksize, $dim0) = $pdl->rice_compress;
$copy = $out->rice_expand($dim0, $blocksize); Bad rice_expand ignores the bad-value flag of the input piddles.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::Compression Ref Unsquishes a PDL that has been squished by rice_compress. File Compression.pm Sig in(n); [o]out(m); lbuf(n); int blocksize; gdImagePolygon PDL::IO::GD Module PDL::IO::GD File IO/GD.pm�bilin2d PDL::Image2D Bad bilin2d ignores the bad-value flag of the input piddles.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Sig Int(n,m); O(q,p) Ref Bilinearly maps the first piddle in the second. The
interpolated values are actually added to the second
piddle which is supposed to be larger than the first one. File Image2D.pm Module PDL::Image2Dhgsl_sf_bessel_Y_array PDL::GSLSF::BESSEL Bad gsl_sf_bessel_Y_array does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Ref Array of Regular Bessel Functions Y_{s}(x) to Y_{s+n-1}(x). File GSLSF/BESSEL.pm Sig double x(); double [o]y(num); int s; int n=>num Module PDL::GSLSF::BESSEL� ran_shuffle_vec PDL::GSL::RNG Ref Shuffles values in piddle File GSL/RNG.pm Module PDL::GSL::RNG Usage $rng->ran_shuffle_vec(@vec);6mnstat PDL::Minuit Bad mnstat does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Sig double [o] a(); double [o] b(); double [o] c(); int [o] ia(); int [o] ib(); int [o] ic() Ref info not available File Minuit.pm Module PDL::Minuit� t_rot PDL::Transform Usage $f = t_rot(<rotation-in-degrees>) Module PDL::Transform File Transform.pm Ref Convenience interface to L</t_linear>.` PDL::IO::Dumper PDL::IO::Dumper File IO/Dumper.pm Ref Module: data dumping for structs with PDLs� glXSwapBuffers PDL::Graphics::OpenGL::Perl::OpenGL File Graphics/OpenGL/Perl/OpenGL.pm Module PDL::Graphics::OpenGL::Perl::OpenGL7 FilledArcs PDL::IO::GD Module PDL::IO::GD File IO/GD.pm� mninit PDL::Minuit Bad mninit does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Sig int a();int b(); int c() Ref info not available File Minuit.pm Module PDL::Minuit/gsl_sf_transport_3 PDL::GSLSF::TRANSPORT Module PDL::GSLSF::TRANSPORT Sig double x(); double [o]y(); double [o]e() File GSLSF/TRANSPORT.pm Ref J(3,x) Bad gsl_sf_transport_3 does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.� mapflex PDL::IO::FlexRaw File IO/FlexRaw.pm Ref Memory map a binary file with flexible format specification Module PDL::IO::FlexRaw Opt All of these options default to false unless set true: Usage o pp_bless PDL::PP Ref Sets the package to which the XS code is added (default is PDL) File PP.pod Module PDL::PPi2C PDL::Complex Module PDL::Complex Ref convert imaginary to complex, assuming a real part of zero File Complex.pm Sig r(); [o]c(m=2) Bad i2C does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.7oddpctover PDL::Ufunc File Ufunc.pm Sig a(n); p(); [o]b(); [t]tmp(n) Module PDL::Ufunc Example $spectrum = oddpctover $image->xchg(0,1), $p Bad oddpctover processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Usage $y = oddpctover($x, $p);| PDL::GSL::MROOT PDL::GSL::MROOT File GSL/MROOT.pm Ref Module: PDL interface to multidimensional root-finding routines in GSLxchg PDL::Slices Module PDL::Slices Example $y = $x->xchg(2,3); File Slices.pm Ref exchange two dimensions Sig P(); C(); int n1; int n2 Bad xchg does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.� callext PDL::CallExt Module PDL::CallExt File CallExt.pm Ref Call a function in an external library using Perl dynamic loading Usage callext('file.so', 'foofunc', $x, $y); # pass piddles to foofunc()nccNcompt PDL::Image2D Bad ccNcompt ignores the bad-value flag of the input piddles.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Example $segmented = ccNcompt( $image > $threshold, 4); Module PDL::Image2D Sig a(m,n); int+ [o]b(m,n); int con File Image2D.pm Ref Connected component labeling of a binary image. canreduce PDL::Reduce Ref return list of valid named C<reduce> operations
Some common operations can be accessed using a
number of names, e.g. C<'+'>, C<add> and C<plus>
all sum the elements along the chosen dimension. File Reduce.pm Module PDL::Reduce Example @ops = PDL->canreduce;� Cmul PDL::Complex Bad Cmul does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Sig a(m=2); b(m=2); [o]c(m=2) Ref complex multiplication File Complex.pm Module PDL::ComplexF gdImageTrueColorToPalette PDL::IO::GD File IO/GD.pm Module PDL::IO::GDg t_zenithal PDL::Transform::Cartography File Transform/Cartography.pm Module PDL::Transform::Cartography< ColorClosestHWB PDL::IO::GD Module PDL::IO::GD File IO/GD.pmL PDL::Ops PDL::Ops File Ops.pm Ref Module: Fundamental mathematical operatorsFran_exppow PDL::GSL::RNG Usage $piddle = $rng->ran_exppow($pa,$pb,[list of integers = output piddle dims]);
$rng->ran_exppow($pa,$pb,$output_piddle); Module PDL::GSL::RNG Ref Fills output piddle with random variates from the exponential power distribution with scale
parameter C<$pa> and exponent C<$pb>. File GSL/RNG.pmacoldhot_colortable PDL::Graphics::TriD::Contours Ref A simple colortable function for use with the set_colortable function. File Graphics/TriD/Contours.pm Module PDL::Graphics::TriD::Contours Usage coldhot_colortable defines a blue red spectrum of colors where the
smallest contour value is blue, the highest is red and the others are
shades in between.
bessy1 PDL::Math Module PDL::Math Sig a(); [o]b() Ref The regular Bessel function of the second kind, Y_n. Works inplace. File Math.pm Bad bessy1 processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.Arpic PDL::IO::Pic Opt FORMAT => 'JPEG' # explicitly read this format
XTRAFLAGS => '-nolut' # additional flags for converter Ref Read images in many formats with automatic format detection. File IO/Pic.pm Example $im = rpic $file;
$im = PDL->rpic 'PDL.jpg' if PDL->rpiccan('JPEG'); Module PDL::IO::Pic%vsearch PDL::Primitive Example use PDL; Module PDL::Primitive Ref Efficiently search for values in a sorted piddle, returning indices. File Primitive.pm Sig vals(); xs(n); [o] indx(); [\%options] Usage $idx = vsearch( $vals, $x, [\%options] );
vsearch( $vals, $x, $idx, [\%options ] );r callext_cc PDL::CallExt Usage Module PDL::CallExt File CallExt.pm Ref Compile external C code for dynamic loadingr2C PDL::Complex Bad r2C does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::Complex Sig r(); [o]c(m=2) File Complex.pm Ref convert real to complex, assuming an imaginary part of zero1 mapfld PDL::Types Module PDL::Types File Types.pm�qag_meat PDL::GSL::INTEG Module PDL::GSL::INTEG File GSL/INTEG.pm Ref info not available Sig (double a(); double b(); double epsabs();double epsrel(); int limit();
int key(); double [o] result(); double [o] abserr();int n();int [o] ierr();int gslwarn();; SV* function) Bad qag_meat does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.igsl_sf_bessel_y_array PDL::GSLSF::BESSEL Bad gsl_sf_bessel_y_array does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Sig double x(); double [o]y(num); int n=>num Ref Array of Regular Spherical Bessel Functions y_{0}(x) to y_{n-1}(x). File GSLSF/BESSEL.pm Module PDL::GSLSF::BESSEL� t_spherical PDL::Transform Usage $t = t_spherical(<options>); Module PDL::Transform File Transform.pm Ref Convert Cartesian to spherical coordinates. (3-D; with inverse)Ucombcoords PDL::Graphics::TriD::Rout Sig (x(); y(); z();
float [o]coords(tri=3);) Ref Combine three coordinates into a single piddle. File Graphics/TriD/Rout.pm Module PDL::Graphics::TriD::Rout Bad combcoords does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.whichND PDL::Primitive Usage WhichND returns the N-dimensional coordinates of each nonzero value in
a mask PDL with any number of dimensions. The returned values arrive
as an array-of-vectors suitable for use in
L<indexND|PDL::Slices/indexND> or L<range|PDL::Slices/range>. Ref Return the coordinates of non-zero values in a mask. File Primitive.pm Module PDL::Primitive Example pdl> $s=sequence(10,10,3,4)
pdl> ($x, $y, $z, $w)=whichND($s == 203); p $x, $y, $z, $w
[3] [0] [2] [0]
pdl> print $s->at(list(cat($x,$y,$z,$w)))
203� ezffti PDL::Slatec Bad ezffti does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::Slatec Sig int n();[o]wsave(foo) File Slatec.pmm PDL::GSLSF::HYPERG PDL::GSLSF::HYPERG Ref Module: PDL interface to GSL Special Functions File GSLSF/HYPERG.pm� patch2d PDL::Image2D Module PDL::Image2D Sig a(m,n); int bad(m,n); [o]b(m,n) Ref patch bad pixels out of 2D images using a mask File Image2D.pm Usage $patched = patch2d $data, $bad; Bad This routine does not handle bad values - use L</patchbad2d> insteadg zeros PDL::Core Module PDL::Core Ref construct a zero filled piddle (see zeroes for usage) File Core.pm� PDL::ParallelCPU PDL::ParallelCPU File ParallelCPU.pod Ref Manual: Parallel Processor MultiThreading Support in PDL (Experimental)ran_pascal_var PDL::GSL::RNG Usage $piddle = $rng->ran_pascal_var($p_piddle, $n_piddle); File GSL/RNG.pm Ref Similar to L</ran_pascal> except that it takes the distribution
parameters as a piddle and returns a piddle of equal dimensions. Module PDL::GSL::RNGvget_int PDL::GSL::RNG Usage $piddle = $rng->get($max, $list_of_integers)
$rng->get($max, $piddle); Module PDL::GSL::RNG Example $x = zeroes 5,6; $max=100;
$o = $rng->get(10,10); $rng->get($x); File GSL/RNG.pm Ref This function creates a piddle with given dimensions or accepts an
existing piddle and fills it. get_int() returns integer values
between 0 and $max.G gdImageColorAllocateAlphas PDL::IO::GD Module PDL::IO::GD File IO/GD.pm<mnpout PDL::Minuit Module PDL::Minuit Ref info not available File Minuit.pm Sig int ia(); double [o] a(); double [o] b(); double [o] c(); double [o] d();int [o] ib(); SV* str Bad mnpout does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.�eigens PDL::MatrixOps Bad eigens ignores the bad-value flag of the input piddles.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Usage ($ev, $e) = eigens($x); # e'vects & e'vals
$e = eigens($x); # just eigenvalues File MatrixOps.pm Ref Real eigenvalues and -vectors of a real square matrix. Sig [phys]a(m); [o,phys]ev(l,n,n); [o,phys]e(l,n) Module PDL::MatrixOps� minimum_n_ind PDL::Ufunc Bad Not yet been converted to ignore bad values Module PDL::Ufunc Sig a(n); indx [o]c(m) File Ufunc.pm Ref Returns the index of C<m> minimum elementsLdprodover PDL::Ufunc Module PDL::Ufunc Example $spectrum = dprodover $image->xchg(0,1) File Ufunc.pm Ref Project via product to N-1 dimensions Sig a(n); double [o]b() Usage $y = dprodover($x); Bad dprodover processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.�gsl_sf_hyperg_2F0 PDL::GSLSF::HYPERG Bad gsl_sf_hyperg_2F0 does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::GSLSF::HYPERG File GSLSF/HYPERG.pm Ref Mysterious hypergeometric function. The series representation is a divergent hypergeometric series. However, for x < 0 we have 2F0(a,b,x) = (-1/x)^a U(a,1+a-b,-1/x) Sig double x(); double [o]y(); double [o]e(); double a; double bMcprodover PDL::Ufunc Usage $y = dprodover($x); Bad cprodover processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Example $spectrum = dprodover $image->xchg(0,1) Module PDL::Ufunc Sig a(n); cdouble [o]b() Ref Project via product to N-1 dimensions File Ufunc.pm| PDL::GSLSF::FERMI_DIRAC PDL::GSLSF::FERMI_DIRAC Ref Module: PDL interface to GSL Special Functions File GSLSF/FERMI_DIRAC.pm= gdImageSaveAlpha PDL::IO::GD Module PDL::IO::GD File IO/GD.pm� davg PDL::Ufunc File Ufunc.pm Ref Return the average (in double precision) of all elements in a piddle. Module PDL::Ufunc Bad This routine handles bad values. Usage $x = davg($data);, indx PDL::Core File Core.pm Module PDL::Coregsl_sf_exp PDL::GSLSF::EXP Ref Exponential File GSLSF/EXP.pm Sig double x(); double [o]y(); double [o]e() Module PDL::GSLSF::EXP Bad gsl_sf_exp does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.G pp_def PDL::PP Ref Define a new PDL function File PP.pod Module PDL::PP� eigsys PDL::Slatec File Slatec.pm Ref Eigenvalues and eigenvectors of a real positive definite symmetric matrix. Module PDL::Slatec Usage ($eigvals,$eigvecs) = eigsys($mat)=gsl_sf_legendre_Plm PDL::GSLSF::LEGENDRE File GSLSF/LEGENDRE.pm Ref P_lm(x) Sig double x(); double [o]y(); double [o]e(); int l; int m Module PDL::GSLSF::LEGENDRE Bad gsl_sf_legendre_Plm does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.x pp_line_numbers PDL::PP File PP.pod Ref Add line number information to simplify debugging of PDL::PP code Module PDL::PPmatmult PDL::Primitive Sig a(t,h); b(w,t); [o]c(w,h) Ref Matrix multiplication File Primitive.pm Module PDL::Primitive Bad matmult ignores the bad-value flag of the input piddles.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.h ylinvals PDL::Basic File Basic.pm Ref Y axis values between endpoints (see L</yvals>). Module PDL::Basicrdiagonal PDL::Core Module PDL::Core Example pdl> $x = zeroes(3,3,3);
pdl> ($y = $x->diagonal(0,1))++;
pdl> p $x
[
[
[1 0 0]
[0 1 0]
[0 0 1]
]
[
[1 0 0]
[0 1 0]
[0 0 1]
]
[
[1 0 0]
[0 1 0]
[0 0 1]
]
] Ref Returns the multidimensional diagonal over the specified dimensions. File Core.pm Usage $d = $x->diagonal(dim1, dim2,...)^match PDL::Transform Usage $y = $x->match($c); # Match $c's header and size
$y = $x->match([100,200]); # Rescale to 100x200 pixels
$y = $x->match([100,200],{rect=>1}); # Rescale and remove rotation/skew. Ref Resample a scientific image to the same coordinate system as another. File Transform.pm Module PDL::Transform� Casin PDL::Complex Bad Casin does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Ref Works inplace File Complex.pm Sig a(m=2); [o]c(m=2) Module PDL::Complex init PDL::Func Ref Create a PDL::Func object, which can interpolate, and possibly
integrate and calculate gradients of a dataset. File Func.pm Module PDL::Func Usage $obj = PDL::Func->init( Interpolate => "Hermite", x => $x, y => $y );
$obj = PDL::Func->init( { x => $x, y => $y } );�init PDL::GSL::INTERP Usage File GSL/INTERP.pm Ref The init method initializes a new instance of INTERP. It needs as
input an interpolation type and two piddles holding the x and y
values to be interpolated. The GSL routines require that x be
monotonically increasing and a quicksort is performed by default to
ensure that. You can skip the quicksort by passing the option
{Sort => 0}. Module PDL::GSL::INTERP Example Example:� gslinteg_qags PDL::GSL::INTEG Usage Ref Please check the GSL documentation for more information. File GSL/INTEG.pm Example Example: Module PDL::GSL::INTEG� Cacos PDL::Complex Module PDL::Complex Ref Works inplace File Complex.pm Sig a(m=2); [o]c(m=2) Bad Cacos does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.� get_autopthread_size PDL::Core Usage $autopthread_size = get_autopthread_size(); Module PDL::Core File Core.pm Ref Get the current autopthread_size setting.- short PDL::Core File Core.pm Module PDL::Core9 ColorResolve PDL::IO::GD File IO/GD.pm Module PDL::IO::GD� name PDL::GSL::RNG Example $name = $rng->name(); Module PDL::GSL::RNG Ref Returns the name of the RNG. File GSL/RNG.pm Usage $string = $rng->name();7 write_Jpeg PDL::IO::GD File IO/GD.pm Module PDL::IO::GD� ci PDL::Ops Sig cdouble [o]b() File Ops.pm Module PDL::Ops Bad ci processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles., long PDL::Core File Core.pm Module PDL::Core> gdImageBoundsSafe PDL::IO::GD File IO/GD.pm Module PDL::IO::GD� s_identity PDL::Slices File Slices.pm Ref Internal vaffine identity function. Sig P(); C() Module PDL::Slices Bad s_identity processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.� glpRasterFont PDL::Graphics::OpenGL::Perl::OpenGL File Graphics/OpenGL/Perl/OpenGL.pm Module PDL::Graphics::OpenGL::Perl::OpenGLNchsp PDL::Slatec File Slatec.pm Ref Calculate the derivatives of (x,f(x)) using cubic spline interpolation. Sig int ic(two=2);vc(two=2);x(n);f(n);[o]d(n);wk(nwk);int [o]ierr() Module PDL::Slatec Bad chsp does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.6 write_Gd2 PDL::IO::GD File IO/GD.pm Module PDL::IO::GD: ColorAllocate PDL::IO::GD Module PDL::IO::GD File IO/GD.pmidentvaff PDL::Slices Bad identvaff does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::Slices Sig P(); C() Ref A vaffine identity transformation (includes thread_id copying). File Slices.pm� iiscirc PDL::Graphics::IIS Usage iiscirc $x, $y, [$radius, $colour] Module PDL::Graphics::IIS Sig x(),y(),radius(),colour() Ref Draws a circle on a IIS device (e.g. SAOimage/Ximtool) File Graphics/IIS.pm� bswap2 PDL::IO::Misc File IO/Misc.pm Ref Swaps pairs of bytes in argument x() Sig x(); Module PDL::IO::Misc Bad bswap2 does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.6 TrueColor PDL::IO::GD File IO/GD.pm Module PDL::IO::GD�med2d PDL::Image2D Opt Boundary - controls what values are assumed for the image when kernel
crosses its edge:
=> Default - periodic boundary conditions (i.e. wrap around axis)
=> Reflect - reflect at boundary
=> Truncate - truncate at boundary
=> Replicate - repeat boundary pixel values Usage $new = med2d $old, $kernel, {OPTIONS} Example $smoothed = med2d $image, ones(3,3), {Boundary => Reflect} Module PDL::Image2D File Image2D.pm Ref 2D median-convolution of an array with a kernel (smoothing) Bad Bad values are ignored in the calculation. If all elements within the
kernel are bad, the output is set bad. Sig a(m,n); kern(p,q); [o]b(m,n); int opt� ran_ver PDL::GSL::RNG Module PDL::GSL::RNG Ref Returns a piddle with C<$n> values generated by the Verhulst map from C<$x0> and
parameter C<$r>. File GSL/RNG.pm Usage $rng->ran_ver($x0, $r, $n);Dcumuprodover PDL::Ufunc Usage $y = cumuprodover($x); Bad cumuprodover processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Example $spectrum = cumuprodover $image->xchg(0,1) Module PDL::Ufunc Ref Cumulative product File Ufunc.pm Sig a(n); int+ [o]b(n)X PDL::Minuit PDL::Minuit File Minuit.pm Ref Module: a PDL interface to the Minuit libraryM mn_excm PDL::Minuit File Minuit.pm Example Example: Module PDL::Minuit Usage �t_inverse PDL::Transform Usage $t2 = t_inverse($t);
$t2 = $t->inverse;
$t2 = $t ** -1;
$t2 = !$t; Module PDL::Transform File Transform.pm Ref Return the inverse of a PDL::Transform. This just reverses the
func/inv, idim/odim, itype/otype, and iunit/ounit pairs. Note that
sometimes you end up with a transform that cannot be applied or
mapped, because either the mathematical inverse doesn't exist or the
inverse func isn't implemented.� unwind PDL::Core Usage $y = $x->unwind; Ref Return a piddle which is the same as the argument except
that all threadids have been removed. File Core.pm Module PDL::CoreBhdrcpy PDL::Core Example print "hdrs will be copied" if $x->hdrcpy;
$x->hdrcpy(1); # switch on automatic header copying
$y = $x->sumover; # and $y will inherit $x's hdr
$x->hdrcpy(0); # and now make $x non-infectious again Module PDL::Core Ref switch on/off/examine automatic header copying File Core.pm2 Lines PDL::IO::GD File IO/GD.pm Module PDL::IO::GD gsl_sf_coulomb_wave_sphF_array PDL::GSLSF::COULOMB Bad gsl_sf_coulomb_wave_sphF_array does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::GSLSF::COULOMB Sig double x(); double [o]fc(n); int [o]ovfw(); double [o]fe(n); double lam_min; int kmax=>n; double eta File GSLSF/COULOMB.pm Ref Coulomb wave function divided by the argument, F(xi, eta)/xi. This is the function which reduces to spherical Bessel functions in the limit eta->0. ibandover PDL::Ufunc Bad 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,
as it will not contain any bad values. Usage $y = bandover($x); Sig a(n); [o]b() Ref Project via bitwise and to N-1 dimensions File Ufunc.pm Example $spectrum = bandover $image->xchg(0,1) Module PDL::Ufunc� get_autopthread_actual PDL::Core Usage $autopthread_actual = get_autopthread_actual(); File Core.pm Ref Get the actual number of pthreads executed for the last pdl processing function. Module PDL::Core: get_WBMP_data PDL::IO::GD Module PDL::IO::GD File IO/GD.pm0 Arc PDL::IO::GD File IO/GD.pm Module PDL::IO::GDhwrite_true_png_ex PDL::IO::GD Module PDL::IO::GD Sig img(x,y,z); char* filename; int level Ref Same as write_true_png(), except you can specify the compression level (0-9) as the last argument. File IO/GD.pm Bad write_true_png_ex does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.(nslice_if_pdl PDL::Core Module PDL::Core File Core.pm Ref If C<$self> is a PDL, then calls C<slice> with all but the last
argument, otherwise $self->($_[-1]) is called where $_[-1} is the
original argument string found during PDL::NiceSlice filtering. Usage $w = $x->nslice_if_pdl(...,'(args)');h PDL::Filter::LinPred PDL::Filter::LinPred Ref Module: Linear predictive filtering File Filter/LinPred.pmA gdImageGetInterlaced PDL::IO::GD Module PDL::IO::GD File IO/GD.pmtgsl_sf_bessel_Inu_scaled PDL::GSLSF::BESSEL Bad gsl_sf_bessel_Inu_scaled does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Ref Scaled Modified Cylindrical Bessel Function exp(-|x|) I_nu(x). File GSLSF/BESSEL.pm Sig double x(); double [o]y(); double [o]e(); double n Module PDL::GSLSF::BESSEL{setops PDL::Primitive Module PDL::Primitive Example You will very often use these functions on an index vector, so that is
what we will show here. We will in fact something slightly silly. First
we will find all squares that are also cubes below 10000. Ref Implements simple set operations like union and intersection File Primitive.pm Usage $set = setops($x, <OPERATOR>, $y);� gslinteg_qawc PDL::GSL::INTEG Ref Please check the GSL documentation for more information. File GSL/INTEG.pm Module PDL::GSL::INTEG Example Example: Usage 6 write_Png PDL::IO::GD Module PDL::IO::GD File IO/GD.pm� tan PDL::Math Bad tan processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::Math File Math.pm Sig a(); [o]b()ceil PDL::Math Bad ceil processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::Math File Math.pm Ref Round to integer values in floating-point format. Works inplace. Sig a(); [o]b()j PDL::GSLSF::DILOG PDL::GSLSF::DILOG Ref Module: PDL interface to GSL Special Functions File GSLSF/DILOG.pm? gdImageCopyRotated PDL::IO::GD Module PDL::IO::GD File IO/GD.pmran_pareto_var PDL::GSL::RNG Ref Similar to L</ran_pareto> except that it takes the distribution
parameters as a piddle and returns a piddle of equal dimensions. File GSL/RNG.pm Module PDL::GSL::RNG Usage $piddle = $rng->ran_pareto_var($a_piddle, $b_piddle);^ release3d PDL::Graphics::TriD File Graphics/TriD.pm Module PDL::Graphics::TriD Crossref hold3d�fitgauss1dr PDL::Fit::Gaussian Ref Fit 1D Gassian to radial data piddle File Fit/Gaussian.pm Sig xval(n); data(n); [o]peak_ht(); [o]fwhm();
[o]background();int [o]err(); [o]datafit(n);
[t]sig(n); [t]ytmp(n); [t]yytmp(n); [t]rtmp(n); Module PDL::Fit::Gaussian Example ($pk, $fwhm2, $back, $err, $fit) = fitgauss1dr($r, $data); Usage ($pk, $fwhm2, $back, $err, $fit) = fitgauss1dr($r, $data);imageformat PDL::IO::Pic Module PDL::IO::Pic Example $format=imageformat($path); # find out image format of certain file
print "Unknown image format" if $format eq 'UNKNOWN';
$canread=rpiccan($format); # check if this format is readable in this system
if($canread){
$pdl=rpic($path) ; # attempt to read image ONLY if we can
} else {
print "Image can't be read\n"; # skip unreadable file
} Ref Figure out the format of an image file from its magic numbers, or else, from its extension. File IO/Pic.pmhminus PDL::Ops Sig a(); b(); [o]c(); int swap File Ops.pm Ref subtract two piddles Example $c = minus $x, $y, 0; # explicit call with trailing 0
$c = $x - $y; # overloaded call
$x->inplace->minus($y,0); # modify $x inplace Module PDL::Ops Bad minus processes bad values.
The state of the bad-value flag of the output piddles is unknown. ran_levy_var PDL::GSL::RNG Ref Similar to L</ran_levy> except that it takes the distribution
parameters as a piddle and returns a piddle of equal dimensions. File GSL/RNG.pm Module PDL::GSL::RNG Usage $piddle = $rng->ran_levy_var($mu_piddle, $a_piddle);!not PDL::Ops Bad not processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::Ops Example $y = ! $x;
$x->inplace->not; # modify $x inplace Sig a(); [o]b() Ref the elementwise I<not> operation File Ops.pmgor2 PDL::Ops File Ops.pm Ref binary I<or> of two piddles Sig a(); b(); [o]c(); int swap Module PDL::Ops Example $c = or2 $x, $y, 0; # explicit call with trailing 0
$c = $x | $y; # overloaded call
$x->inplace->or2($y,0); # modify $x inplace Bad or2 processes bad values.
The state of the bad-value flag of the output piddles is unknown.j PDL::GSLSF::GAMMA PDL::GSLSF::GAMMA Ref Module: PDL interface to GSL Special Functions File GSLSF/GAMMA.pmggsl_sf_complex_logsin PDL::GSLSF::TRIG Bad gsl_sf_complex_logsin does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Ref Log(Sin(z)) for complex z File GSLSF/TRIG.pm Sig double zr(); double zi(); double [o]x(); double [o]y(); double [o]xe(); double [o]ye() Module PDL::GSLSF::TRIG; gdImageSetClip PDL::IO::GD File IO/GD.pm Module PDL::IO::GD; gdImageAABlend PDL::IO::GD File IO/GD.pm Module PDL::IO::GD0ran_rayleigh PDL::GSL::RNG Ref Fills output piddle with random variates from the Rayleigh distribution with scale parameter C<$sigma>. File GSL/RNG.pm Module PDL::GSL::RNG Usage $piddle = $rng->ran_rayleigh($sigma,[list of integers = output piddle dims]);
$rng->ran_rayleigh($sigma,$output_piddle);ran_geometric_var PDL::GSL::RNG Usage $piddle = $rng->ran_geometric_var($p_piddle); File GSL/RNG.pm Ref Similar to L</ran_geometric> except that it takes the distribution
parameters as a piddle and returns a piddle of equal dimensions. Module PDL::GSL::RNG� t_stereographic PDL::Transform::Cartography Module PDL::Transform::Cartography Ref (Cartography) Stereographic projection (az.; conf.; persp.) File Transform/Cartography.pm Usage $t = t_stereographic(<options>);� vsearch_match PDL::Primitive Bad needs major (?) work to handles bad values Usage $idx = vsearch_match($vals, $x); Sig vals(); x(n); indx [o]idx() Ref Match values against a sorted array. File Primitive.pm Module PDL::Primitive�gsl_sf_hyperg_2F1_renorm PDL::GSLSF::HYPERG Bad gsl_sf_hyperg_2F1_renorm does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::GSLSF::HYPERG Sig double x(); double [o]y(); double [o]e(); double a; double b; double c File GSLSF/HYPERG.pm Ref Renormalized Gauss hypergeometric function 2F1[a,b,c,x] / Gamma[c]� t_unit_sphere PDL::Transform::Cartography Module PDL::Transform::Cartography Ref (Cartography) 3-D globe projection (conformal; authalic) File Transform/Cartography.pm Usage $t = t_unit_sphere(<options>);� rcube PDL::IO::Misc Example $cube = rcube \&rfits, glob("*.fits"); Module PDL::IO::Misc File IO/Misc.pm Ref Read list of files directly into a large data cube (for efficiency) Usage $cube = rcube \&reader_function, @files;P PDL::Slices PDL::Slices File Slices.pm Ref Module: Indexing, slicing, and dicing�statsover PDL::Primitive Usage ($mean,$prms,$median,$min,$max,$adev,$rms) = statsover($piddle, $weights); Bad Bad values are simply ignored in the calculation, effectively reducing
the sample size. If all data are bad then the output data are marked bad. Module PDL::Primitive Sig a(n); w(n); float+ [o]avg(); float+ [o]prms(); int+ [o]median(); int+ [o]min(); int+ [o]max(); float+ [o]adev(); float+ [o]rms() Ref Calculate useful statistics over a dimension of a piddle File Primitive.pm� ppdefs PDL::Types Module PDL::Types Example pdl> @ppdefs = PDL::Types::ppdefs
pdl> print @ppdefs;
B S U L N Q F D File Types.pm Ref Returns an array of pp symbols for all known typesEmncont PDL::Minuit Module PDL::Minuit Sig int ia(); int ib(); int ic(); double [o] a(n); double [o] b(n); int [o] id(); SV* function; int numelem File Minuit.pm Ref info not available Bad mncont does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.:vrmlcoordsvert PDL::Graphics::TriD::Rout Bad vrmlcoordsvert does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Ref info not available File Graphics/TriD/Rout.pm Sig vertices(n=3); char* space; char* fd Module PDL::Graphics::TriD::Rout,oslice PDL::Slices Bad oslice does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Example $x->slice('1:3'); # return the second to fourth elements of $x
$x->slice('3:1'); # reverse the above
$x->slice('-2:1'); # return last-but-one to second elements of $x Module PDL::Slices Ref DEPRECATED: 'oslice' is the original 'slice' routine in pre-2.006_006
versions of PDL. It is left here for reference but will disappear in
PDL 3.000 File Slices.pm Sig P(); C(); char* str!vsearch_bin_inclusive PDL::Primitive Usage $idx = vsearch_bin_inclusive($vals, $x); Bad needs major (?) work to handles bad values Module PDL::Primitive File Primitive.pm Ref Determine the index for values in a sorted array of bins, lower bound inclusive. Sig vals(); x(n); indx [o]idx()A gdImageFilledEllipse PDL::IO::GD Module PDL::IO::GD File IO/GD.pm� zcheck PDL::Ufunc Usage $x = zcheck($data); Bad This routine handles bad values. Module PDL::Ufunc File Ufunc.pm Ref Return the check for zero of all elements in a piddle.Hdaverage PDL::Ufunc Example $spectrum = daverage $image->xchg(0,1) Module PDL::Ufunc Ref Project via average to N-1 dimensions File Ufunc.pm Sig a(n); double [o]b() Usage $y = daverage($x); Bad daverage processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.jchbs PDL::Slatec Bad chbs does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::Slatec Sig x(n);f(n);d(n);int knotyp();int nknots();t(tsize);[o]bcoef(bsize);int [o]ndim();int [o]kord();int [o]ierr() File Slatec.pm Ref Piecewise Cubic Hermite function to B-Spline converter.� PDL::Perldl2::Plugin::CleanErrors PDL::Perldl2::Plugin::CleanErrors File Perldl2/Plugin/CleanErrors.pm Ref Module: filter out Moose cruft�gsl_sf_bessel_K_scaled_array PDL::GSLSF::BESSEL Bad gsl_sf_bessel_K_scaled_array does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Ref Array of Scaled IrRegular Modified Bessel Functions exp(-|x|) K_{s}(x) to exp(-|x|) K_{s+n-1}(x). File GSLSF/BESSEL.pm Sig double x(); double [o]y(num); int s; int n=>num Module PDL::GSLSF::BESSELkcat PDL::Core Module PDL::Core Example pdl> $x = cat ones(3,3),zeroes(3,3),rvals(3,3); p $x
[
[
[1 1 1]
[1 1 1]
[1 1 1]
]
[
[0 0 0]
[0 0 0]
[0 0 0]
]
[
[1 1 1]
[1 0 1]
[1 1 1]
]
] File Core.pm Ref concatenate piddles to N+1 dimensional piddle Bad The output piddle is set bad if any input piddles have their bad flag set.ran_laplace PDL::GSL::RNG File GSL/RNG.pm Ref Fills output piddle with random variates from the Laplace distribution with width C<$pa>. Module PDL::GSL::RNG Usage $piddle = $rng->ran_laplace($pa,[list of integers = output piddle dims]);
$rng->ran_laplace($pa,$output_piddle);Bgsl_sf_bessel_Jn PDL::GSLSF::BESSEL Bad gsl_sf_bessel_Jn does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. File GSLSF/BESSEL.pm Ref Regular Bessel Function J_n(x). Sig double x(); double [o]y(); double [o]e(); int n Module PDL::GSLSF::BESSEL{gsl_sf_fermi_dirac_inc_0 PDL::GSLSF::FERMI_DIRAC Module PDL::GSLSF::FERMI_DIRAC Sig double x(); double [o]y(); double [o]e(); double b File GSLSF/FERMI_DIRAC.pm Ref Incomplete integral F_0(x,b) = ln(1 + e^(b-x)) - (b-x) Bad gsl_sf_fermi_dirac_inc_0 does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.Weigens_sym PDL::MatrixOps Usage ($ev, $e) = eigens_sym($x); # e-vects & e-values
$e = eigens_sym($x); # just eigenvalues Bad eigens_sym ignores the bad-value flag of the input piddles.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::MatrixOps Ref Eigenvalues and -vectors of a symmetric square matrix. If passed
an asymmetric matrix, the routine will warn and symmetrize it, by taking
the average value. That is, it will solve for 0.5*($a+$a->mv(0,1)). File MatrixOps.pm Sig [phys]a(m); [o,phys]ev(n,n); [o,phys]e(n)~get_uniform PDL::GSL::RNG Usage $piddle = $rng->get_uniform($list_of_integers)
$rng->get_uniform($piddle); Module PDL::GSL::RNG Example $x = zeroes 5,6; $max=100;
$o = $rng->get_uniform(10,10); $rng->get_uniform($x); Ref This function creates a piddle with given dimensions or accepts an
existing piddle and fills it. get_uniform() returns values 0<=x<1, File GSL/RNG.pmqgt PDL::Ops Module PDL::Ops Example $c = gt $x, $y, 0; # explicit call with trailing 0
$c = $x > $y; # overloaded call
$x->inplace->gt($y,0); # modify $x inplace Sig a(); b(); [o]c(); int swap File Ops.pm Ref the binary E<gt> (greater than) operation Bad gt processes bad values.
The state of the bad-value flag of the output piddles is unknown.� ran_shuffle PDL::GSL::RNG Usage $rng->ran_shuffle($piddle); Module PDL::GSL::RNG File GSL/RNG.pm Ref Shuffles values in piddle ran_bivariate_gaussian PDL::GSL::RNG Usage $piddle = $rng->ran_bivariate_gaussian($sigma_x,$sigma_y,$rho,$n); Example $o = $rng->ran_bivariate_gaussian(1,2,0.5,1000); Module PDL::GSL::RNG File GSL/RNG.pm Ref Generates C<$n> bivariate gaussian random deviates.�gsl_sf_complex_log PDL::GSLSF::LOG Bad gsl_sf_complex_log does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Sig double zr(); double zi(); double [o]x(); double [o]y(); double [o]xe(); double [o]ye() File GSLSF/LOG.pm Ref Complex Logarithm exp(lnr + I theta) = zr + I zi Returns argument in [-pi,pi]. Module PDL::GSLSF::LOGK PDL::IO::Pnm PDL::IO::Pnm Ref Module: pnm format I/O for PDL File IO/Pnm.pm.gsl_sf_beta PDL::GSLSF::GAMMA Module PDL::GSLSF::GAMMA Ref Beta Function B(a,b) File GSLSF/GAMMA.pm Sig double a(); double b();double [o]y(); double [o]e() Bad gsl_sf_beta does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.� interlrgb PDL::ImageRGB Module PDL::ImageRGB File ImageRGB.pm Ref Make an RGB image from a palette image and its lookup table. Usage $rgb = $palette_im->interlrgb($lut)� erfi PDL::Math Bad erfi processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Ref The inverse of the error function. Works inplace. File Math.pm Sig a(); [o]b() Module PDL::Math{gsl_sf_gegenpoly_array PDL::GSLSF::GEGENBAUER Module PDL::GSLSF::GEGENBAUER File GSLSF/GEGENBAUER.pm Ref Calculate array of Gegenbauer polynomials from 0 to n-1. Sig double x(); double [o]y(num); int n=>num; double lambda Bad gsl_sf_gegenpoly_array does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.y PDL::GSLSF::ELEMENTARY PDL::GSLSF::ELEMENTARY File GSLSF/ELEMENTARY.pm Ref Module: PDL interface to GSL Special Functions� sig PDL::Doc::Perldl Module PDL::Doc::Perldl Example pdl> sig 'outer'
Signature: outer(a(n); b(m); [o]c(n,m)) File Doc/Perldl.pm Ref prints signature of PDL function Usage sig 'func'�polyfill PDL::Image2D Example # Make a convex 3x3 square of 1s in an image using the pnpoly algorithm
$ps = pdl([3,3],[3,6],[6,6],[6,3]);
polyfill($im,$ps,1,{'Method' =>'pnpoly'}); Module PDL::Image2D File Image2D.pm Ref fill the area of the given polygon with the given colour. Opt Method - Set the method used to determine which points lie in the polygon.
=> Default - internal PDL algorithm
=> pnpoly - use the L</pnpoly> algorithm Usage polyfill($im,$ps,$colour,[\%options]);qgsl_sf_bessel_I_array PDL::GSLSF::BESSEL Ref Array of Regular Modified Bessel Functions I_{s}(x) to I_{s+n-1}(x). File GSLSF/BESSEL.pm Sig double x(); double [o]y(num); int s; int n=>num Module PDL::GSLSF::BESSEL Bad gsl_sf_bessel_I_array does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.>gsl_sf_airy_Bi_deriv PDL::GSLSF::AIRY Bad gsl_sf_airy_Bi_deriv does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. File GSLSF/AIRY.pm Ref Derivative Airy Function Bi`(x). Sig double x(); double [o]y(); double [o]e() Module PDL::GSLSF::AIRY@ gdImageColorClosest PDL::IO::GD Module PDL::IO::GD File IO/GD.pm� gslinteg_qagil PDL::GSL::INTEG Ref Please check the GSL documentation for more information. File GSL/INTEG.pm Example Example: Module PDL::GSL::INTEG Usage outer PDL::Primitive Bad outer processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::Primitive Sig a(n); b(m); [o]c(n,m) File Primitive.pm Ref outer product over one dimension]hist PDL::Basic Usage $hist = hist($data);
($xvals,$hist) = hist($data); Example pdl> p $y
[13 10 13 10 9 13 9 12 11 10 10 13 7 6 8 10 11 7 12 9 11 11 12 6 12 7]
pdl> $h = hist $y,0,20,1; # hist with step 1, min 0 and 20 bins
pdl> p $h
[0 0 0 0 0 0 2 3 1 3 5 4 4 4 0 0 0 0 0 0] Module PDL::Basic Ref Create histogram of a piddle File Basic.pm�ran_gaussian_var PDL::GSL::RNG Example $sigma_pdl = rvals zeroes 11,11;
$o = $rng->ran_gaussian_var($sigma_pdl); Module PDL::GSL::RNG Ref This method is similar to L</ran_gaussian> except that it takes
the parameters of the distribution as a piddle and returns a piddle of equal
dimensions. File GSL/RNG.pm Usage $piddle = $rng->ran_gaussian_var($sigma_piddle);
$rng->ran_gaussian_var($sigma_piddle, $output_piddle);: GetInterlaced PDL::IO::GD File IO/GD.pm Module PDL::IO::GD�warp2d PDL::Image2D Example $img = rvals(byte,501,501);
imag $img, { JUSTIFY => 1 };
#
# use a not-particularly-obvious transformation:
# x = -10 + 0.5 * $u - 0.1 * $v
# y = -20 + $v - 0.002 * $u * $v
#
$px = pdl( [ -10, 0.5 ], [ -0.1, 0 ] );
$py = pdl( [ -20, 0 ], [ 1, 0.002 ] );
$wrp = warp2d( $img, $px, $py );
#
# see the warped image
imag $warp, { JUSTIFY => 1 }; Module PDL::Image2D File Image2D.pm Ref Warp a 2D image given a polynomial describing the I<reverse> mapping. Sig img(m,n); double px(np,np); double py(np,np); [o] warp(m,n); { options } Usage $out = warp2d( $img, $px, $py, { options } ); Opt KERNEL - default value is tanh
NOVAL - default value is 08 gdImageLine PDL::IO::GD Module PDL::IO::GD File IO/GD.pmLmn_def_pars PDL::Minuit Module PDL::Minuit Example Example: Ref The function mn_def_pars() defines the initial values of the parameters of the function to
be minimized and the value of the initial steps around these values that the
minimizer will use for the first variations of the parameters in the search for the minimum.
There are several optional arguments. One allows assigning names to these parameters which
otherwise get names (Par_0, Par_1,....,Par_n) by default. Another two arguments can give
lower and upper bounds for the parameters via two piddles. If the lower and upper bound for a
given parameter are both equal to 0 then the parameter is unbound. By default these lower and
upper bound piddles are set to zeroes(n), where n is the number of parameters, i.e. the
parameters are unbound by default. File Minuit.pm Usage � asinh PDL::Math Bad asinh processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. File Math.pm Sig a(); [o]b() Module PDL::Mathd hdr_copy PDL::Core File Core.pm Ref Return an explicit copy of the header of a PDL. Module PDL::Core<gsl_sf_Ci PDL::GSLSF::EXPINT Module PDL::GSLSF::EXPINT File GSLSF/EXPINT.pm Ref Ci(x) := -Integrate[ Cos[t]/t, {t,x,Infinity}] Sig double x(); double [o]y(); double [o]e() Bad gsl_sf_Ci does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.� earth_image PDL::Transform::Cartography Module PDL::Transform::Cartography Ref (Cartography) PDL constructor - RGB pixel map of Earth File Transform/Cartography.pm Usage $rgb = earth_image()t get_dataref PDL::Core File Core.pm Ref Return the internal data for a piddle, as a perl SCALAR ref. Module PDL::Core� isfinite PDL::Math Module PDL::Math Sig a(); int [o]mask() Ref Sets C<$mask> true if C<$a> is not a C<NaN> or C<inf> (either positive or negative). Works inplace. File Math.pm Bad Bad values are treated as C<NaN> or C<inf>.�set_autopthread_targ PDL::Core Example # Example turning on auto-pthreading for a target of 2 pthreads and for functions involving
# PDLs with greater than 1M elements
set_autopthread_targ(2);
set_autopthread_size(1); Module PDL::Core File Core.pm Ref Set the target number of processor threads (pthreads) for multi-threaded processing. Usage set_autopthread_targ($num_pthreads);N PDL::Doc PDL::Doc File Doc.pm Ref Module: support for PDL online documentation� ones PDL::Core Example see zeroes() and add one Module PDL::Core Ref construct a one filled piddle File Core.pm Usage $w = ones([type], $nx, $ny, $nz,...);
etc. (see 'zeroes')@ gdImageColorResolve PDL::IO::GD File IO/GD.pm Module PDL::IO::GDcgsldiff PDL::GSL::DIFF Usage File GSL/DIFF.pm Ref This functions serves as an interface to the three differentiation
functions present in GSL: gsl_diff_central, gsl_diff_backward and
gsl_diff_forward. To compute the derivative, the central method uses
values greater and smaller than the point at which the derivative is
to be evaluated, while backward and forward use only values smaller
and greater respectively. gsldiff() returns both the derivative
and an absolute error estimate. The default method is 'central',
others can be specified by passing an option. Module PDL::GSL::DIFF Example Example:� maximum_ind PDL::Ufunc Sig a(n); indx [o] c() Ref Like maximum but returns the index rather than the value File Ufunc.pm Module PDL::Ufunc Bad Output is set bad if all elements of the input are bad,
otherwise the bad flag is cleared for the output piddle.7 gdImageRed PDL::IO::GD File IO/GD.pm Module PDL::IO::GD{ XPending PDL::Graphics::OpenGL::Perl::OpenGL Module PDL::Graphics::OpenGL::Perl::OpenGL File Graphics/OpenGL/Perl/OpenGL.pm
topdl PDL::Core Usage $x = topdl(SCALAR|ARRAY REFERENCE|ARRAY); Ref alternate piddle constructor - ensures arg is a piddle File Core.pm Module PDL::Core Example use PDL::Core ':Internal'; # use the internal routines of
# the Core moduleGrange PDL::Slices Bad rangeb processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Ref Extract selected chunks from a source piddle, with boundary conditions File Slices.pm Module PDL::Slices Example $out = $source->range($index,[$size,[$boundary]]) howbig PDL::Core Usage use PDL::Core ':Internal'; # use the internal routines of
# the Core module File Core.pm Ref Returns the sizeof a piddle datatype in bytes. Example pdl> p howbig(ushort([1..10])->get_datatype)
2 Module PDL::CoreClog PDL::Complex Bad Clog does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. File Complex.pm Ref log (a) = log (cabs (a)) + i * carg (a). Works inplace Sig a(m=2); [o]c(m=2) Module PDL::Complex� t_fits PDL::Transform Module PDL::Transform Ref FITS pixel-to-scientific transformation with inverse File Transform.pm Usage $f = t_fits($fits,[option]);wpic PDL::IO::Pic Ref Write images in many formats with automatic format selection. File IO/Pic.pm Example wpic $pdl, $file;
$im->wpic('web.gif',{LUT => $lut});
for (@images) {
$_->wpic($name[0],{CONVERTER => 'ppmtogif'})
} Module PDL::IO::Pic Opt CONVERTER => 'ppmtogif', # explicitly specify pbm converter
FLAGS => '-interlaced -transparent 0', # flags for converter
IFORM => 'PGM', # explicitly specify intermediate format
XTRAFLAGS => '-imagename iris', # additional flags to defaultflags
FORMAT => 'PCX', # explicitly specify output image format
COLOR => 'bw', # specify color conversion
LUT => $lut, # use color table information Usage wpic($pdl,$filename[,{ options... }])*maximum PDL::Ufunc Bad Output is set bad if all elements of the input are bad,
otherwise the bad flag is cleared for the output piddle. Usage $y = maximum($x); Sig a(n); [o]c() Ref Project via maximum to N-1 dimensions File Ufunc.pm Example $spectrum = maximum $image->xchg(0,1) Module PDL::Ufunc� mzeroes PDL::Matrix Ref constructs a PDL::Matrix object similar to the piddle constructors
zeroes, ones, sequence. File Matrix.pm Names mzeroes,mones,msequence Module PDL::Matrixd PDL::GSLSF::EXP PDL::GSLSF::EXP File GSLSF/EXP.pm Ref Module: PDL interface to GSL Special Functions;unmap PDL::Transform Usage $out_image = $in_image->unmap($t,[<options>],[<template>]);
$out_image = $t->unmap($in_image,[<options>],[<template>]); File Transform.pm Ref Map an image or N-D dataset using the inverse as a coordinate transform. Sig data(); PDL::Transform a; template(); \%opt Module PDL::Transform�gsl_sf_airy_Ai_deriv_scaled PDL::GSLSF::AIRY Sig double x(); double [o]y(); double [o]e() Ref Derivative Scaled Airy Function Ai(x). Ai`(x) for x < 0 and exp(+2/3 x^{3/2}) Ai`(x) for x > 0. File GSLSF/AIRY.pm Module PDL::GSLSF::AIRY Bad gsl_sf_airy_Ai_deriv_scaled does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. bessj0 PDL::Math Bad bessj0 processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. File Math.pm Ref The regular Bessel function of the first kind, J_n Works inplace. Sig a(); [o]b() Module PDL::Math-Cexp PDL::Complex Bad Cexp does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Sig a(m=2); [o]c(m=2) Ref exp (a) = exp (real (a)) * (cos (imag (a)) + i * sin (imag (a))). Works inplace File Complex.pm Module PDL::Complex�reduce PDL::Reduce Example $x = sequence 5,5;
# reduce by adding all
# elements along 2nd dimension
$y = $x->reduce('add',1);
$y = $x->reduce('plus',1);
$y = $x->reduce('+',1); # three ways to do the same thing # reduce by summing over dims 0 and 2
$result = $pdl->reduce(\&sumover, 0, 2); Module PDL::Reduce File Reduce.pm Ref reduce dimension of piddle by one by applying an operation
along the specified dimension Usage $result = $pdl->reduce($operation [,@dims]);rs PDL::Slatec Module PDL::Slatec File Slatec.pm Sig a(n,n);[o]w(n);int matz();[o]z(n,n);[t]fvone(n);[t]fvtwo(n);int [o]ierr() Bad rs does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.� t_cubic PDL::Transform Usage $t = t_cubic(<options>); Ref Cubic scaling - cubic pincushion (n-d; with inverse) File Transform.pm Module PDL::TransformA gdImageCopyMergeGray PDL::IO::GD File IO/GD.pm Module PDL::IO::GD; gdImageSetTile PDL::IO::GD File IO/GD.pm Module PDL::IO::GD�limits PDL::Graphics::Limits Usage @limits = limits( @datasets );
@limits = limits( @datasets, \%attr );
$limits = limits( @datasets );
$limits = limits( @datasets, \%attr ); Module PDL::Graphics::Limits File Graphics/Limits.pm Ref B<limits> derives global limits for one or more multi-dimensional sets
of data for display purposes. It obtains minimum and maximum limits
for each dimension based upon one of several algorithms.� mnemat PDL::Minuit Module PDL::Minuit Sig double [o] mat(n,n) File Minuit.pm Ref info not available Bad mnemat does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.�rcols PDL::IO::Misc Module PDL::IO::Misc Example For example: File IO/Misc.pm Ref Read specified ASCII cols from a file into piddles and perl
arrays (also see L</rgrep>). Usage ($x,$y,...) = rcols( *HANDLE|"filename", { EXCLUDE => '/^!/' }, $col1, $col2, ... )
$x = rcols( *HANDLE|"filename", { EXCLUDE => '/^!/' }, [] )
($x,$y,...) = rcols( *HANDLE|"filename", $col1, $col2, ..., { EXCLUDE => '/^!/' } )
($x,$y,...) = rcols( *HANDLE|"filename", "/foo/", $col1, $col2, ... )qxor PDL::Ops Ref binary I<exclusive or> of two piddles File Ops.pm Sig a(); b(); [o]c(); int swap Module PDL::Ops Example $c = xor $x, $y, 0; # explicit call with trailing 0
$c = $x ^ $y; # overloaded call
$x->inplace->xor($y,0); # modify $x inplace Bad xor processes bad values.
The state of the bad-value flag of the output piddles is unknown.�gsl_sf_ellint_RF PDL::GSLSF::ELLINT Module PDL::GSLSF::ELLINT Ref Carlsons symmetric basis of functions RF(x,y,z) = 1/2 Integral[(t+x)^(-1/2) (t+y)^(-1/2) (t+z)^(-1/2), {t,0,Inf}] File GSLSF/ELLINT.pm Sig double x(); double yy(); double z(); double [o]y(); double [o]e() Bad gsl_sf_ellint_RF does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.H wpiccan PDL::IO::Pic Crossref rpiccan Module PDL::IO::Pic File IO/Pic.pm� random PDL::Primitive File Primitive.pm Ref Constructor which returns piddle of random numbers Module PDL::Primitive Usage $x = random([type], $nx, $ny, $nz,...);
$x = random $y;� ezfftf PDL::Slatec Module PDL::Slatec Sig r(n);[o]azero();[o]a(n);[o]b(n);wsave(foo) File Slatec.pm Ref Bad ezfftf does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.;gsl_sf_angle_restrict_symm PDL::GSLSF::TRIG Sig double [o]y() File GSLSF/TRIG.pm Ref Force an angle to lie in the range (-pi,pi]. Module PDL::GSLSF::TRIG Bad gsl_sf_angle_restrict_symm does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.� tanh PDL::Math Bad tanh processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Sig a(); [o]b() File Math.pm Module PDL::Math� randsym PDL::Primitive Ref Constructor which returns piddle of random numbers File Primitive.pm Module PDL::Primitive Usage $x = randsym([type], $nx, $ny, $nz,...);
$x = randsym $y;Wgsl_sf_fermi_dirac_3half PDL::GSLSF::FERMI_DIRAC Sig double x(); double [o]y(); double [o]e() Ref Complete integral F_{3/2}(x) File GSLSF/FERMI_DIRAC.pm Module PDL::GSLSF::FERMI_DIRAC Bad gsl_sf_fermi_dirac_3half does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.4 AABlend PDL::IO::GD Module PDL::IO::GD File IO/GD.pmIcaverage PDL::Ufunc Usage $y = daverage($x); Bad caverage processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::Ufunc Example $spectrum = daverage $image->xchg(0,1) Sig a(n); cdouble [o]b() Ref Project via average to N-1 dimensions File Ufunc.pm: get_Jpeg_data PDL::IO::GD Module PDL::IO::GD File IO/GD.pm� dim PDL::Core Module PDL::Core File Core.pm Ref Returns the size of the given dimension of a piddle. Alias
for L<getdim|PDL::Core/getdim>.� isbigendian PDL::IO::Misc Module PDL::IO::Misc Ref Determine endianness of machine - returns 0 or 1 accordingly File IO/Misc.pm� isbigendian PDL::Core::Dev Example print "Your machins is big endian.\n" if isbigendian(); Module PDL::Core::Dev File Core/Dev.pm Ref Is the machine big or little endian? Usage my $retval = isbigendian();6pnminraw PDL::IO::Pnm Bad pnminraw does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Sig (type(); byte+ [o] im(m,n); int ms => m; int ns => n;
int isbin; char* fd) File IO/Pnm.pm Ref Read in a raw pnm file. Module PDL::IO::Pnm� thread_define PDL::Core Ref define functions that support threading at the perl level File Core.pm Module PDL::Core Example thread_define 'tline(a(n);b(n))', over {
line $_[0], $_[1]; # make line compliant with threading
};$gsl_sf_cos PDL::GSLSF::TRIG Bad gsl_sf_cos does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. File GSLSF/TRIG.pm Ref Cos(x) with GSL semantics. Sig double x(); double [o]y(); double [o]e() Module PDL::GSLSF::TRIGD gdImageFilledRectangles PDL::IO::GD File IO/GD.pm Module PDL::IO::GDrld PDL::Slices Bad rld does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Example rld($x,$y,$c=null); Module PDL::Slices Ref Run-length decode a vector File Slices.pm Sig indx a(n); b(n); [o]c(m)XCroots PDL::Complex Bad Croots does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::Complex File Complex.pm Ref Compute the C<n> roots of C<a>. C<n> must be a positive integer. The result will always be a complex type! Sig a(m=2); [o]c(m=2,n); int n => n� rpnm PDL::IO::Pnm Usage $im = rpnm $file; Example $stack = zeroes(byte,3,500,300,4);
rpnm $stack->slice(':,:,:,(0)'),"PDL.ppm"; Module PDL::IO::Pnm File IO/Pnm.pm Ref Read a pnm (portable bitmap/pixmap, pbm/ppm) file into a piddle.� make_physical PDL::Core File Core.pm Ref Make sure the data portion of a piddle can be accessed from XS code. Example $x->make_physical;
$x->call_my_xs_method; Module PDL::Core%ran_beta PDL::GSL::RNG Usage $piddle = $rng->ran_beta($pa,$pb,[list of integers = output piddle dims]);
$rng->ran_beta($pa,$pb,$output_piddle); Module PDL::GSL::RNG File GSL/RNG.pm Ref Fills output piddle with random variates from the beta distribution with parameters C<$pa> and C<$pb>.9 get_Gd2_data PDL::IO::GD Module PDL::IO::GD File IO/GD.pm_plus PDL::Ops Bad plus processes bad values.
The state of the bad-value flag of the output piddles is unknown. Example $c = plus $x, $y, 0; # explicit call with trailing 0
$c = $x + $y; # overloaded call
$x->inplace->plus($y,0); # modify $x inplace Module PDL::Ops File Ops.pm Ref add two piddles Sig a(); b(); [o]c(); int swap�keeptwiddling3d PDL::Graphics::TriD Example keeptwiddling3d();
imag3d(..);
nokeeptwiddling3d();
$o = imag3d($c);
while(1) {
$c .= nextfunc($c);
$o->data_changed();
twiddle3d(); # animate one step, then return.
} Module PDL::Graphics::TriD Names keeptwiddling3d,nokeeptwiddling3d File Graphics/TriD.pm Ref Wait / don't wait for 'q' after displaying a 3D image. Usage keeptwiddling3d();
nokeeptwiddling3d();�gsl_sf_ellint_RD PDL::GSLSF::ELLINT Module PDL::GSLSF::ELLINT File GSLSF/ELLINT.pm Ref Carlsons symmetric basis of functions RD(x,y,z) = 3/2 Integral[(t+x)^(-1/2) (t+y)^(-1/2) (t+z)^(-3/2), {t,0,Inf}] Sig double x(); double yy(); double z(); double [o]y(); double [o]e() Bad gsl_sf_ellint_RD does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.� glue PDL::Primitive Usage $c = $x->glue(<dim>,$y,...) Ref Glue two or more PDLs together along an arbitrary dimension
(N-D L</append>). File Primitive.pm Module PDL::Primitive� set_seed PDL::GSL::RNG Usage $rng->set_seed($integer);
# or
$rng = PDL::GSL::RNG->new('taus')->set_seed($integer); Example $rng->set_seed(666); Module PDL::GSL::RNG File GSL/RNG.pm Ref Sets the RNG seed.v PDL::GSLSF::TRANSPORT PDL::GSLSF::TRANSPORT Ref Module: PDL interface to GSL Special Functions File GSLSF/TRANSPORT.pm� lut_names PDL::Graphics::LUT Usage @tables = lut_names(); Module PDL::Graphics::LUT Ref Return, as a list, the names of the available colour tables. File Graphics/LUT.pm� get_autopthread_targ PDL::Core Usage $num_pthreads = get_autopthread_targ(); Module PDL::Core File Core.pm Ref Get the current target number of processor threads (pthreads) for multi-threaded processing.l pp_addhdr PDL::PP Module PDL::PP Ref Add code and includes to C section of the generated XS file File PP.pod� default_options PDL::Graphics::OpenGL::Perl::OpenGL File Graphics/OpenGL/Perl/OpenGL.pm Module PDL::Graphics::OpenGL::Perl::OpenGLM avgover PDL::Ufunc Ref Synonym for average. File Ufunc.pm Module PDL::UfuncW PDL::Dbg PDL::Dbg File Dbg.pm Ref Module: functions to support debugging of PDL scripts8 gdImageCopy PDL::IO::GD Module PDL::IO::GD File IO/GD.pmg diskcache PDL::DiskCache File DiskCache.pm Module PDL::DiskCache Usage $x = diskcache(\@f,\%options);6 write_Gif PDL::IO::GD File IO/GD.pm Module PDL::IO::GD= gdImageCopyMerge PDL::IO::GD File IO/GD.pm Module PDL::IO::GD� fftnd PDL::FFT Module PDL::FFT Example fftnd($real,$imag); File FFT.pm Ref N-dimensional FFT over all pdl dims of input (inplace) � thread1 PDL::Core Usage $xx = $x->thread1(3,1) Module PDL::Core Example Wibble File Core.pm Ref Explicit threading over specified dims using thread id 1.H apply_lut PDL::IO::GD Sig $lut(piddle) File IO/GD.pm Module PDL::IO::GDiin PDL::Primitive Module PDL::Primitive Example $goodmsk = $labels->in($goodlabels);
print pdl(3,1,4,6,2)->in(pdl(2,3,3));
[1 0 0 0 1] Sig a(); b(n); [o] c() Ref test if a is in the set of values b File Primitive.pm Bad in does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.c PDL::Math PDL::Math Ref Module: extended mathematical operations and special functions File Math.pm� badmask PDL::Math Module PDL::Math Ref Clears all C<infs> and C<nans> in C<$a> to the corresponding value in C<$b>. File Math.pm Sig a(); b(); [o]c() Bad If bad values are present, these are also cleared.� PDL::Doc::Perldl::search_docs PDL::Doc::Perldl Module PDL::Doc::Perldl File Doc/Perldl.pm Ref Internal routine to search docs database and autoload filesl pp_export_nothing PDL::PP File PP.pod Ref Clear out the export list for your generated module Module PDL::PP3gsl_sf_psi_1piy PDL::GSLSF::PSI Module PDL::GSLSF::PSI Ref Di-Gamma Function Re[psi(1 + I y)] File GSLSF/PSI.pm Sig double x(); double [o]y(); double [o]e() Bad gsl_sf_psi_1piy does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.copybad PDL::Bad Bad This handles input piddles that are bad. If either C<$x>
or C<$mask> have bad values, those values will be marked
as bad in the output piddle and the output piddle will have
its bad value flag set to true. Sig a(); mask(); [o]b() File Bad.pm Ref Copies values from one piddle to another, setting them
bad if they are bad in the supplied mask. Example $x = byte( [0,1,3] );
$mask = byte( [0,0,0] );
$mask->badflag(1);
set($mask,1,$mask->badvalue);
$x->inplace->copybad( $mask );
p $x;
[0 BAD 3] Module PDL::Bad� iiscur PDL::Graphics::IIS Usage ($x,$y) = iiscur($ch) Module PDL::Graphics::IIS File Graphics/IIS.pm Ref Return cursor position from an IIS device (e.g. SAOimage/Ximtool)�gsl_sf_conicalP_cyl_reg_e PDL::GSLSF::LEGENDRE Bad gsl_sf_conicalP_cyl_reg_e does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::GSLSF::LEGENDRE Sig double x(); double [o]y(); double [o]e(); int m; double lambda File GSLSF/LEGENDRE.pm Ref Regular Cylindrical Conical Function P^{-m}_{-1/2 + I lambda}(x)8 gdImageArcs PDL::IO::GD Module PDL::IO::GD File IO/GD.pm; FilledEllipses PDL::IO::GD File IO/GD.pm Module PDL::IO::GD1gsl_sf_log_erfc PDL::GSLSF::ERF Module PDL::GSLSF::ERF Ref Log Complementary Error Function File GSLSF/ERF.pm Sig double x(); double [o]y(); double [o]e() Bad gsl_sf_log_erfc does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.Hdcumuprodover PDL::Ufunc Bad dcumuprodover processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Usage $y = cumuprodover($x); Sig a(n); double [o]b(n) File Ufunc.pm Ref Cumulative product Module PDL::Ufunc Example $spectrum = cumuprodover $image->xchg(0,1)= gdImageFilledArc PDL::IO::GD File IO/GD.pm Module PDL::IO::GD:gsl_sf_hypot PDL::GSLSF::TRIG Module PDL::GSLSF::TRIG Sig double x(); double xx(); double [o]y(); double [o]e() Ref Hypot(x,xx) with GSL semantics. File GSLSF/TRIG.pm Bad gsl_sf_hypot does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.*squaretotri PDL::MatrixOps Bad squaretotri does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Sig a(n,n); b(m) Ref Convert a symmetric square matrix to triangular vector storage. File MatrixOps.pm Module PDL::MatrixOpsBaverage PDL::Ufunc Bad average processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Usage $y = average($x); File Ufunc.pm Ref Project via average to N-1 dimensions Sig a(n); int+ [o]b() Example $spectrum = average $image->xchg(0,1) Module PDL::Ufunc� t_gnomonic PDL::Transform::Cartography Ref (Cartography) Gnomonic (focal-plane) projection (az.; persp.) File Transform/Cartography.pm Module PDL::Transform::Cartography Usage $t = t_gnomonic(<options>);� find_autodoc PDL::Doc::Perldl Module PDL::Doc::Perldl File Doc/Perldl.pm Ref Internal routine that finds and returns documentation in the
PDL::AutoLoader path, if it exists.Rgsl_sf_expint_E2 PDL::GSLSF::EXPINT Module PDL::GSLSF::EXPINT Ref E_2(x) := Re[ Integrate[ Exp[-xt]/t^2, {t,1,Infity}] ] File GSLSF/EXPINT.pm Sig double x(); double [o]y(); double [o]e() Bad gsl_sf_expint_E2 does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.D t_cylindrical PDL::Transform Module PDL::Transform File Transform.pm� any PDL::Ufunc Example if (any $x>15) { print "some values are greater than 15\n" } Module PDL::Ufunc Ref Return true if any element in piddle set File Ufunc.pm Bad See L</or> for comments on what happens when all elements
in the check are bad.8 gdImageFill PDL::IO::GD Module PDL::IO::GD File IO/GD.pmCcos PDL::Complex Module PDL::Complex File Complex.pm Ref cos (a) = 1/2 * (exp (a*i) + exp (-a*i)). Works inplace Sig a(m=2); [o]c(m=2) Bad Ccos does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.�xvals PDL::Basic File Basic.pm Ref Fills a piddle with X index values. Uses similar specifications to
L</zeroes> and L</new_from_specification>. Example pdl> print xvals zeroes(5,10)
[
[0 1 2 3 4]
[0 1 2 3 4]
[0 1 2 3 4]
[0 1 2 3 4]
[0 1 2 3 4]
[0 1 2 3 4]
[0 1 2 3 4]
[0 1 2 3 4]
[0 1 2 3 4]
[0 1 2 3 4]
] Module PDL::Basic Usage $x = xvals($somearray);
$x = xvals([OPTIONAL TYPE],$nx,$ny,$nz...);
$x = xvals([OPTIONAL TYPE], $somarray->dims);o nokeeptwiddling3d PDL::Graphics::TriD File Graphics/TriD.pm Module PDL::Graphics::TriD Crossref keeptwiddling3dreadfraw PDL::IO::FastRaw File IO/FastRaw.pm Ref Read a raw format binary file Module PDL::IO::FastRaw Usage $pdl2 = readfraw("fname");
$pdl2 = PDL->readfraw("fname");
$pdl2 = readfraw("fname", {Header => 'headerfname'}); Opt The C<readfraw> command
supports the following option:&mnerrs PDL::Minuit Sig int ia(); double [o] a(); double [o] b(); double [o] c(); double [o] d() Ref info not available File Minuit.pm Module PDL::Minuit Bad mnerrs does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.qsortveci PDL::Ufunc Bad Vectors with bad components should be moved to the end of the array: Module PDL::Ufunc Sig a(n,m); indx [o]indx(m) File Ufunc.pm Ref Sort a list of vectors lexicographically, returning the indices of the
sorted vectors rather than the sorted list itself.fibonacci PDL::Primitive Bad fibonacci does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. File Primitive.pm Ref Constructor - a vector with Fibonacci's sequence Sig [o]x(n) Module PDL::Primitive� threadids PDL::Core Module PDL::Core File Core.pm Ref Returns the piddle thread IDs as a perl list Usage use PDL::Core ':Internal'; # use the internal routines of
# the Core module5 GetPixel PDL::IO::GD File IO/GD.pm Module PDL::IO::GD= gdImageTrueColor PDL::IO::GD File IO/GD.pm Module PDL::IO::GD� cc4compt PDL::Image2D Module PDL::Image2D Example $segmented = cc4compt( $image > $threshold ); File Image2D.pm Ref Connected 4-component labeling of a binary image.? gdImagePaletteCopy PDL::IO::GD File IO/GD.pm Module PDL::IO::GDg PDL::Indexing PDL::Indexing File Indexing.pod Ref Manual: Introduction to indexing and slicing piddles.l PDL::Slatec PDL::Slatec Ref Module: PDL interface to the slatec numerical programming library File Slatec.pme t_aitoff PDL::Transform::Cartography Module PDL::Transform::Cartography File Transform/Cartography.pm%gsl_sf_doublefact PDL::GSLSF::GAMMA Bad gsl_sf_doublefact does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::GSLSF::GAMMA File GSLSF/GAMMA.pm Ref n!! = n(n-2)(n-4) Sig x(); double [o]y(); double [o]e()� pow PDL::Math Bad pow processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::Math Sig a(); b(); [o]c() Ref Synonym for `**'. Works inplace. File Math.pm� conj PDL::Ops Bad conj processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::Ops Ref complex conjugate. File Ops.pm Sig a(); [o]b()� cmul PDL::FFT Module PDL::FFT Sig ar(); ai(); br(); bi(); [o]cr(); [o]ci() File FFT.pm Ref Complex multiplication Bad cmul does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.ran_weibull_var PDL::GSL::RNG Usage $piddle = $rng->ran_weibull_var($a_piddle, $b_piddle); Ref Similar to L</ran_weibull> except that it takes the distribution
parameters as a piddle and returns a piddle of equal dimensions. File GSL/RNG.pm Module PDL::GSL::RNGCabs2 PDL::Complex Bad Cabs2 does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::Complex File Complex.pm Ref complex squared C<abs()> (also known I<squared modulus>) Sig a(m=2); [o]c()< ColorDeallocate PDL::IO::GD Module PDL::IO::GD File IO/GD.pm; ColorAllocates PDL::IO::GD Module PDL::IO::GD File IO/GD.pm1clean_lines PDL::Transform::Cartography File Transform/Cartography.pm Ref (Cartography) PDL method - remove projection irregularities Module PDL::Transform::Cartography Usage $x = clean_lines(t_mercator->apply(scalar(earth_coast())));
$x = clean_lines($line_pen, [threshold]);
$x = $lines->clean_lines;r new_from_specification PDL::Core Module PDL::Core Ref Internal method: create piddle by specification File Core.pmS minmaxover PDL::Ufunc Ref Synonym for minmaximum. File Ufunc.pm Module PDL::Ufuncf PDL::Core PDL::Core Ref Module: fundamental PDL functionality and vectorization/threading File Core.pm� ran_additive_gaussian PDL::GSL::RNG Usage $rng->ran_additive_gaussian($sigma,$piddle); Ref Add Gaussian noise of given sigma to a piddle. File GSL/RNG.pm Example $rng->ran_additive_gaussian(1,$image); Module PDL::GSL::RNG: gdImageString PDL::IO::GD File IO/GD.pm Module PDL::IO::GD� Carg PDL::Complex Sig a(m=2); [o]c() File Complex.pm Ref complex argument function ("angle") Module PDL::Complex Bad Carg does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.jgsl_sf_bessel_In_scaled PDL::GSLSF::BESSEL Ref Scaled Regular Modified Bessel Function exp(-|x|) I_n(x). File GSLSF/BESSEL.pm Sig double x(); double [o]y(); double [o]e(); int n Module PDL::GSLSF::BESSEL Bad gsl_sf_bessel_In_scaled does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.= gdImageStringTTF PDL::IO::GD File IO/GD.pm Module PDL::IO::GD�assgn PDL::Ops Sig a(); [o]b() File Ops.pm Ref Plain numerical assignment. This is used to implement the ".=" operator Module PDL::Ops Bad If C<a> is a child piddle (e.g., the result of a slice) and bad values are generated in C<b>,
the bad value flag is set in C<b>, but it is B<NOT> automatically propagated back to the parent of C<a>.
The following idiom ensures that the badflag is propagated back to the parent of C<a>:wgsl_sf_legendre_sphPlm PDL::GSLSF::LEGENDRE Bad gsl_sf_legendre_sphPlm does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::GSLSF::LEGENDRE Ref P_lm(x), normalized properly for use in spherical harmonics File GSLSF/LEGENDRE.pm Sig double x(); double [o]y(); double [o]e(); int l; int mg doflow PDL::Core Ref Turn on/off dataflow File Core.pm Module PDL::Core Usage $x->doflow; doflow($x);#ran_flat PDL::GSL::RNG Usage $piddle = $rng->ran_flat($la,$lb,[list of integers = output piddle dims]);
$rng->ran_flat($la,$lb,$output_piddle); File GSL/RNG.pm Ref Fills output piddle with random variates from the flat (uniform) distribution from C<$la> to C<$lb>. Module PDL::GSL::RNGg PDL::GSLSF::ZETA PDL::GSLSF::ZETA File GSLSF/ZETA.pm Ref Module: PDL interface to GSL Special Functions? ColorAllocateAlpha PDL::IO::GD Module PDL::IO::GD File IO/GD.pm{gsl_sf_conicalP_mhalf PDL::GSLSF::LEGENDRE Bad gsl_sf_conicalP_mhalf does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Sig double x(); double [o]y(); double [o]e(); double lambda Ref Regular Spherical Conical Function P^{-1/2}_{-1/2 + I lambda}(x) File GSLSF/LEGENDRE.pm Module PDL::GSLSF::LEGENDRE` PDL::Dataflow PDL::Dataflow File Dataflow.pod Ref Manual: description of the dataflow philosophy�setbadif PDL::Bad File Bad.pm Ref Set elements bad based on the supplied mask, otherwise
copy across the data. Sig a(); int mask(); [o]b() Module PDL::Bad Example pdl> $x = sequence(5,5)
pdl> $x = $x->setbadif( $x % 2 )
pdl> p "a badflag: ", $x->badflag, "\n"
a badflag: 1
pdl> p "a is\n$x"
[
[ 0 BAD 2 BAD 4]
[BAD 6 BAD 8 BAD]
[ 10 BAD 12 BAD 14]
[BAD 16 BAD 18 BAD]
[ 20 BAD 22 BAD 24]
] Bad The output always has its bad flag set, even if it does not contain
any bad values (use L</check_badflag> to check
whether there are any bad values in the output).
The input piddle can have bad values: any bad values in the input piddles
are copied across to the output piddle.Ggsl_sf_legendre_Pl_array PDL::GSLSF::LEGENDRE Bad gsl_sf_legendre_Pl_array does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::GSLSF::LEGENDRE Sig double x(); double [o]y(num); int l=>num Ref P_l(x) from 0 to n-1. File GSLSF/LEGENDRE.pm(oddpct PDL::Ufunc File Ufunc.pm Ref Return the specified percentile of all elements in a piddle. The
specified percentile must be between 0.0 and 1.0. When the specified
percentile falls between two values, the nearest data value is the
result. Module PDL::Ufunc Usage $x = oddpct($data, $pct);= FilledRectangles PDL::IO::GD Module PDL::IO::GD File IO/GD.pm3gsl_sf_legendre_Pl PDL::GSLSF::LEGENDRE Bad gsl_sf_legendre_Pl does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::GSLSF::LEGENDRE Sig double x(); double [o]y(); double [o]e(); int l Ref P_l(x) File GSLSF/LEGENDRE.pmqran_ugaussian_tail PDL::GSL::RNG File GSL/RNG.pm Ref Fills output piddle with random variates from the upper tail of a Gaussian
distribution with C<standard deviation = 1> (AKA unit Gaussian distribution). Module PDL::GSL::RNG Usage $piddle = $rng->ran_ugaussian_tail($tail,[list of integers = output piddle dims]);
$rng->ran_ugaussian_tail($tail,$output_piddle);� pnpoly PDL::Image2D Usage $mask = $img->pnpoly($ps); Ref 'points in a polygon' selection from a 2-D piddle File Image2D.pm Example # define a 3-sided polygon (a triangle)
$ps = pdl([3, 3], [20, 20], [34, 3]); Module PDL::Image2D�vsearch_sample PDL::Primitive Bad needs major (?) work to handles bad values Usage $idx = vsearch_sample($vals, $x); Sig vals(); x(n); indx [o]idx() File Primitive.pm Ref Search for values in a sorted array, return index appropriate for sampling from a distribution Example This function is useful e.g. when you have a list of probabilities
for events and want to generate indices to events: Module PDL::Primitivec PDL::BadValues PDL::BadValues Ref Manual: Discussion of bad value support in PDL File BadValues.podran_gumbel1 PDL::GSL::RNG Usage $piddle = $rng->ran_gumbel1($pa,$pb,[list of integers = output piddle dims]);
$rng->ran_gumbel1($pa,$pb,$output_piddle); Module PDL::GSL::RNG Ref Fills output piddle with random variates from the Type-1 Gumbel distribution. File GSL/RNG.pm�get_uniform_pos PDL::GSL::RNG Usage $piddle = $rng->get_uniform_pos($list_of_integers)
$rng->get_uniform_pos($piddle); Module PDL::GSL::RNG Example $x = zeroes 5,6;
$o = $rng->get_uniform_pos(10,10); $rng->get_uniform_pos($x); Ref This function creates a piddle with given dimensions or accepts an
existing piddle and fills it. get_uniform_pos() returns values 0<x<1, File GSL/RNG.pm�new PDL::Graphics::TriD::ButtonControl Usage The ButtonControl class is a base class which all TriD event
controllers should inherit from. By itself it does not do much. It
defines ButtonPressed and ButtonRelease functions which are expected by
the Event loop. Module PDL::Graphics::TriD::ButtonControl Ref Bless an oject into the class ButtonControl, expects the associated
Window object to be supplied as an argument. File Graphics/TriD/ButtonControl.pm0 new PDL::IO::GD Module PDL::IO::GD File IO/GD.pmSnew PDL::Char Module PDL::Char Example $pdlchar3d = PDL::Char->new([['abc','def','ghi'],['jkl', 'mno', 'pqr']]); Ref Function to create a byte PDL from a string, list of strings, list of list of strings, etc. File Char.pm Usage # create a new PDL::Char from a perl array of strings
$strpdl = PDL::Char->new( ['abc', 'def', 'ghij'] ); new PDL::Core Usage $x = PDL->new(SCALAR|ARRAY|ARRAY REF|STRING); Ref new piddle constructor method File Core.pm Module PDL::Core Example $x = PDL->new(42); # new from a Perl scalar
$x = new PDL 42; # ditto
$y = PDL->new(@list_of_vals); # new from Perl list
$y = new PDL @list_of_vals; # ditto
$z = PDL->new(\@list_of_vals); # new from Perl list reference
$w = PDL->new("[1 2 3]"); # new from Perl string, using
# Matlab constructor syntaxBnew PDL::Graphics::TriD::Contours Opt ContourInt => 0.7 # explicitly set a contour interval
ContourMin => 0.0 # explicitly set a contour minimum
ContourMax => 10.0 # explicitly set a contour maximum
ContourVals => $pdl # explicitly set all contour values
Label => [1,5,$myfont] # see addlabels below
Font => $font # explicitly set the font for contour labels File Graphics/TriD/Contours.pm Ref Define a new contour plot for TriD. Example $data=new PDL::Graphics::TriD::Contours($d,[$x,$y,$z],[$r,$g,$b],$options); Module PDL::Graphics::TriD::Contours� new PDL::GSL::RNG Ref The new method initializes a new instance of the RNG. File GSL/RNG.pm Example $rng = PDL::GSL::RNG->new('taus'); Module PDL::GSL::RNG Usage � new PDL::Graphics::OpenGL::Perl::OpenGL Usage new($class,$options,[$window_type]) Module PDL::Graphics::OpenGL::Perl::OpenGL Ref Returns a new OpenGL object. File Graphics/OpenGL/Perl/OpenGL.pmigsl_sf_bessel_j_array PDL::GSLSF::BESSEL Module PDL::GSLSF::BESSEL File GSLSF/BESSEL.pm Ref Array of Spherical Regular Bessel Functions J_{0}(x) to J_{n-1}(x). Sig double x(); double [o]y(num); int n=>num Bad gsl_sf_bessel_j_array does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.D gdImageColorTransparent PDL::IO::GD File IO/GD.pm Module PDL::IO::GD3 CharUp PDL::IO::GD File IO/GD.pm Module PDL::IO::GDo PDL::GSL::INTERP PDL::GSL::INTERP File GSL/INTERP.pm Ref Module: PDL interface to Interpolation routines in GSLm PDL::GSLSF::BESSEL PDL::GSLSF::BESSEL File GSLSF/BESSEL.pm Ref Module: PDL interface to GSL Special Functions� is_inplace PDL::Core Usage $out = ($in->is_inplace) ? $in : zeroes($in);
$in->set_inplace(0) Module PDL::Core File Core.pm Ref Test the in-place flag on a piddle�gsl_sf_ellint_Ecomp PDL::GSLSF::ELLINT Bad gsl_sf_ellint_Ecomp does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Sig double k(); double [o]y(); double [o]e() Ref Legendre form of complete elliptic integrals E(k) = Integral[ Sqrt[1 - k^2 Sin[t]^2], {t, 0, Pi/2}] File GSLSF/ELLINT.pm Module PDL::GSLSF::ELLINT'mnexcm PDL::Minuit File Minuit.pm Ref info not available Sig double a(n); int ia(); int [o] ib(); char* str; SV* function; int numelem Module PDL::Minuit Bad mnexcm does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.< mn_pout PDL::Minuit Module PDL::Minuit File Minuit.pm Usage �gsl_sf_gammastar PDL::GSLSF::GAMMA Bad gsl_sf_gammastar does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. File GSLSF/GAMMA.pm Ref Regulated Gamma Function, x > 0 Gamma^*(x) = Gamma(x)/(Sqrt[2Pi] x^(x-1/2) exp(-x)) = (1 + 1/(12x) + ...), x->Inf Sig double x(); double [o]y(); double [o]e() Module PDL::GSLSF::GAMMA7 StringUp16 PDL::IO::GD File IO/GD.pm Module PDL::IO::GD� ran_caos PDL::GSL::RNG Module PDL::GSL::RNG Ref Returns values from Verhuls map with C<$r=4.0> and randomly chosen
C<$x0>. The values are scaled by C<$m>. File GSL/RNG.pm Usage $rng->ran_caos($m,$n);� spheres3d PDL::Graphics::TriD Ref 3D spheres plot (preliminary implementation) File Graphics/TriD.pm Module PDL::Graphics::TriD Example Example: Usage spheres3d piddle(3), {OPTIONS}
spheres3d [piddle,...], {OPTIONS}� acos PDL::Math Bad acos processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Sig a(); [o]b() File Math.pm Module PDL::Mathgefa PDL::Slatec Bad gefa does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::Slatec File Slatec.pm Ref Factor a matrix using Gaussian elimination. Sig a(n,n);int [o]ipvt(n);int [o]info()� mpdl PDL::Matrix Ref constructs an object of class PDL::Matrix which is a piddle child class. File Matrix.pm Module PDL::Matrix Example $m = mpdl [[1,2,3],[4,5,6]];
$m = PDL::Matrix->pdl([[1,2,3],[4,5,6]]); Names mpdl,PDL::Matrix::pdltgsl_sf_bessel_il_scaled PDL::GSLSF::BESSEL Module PDL::GSLSF::BESSEL Sig double x(); double [o]y(); double [o]e(); int n File GSLSF/BESSEL.pm Ref Scaled Regular Modified Spherical Bessel Function exp(-|x|) i_n(x). Bad gsl_sf_bessel_il_scaled does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.�gsl_sf_ellint_P PDL::GSLSF::ELLINT Module PDL::GSLSF::ELLINT Sig (double phi(); double k(); double n();
double [o]y(); double [o]e()) File GSLSF/ELLINT.pm Ref Legendre form of incomplete elliptic integrals P(phi,k,n) = Integral[(1 + n Sin[t]^2)^(-1)/Sqrt[1 - k^2 Sin[t]^2], {t, 0, phi}] Bad gsl_sf_ellint_P does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.L PDL::Complex PDL::Complex Ref Module: handle complex numbers File Complex.pm� reorder PDL::Slices File Slices.pm Ref Re-orders the dimensions of a PDL based on the supplied list. Example Example: Module PDL::Slices Usage # Completely reverse the dimension order of a 6-Dim array.
$reOrderedPDL = $pdl->reorder(5,4,3,2,1,0);floor PDL::Math File Math.pm Ref Round to integer values in floating-point format. Works inplace. Sig a(); [o]b() Module PDL::Math Bad floor processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.R PDL::LiteF PDL::LiteF File LiteF.pm Ref Module: minimum PDL module function loader� gslinteg_qawo PDL::GSL::INTEG File GSL/INTEG.pm Ref Please check the GSL documentation for more information. Module PDL::GSL::INTEG Example Example: Usage Y PDL::MatrixOps PDL::MatrixOps File MatrixOps.pm Ref Module: Some Useful Matrix Operations� inv PDL::MatrixOps Module PDL::MatrixOps Sig a(m,m); sv opt File MatrixOps.pm Ref Invert a square matrix. Usage $a1 = inv($a, {$opt}); /gsl_sf_transport_2 PDL::GSLSF::TRANSPORT Bad gsl_sf_transport_2 does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::GSLSF::TRANSPORT Ref J(2,x) File GSLSF/TRANSPORT.pm Sig double x(); double [o]y(); double [o]e()� hold3d PDL::Graphics::TriD Usage hold3d();
release3d(); Names hold3d,release3d Module PDL::Graphics::TriD Ref Keep / don't keep the previous objects when plotting new 3D objects File Graphics/TriD.pmE PDL::Bad PDL::Bad Ref Module: PDL does process bad values File Bad.pm identity PDL::MatrixOps Module PDL::MatrixOps Ref Return an identity matrix of the specified size. If you hand in a
scalar, its value is the size of the identity matrix; if you hand in a
dimensioned PDL, the 0th dimension is the size of the matrix. File MatrixOps.pm Sig n; [o]a(n,n)� ran_poisson_var PDL::GSL::RNG Module PDL::GSL::RNG File GSL/RNG.pm Ref Similar to L</ran_poisson> except that it takes the distribution
parameters as a piddle and returns a piddle of equal dimensions. Usage $piddle = $rng->ran_poisson_var($mu_piddle);� cquant PDL::ImageRGB Usage ($out, $lut) = cquant($image [,$ncols]); Ref quantize and reduce colours in 8-bit images File ImageRGB.pm Module PDL::ImageRGBinner PDL::Primitive Bad If C<a() * b()> contains only bad data,
C<c()> is set bad. Otherwise C<c()> will have its bad flag cleared,
as it will not contain any bad values. Module PDL::Primitive File Primitive.pm Ref Inner product over one dimension Sig a(n); b(n); [o]c()� thread PDL::Core Example $x = zeroes 3,4,5;
$y = $x->thread(2,0); Module PDL::Core File Core.pm Ref Use explicit threading over specified dimensions (see also L<PDL::Indexing>) Usage $y = $x->thread($dim,[$dim1,...])\ PDL::IO PDL::IO Ref Manual: An overview of the modules in the PDL::IO namespace. File IO.pod ylogvals PDL::Basic Ref Y axis values logarithmically spaced between endpoints (see L</yvals>). File Basic.pm Module PDL::Basic�gsl_sf_bessel_i_scaled_array PDL::GSLSF::BESSEL Bad gsl_sf_bessel_i_scaled_array does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::GSLSF::BESSEL File GSLSF/BESSEL.pm Ref Array of Scaled Regular Modified Spherical Bessel Functions exp(-|x|) i_{0}(x) to exp(-|x|) i_{n-1}(x). Sig double x(); double [o]y(num); int n=>num. ushort PDL::Core File Core.pm Module PDL::CoreNindex1d PDL::Slices Sig a(n); indx ind(m); [oca] c(m) Ref C<index>, C<index1d>, and C<index2d> provide rudimentary index indirection. File Slices.pm Module PDL::Slices Example $c = index($source,$ind);
$c = index1d($source,$ind);
$c = index2d($source2,$ind1,$ind2); Bad index1d propagates BAD index elements to the output variable.N pp_add_isa PDL::PP Module PDL::PP File PP.pod Ref Add entries to the @ISA list� glpXNextEvent PDL::Graphics::OpenGL::Perl::OpenGL File Graphics/OpenGL/Perl/OpenGL.pm Module PDL::Graphics::OpenGL::Perl::OpenGLvran_weibull PDL::GSL::RNG Module PDL::GSL::RNG File GSL/RNG.pm Ref Fills output piddle with random variates from the Weibull distribution with scale C<$pa> and exponent C<$pb>. (Some literature uses C<lambda> for C<$pa> and C<k> for C<$pb>.) Usage $piddle = $rng->ran_weibull($pa,$pb,[list of integers = output piddle dims]);
$rng->ran_weibull($pa,$pb,$output_piddle);ngsl_sf_coulomb_wave_FGp_array PDL::GSLSF::COULOMB Bad gsl_sf_coulomb_wave_FGp_array does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::GSLSF::COULOMB Sig double x(); double [o]fc(n); double [o]fcp(n); double [o]gc(n); double [o]gcp(n); int [o]ovfw(); double [o]fe(n); double [o]ge(n); double lam_min; int kmax=>n; double eta Ref Coulomb wave functions F_{lam_F}(eta,x), G_{lam_G}(eta,x) and their derivatives; lam_G := lam_F - k_lam_G. if ovfw is signaled then F_L(eta,x) = fc[k_L] * exp(fe) and similar. File GSLSF/COULOMB.pm typesynonyms PDL::Types Module PDL::Types Ref return type related synonym definitions to be included in pdl.h .
This routine must be updated to include new types as required.
Mostly the automatic updating should take care of the vital
things. File Types.pm; mn_err PDL::Minuit Usage Module PDL::Minuit File Minuit.pm� oddmedian PDL::Ufunc Usage $x = oddmedian($data); Bad This routine handles bad values. Module PDL::Ufunc Ref Return the oddmedian of all elements in a piddle. File Ufunc.pmTtlmfit PDL::Fit::LM File Fit/LM.pm Ref threaded version of Levenberg-Marquardt fitting routine mfit Sig tlmfit(x(n);y(n);sigma(n);initp(m);iter();eps();[o] ym(n);[o] finalp(m);
OtherPar => subref) Example tlmfit $x, $y, float(1)->dummy(0), $na, float(200), float(1e-4),
$ym=null, $afit=null, \&expdec; Module PDL::Fit::LM7 DashedLine PDL::IO::GD Module PDL::IO::GD File IO/GD.pm� type PDL::Core Module PDL::Core Example $y = PDL->zeroes($x->type,$x->dims,3);
die "must be float" unless $x->type == float; Ref return the type of a piddle as a blessed type object File Core.pm&gsl_sf_airy_Bi PDL::GSLSF::AIRY Module PDL::GSLSF::AIRY Sig double x(); double [o]y(); double [o]e() File GSLSF/AIRY.pm Ref Airy Function Bi(x). Bad gsl_sf_airy_Bi does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.6rangeb PDL::Slices Module PDL::Slices Example Same calling convention as L</range>, but you must supply all
parameters. C<rangeb> is marginally faster as it makes a direct PP call,
avoiding the perl argument-parsing step. Sig P(); C(); SV *index; SV *size; SV *boundary Ref Engine for L</range> File Slices.pm�attract PDL::Graphics::TriD::Rout Bad attract does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::Graphics::TriD::Rout Sig (coords(nc,np);
int from(nl);
int to(nl);
strength(nl);
[o]vecs(nc,np);;
double m;
double ms;
) Ref Attractive potential for molecule-like constructs. File Graphics/TriD/Rout.pm-Cproj PDL::Complex Bad Cproj does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::Complex Sig a(m=2); [o]c(m=2) File Complex.pm Ref compute the projection of a complex number to the riemann sphere. Works inplacep PDL::GSLSF::CLAUSEN PDL::GSLSF::CLAUSEN Ref Module: PDL interface to GSL Special Functions File GSLSF/CLAUSEN.pmJ PDL::Lvalue PDL::Lvalue Ref Module: declare PDL lvalue subs File Lvalue.pm zlogvals PDL::Basic Module PDL::Basic Ref Z axis values logarithmically spaced between endpoints (see L</zvals>). File Basic.pm9 get_Png_data PDL::IO::GD Module PDL::IO::GD File IO/GD.pmGgsl_sf_exp_err PDL::GSLSF::EXP Bad gsl_sf_exp_err does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::GSLSF::EXP Sig double x(); double dx(); double [o]y(); double [o]e() File GSLSF/EXP.pm Ref Exponential of a quantity with given error.X Catan PDL::Complex Ref Return the complex C<atan()>. File Complex.pm Module PDL::Complex� t_sin_lat PDL::Transform::Cartography File Transform/Cartography.pm Ref (Cartography) Cyl. equal-area projection (cyl.; authalic) Module PDL::Transform::Cartography Usage $t = t_sin_lat(<options>);� gslinteg_qaws PDL::GSL::INTEG Module PDL::GSL::INTEG Example Example: Ref Please check the GSL documentation for more information. File GSL/INTEG.pm Usage }shiftleft PDL::Ops Bad shiftleft processes bad values.
The state of the bad-value flag of the output piddles is unknown. Ref leftshift C<$a> by C<$b> File Ops.pm Sig a(); b(); [o]c(); int swap Module PDL::Ops Example $c = shiftleft $x, $y, 0; # explicit call with trailing 0
$c = $x << $y; # overloaded call
$x->inplace->shiftleft($y,0); # modify $x inplace^gsl_sf_conicalP_1 PDL::GSLSF::LEGENDRE Bad gsl_sf_conicalP_1 does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::GSLSF::LEGENDRE File GSLSF/LEGENDRE.pm Ref Conical Function P^{1}_{-1/2 + I lambda}(x) Sig double x(); double [o]y(); double [o]e(); double lambdaRgsl_sf_expint_E1 PDL::GSLSF::EXPINT Bad gsl_sf_expint_E1 does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Sig double x(); double [o]y(); double [o]e() File GSLSF/EXPINT.pm Ref E_1(x) := Re[ Integrate[ Exp[-xt]/t, {t,1,Infinity}] ] Module PDL::GSLSF::EXPINTogsl_sf_ellint_D PDL::GSLSF::ELLINT Bad gsl_sf_ellint_D does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. File GSLSF/ELLINT.pm Ref Legendre form of incomplete elliptic integrals D(phi,k) Sig (double phi(); double k();
double [o]y(); double [o]e()) Module PDL::GSLSF::ELLINTY PDL::Modules PDL::Modules File Modules.pod Ref Manual: A guide to PDL's module reference.� t_perspective PDL::Transform::Cartography Usage $t = t_perspective(<options>); File Transform/Cartography.pm Ref (Cartography) Arbitrary perspective projection Module PDL::Transform::CartographyKgsl_sf_bessel_In PDL::GSLSF::BESSEL Module PDL::GSLSF::BESSEL Sig double x(); double [o]y(); double [o]e(); int n Ref Regular Modified Bessel Function I_n(x). File GSLSF/BESSEL.pm Bad gsl_sf_bessel_In does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.awrite_png_ex PDL::IO::GD Bad write_png_ex does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Sig img(x,y); lut(i,j); char* filename; int level File IO/GD.pm Ref Same as write_png(), except you can specify the compression level (0-9) as the last argument. Module PDL::IO::GD~apropos PDL::Doc::Perldl Usage apropos 'text' Ref Regex search PDL documentation database File Doc/Perldl.pm Module PDL::Doc::Perldl Example pdl> apropos 'pic'
PDL::IO::Pic P::IO::Pic Module: image I/O for PDL
grabpic3d P::G::TriD Grab a 3D image from the screen.
rim P::IO::Pic Read images in most formats, with improved RGB handling.
rpic P::IO::Pic Read images in many formats with automatic format detection.
rpiccan P::IO::Pic Test which image formats can be read/written
wim P::IO::Pic Write a pdl to an image file with selected type (or using filename extensions)
wmpeg P::IO::Pic Write an image sequence (a (3,x,y,n) byte pdl) as an animation.
wpic P::IO::Pic Write images in many formats with automatic format selection.
wpiccan P::IO::Pic Test which image formats can be read/written�gsl_sf_ellint_RC PDL::GSLSF::ELLINT Bad gsl_sf_ellint_RC does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::GSLSF::ELLINT Sig double x(); double yy(); double [o]y(); double [o]e() Ref Carlsons symmetric basis of functions RC(x,y) = 1/2 Integral[(t+x)^(-1/2) (t+y)^(-1)], {t,0,Inf} File GSLSF/ELLINT.pm� clump PDL::Core Module PDL::Core Example $y = $x->clump(2); # Clump 2 first dimensions Ref "clumps" several dimensions into one large dimension File Core.pm= vars PDL::Dbg Ref Alias for C<px> File Dbg.pm Module PDL::Dbg� Cdiv PDL::Complex File Complex.pm Ref complex division Sig a(m=2); b(m=2); [o]c(m=2) Module PDL::Complex Bad Cdiv does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.Linplace PDL::Core File Core.pm Ref Flag a piddle so that the next operation is done 'in place' Example pdl> $x = xvals zeroes 10;
pdl> log10(inplace $x)
pdl> p $x
[-inf 0 0.30103 0.47712125 0.60205999 0.69897 0.77815125 0.84509804 0.90308999 0.95424251] Module PDL::Core Usage somefunc($x->inplace); somefunc(inplace $x);ran_ugaussian_tail_var PDL::GSL::RNG Usage $piddle = $rng->ran_ugaussian_tail_var($tail_piddle); File GSL/RNG.pm Ref Similar to L</ran_ugaussian_tail> except that it takes the distribution
parameters as a piddle and returns a piddle of equal dimensions. Module PDL::GSL::RNGP gslmroot_fsolver PDL::GSL::MROOT Usage File GSL/MROOT.pm Module PDL::GSL::MROOTp PDL::GSLSF::COULOMB PDL::GSLSF::COULOMB File GSLSF/COULOMB.pm Ref Module: PDL interface to GSL Special Functions5 StringUp PDL::IO::GD File IO/GD.pm Module PDL::IO::GD� Casinh PDL::Complex Bad Casinh does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Sig a(m=2); [o]c(m=2) File Complex.pm Ref Works inplace Module PDL::Complex convmath PDL::FFT File FFT.pm Ref Internal routine doing maths for convolution Sig [o,nc]a(m); [o,nc]b(m) Module PDL::FFT Bad convmath does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.�trylink PDL::Core::Dev Usage trylink $infomsg, $include, $progbody, $libs [,$cflags,{OPTIONS}]; Module PDL::Core::Dev Example if (trylink 'libGL', '', 'char glBegin(); glBegin();', '-lGL') {
$libs = '-lGLU -lGL';
$have_GL = 1;
} else {
$have_GL = 0;
}
$maybe =
trylink 'libwhatever', $inc, $body, $libs, $cflags,
{MakeMaker=>1, Hide=>0, Clean=>1}; File Core/Dev.pm Ref a perl configure clone gsl_sf_psi PDL::GSLSF::PSI Module PDL::GSLSF::PSI Ref Di-Gamma Function psi(x). File GSLSF/PSI.pm Sig double x(); double [o]y(); double [o]e() Bad gsl_sf_psi does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.5ran_fdist PDL::GSL::RNG File GSL/RNG.pm Ref Fills output piddle with random variates from the F-distribution with degrees
of freedom C<$nu1> and C<$nu2>. Module PDL::GSL::RNG Usage $piddle = $rng->ran_fdist($nu1, $nu2,[list of integers = output piddle dims]);
$rng->ran_fdist($nu1, $nu2,$output_piddle);� carg PDL::Ops Sig a(); [o]b() File Ops.pm Ref Returns the polar angle of a complex number. Module PDL::Ops Bad carg processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.� ndcoords PDL::Basic Ref Enumerate pixel coordinates for an N-D piddle File Basic.pm Module PDL::Basic Example pdl> print ndcoords(2,3) Usage $indices = ndcoords($pdl);
$indices = ndcoords(@dimlist);
$indices = ndcoords($type,@dimlist);t PDL::IO::FastRaw PDL::IO::FastRaw Ref Module: A simple, fast and convenient io format for PerlDL. File IO/FastRaw.pm� interpol PDL::Primitive Sig xi(); x(n); y(n); [o] yi() Ref routine for 1D linear interpolation File Primitive.pm Module PDL::Primitive Usage $yi = interpol($xi, $x, $y)9 SetThickness PDL::IO::GD File IO/GD.pm Module PDL::IO::GDMgsl_sf_bessel_Kn PDL::GSLSF::BESSEL Sig double x(); double [o]y(); double [o]e(); int n File GSLSF/BESSEL.pm Ref IrRegular Modified Bessel Function K_n(x). Module PDL::GSLSF::BESSEL Bad gsl_sf_bessel_Kn does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.'ran_hypergeometric PDL::GSL::RNG Usage $piddle = $rng->ran_hypergeometric($n1, $n2, $t,[list of integers = output piddle dims]);
$rng->ran_hypergeometric($n1, $n2, $t,$output_piddle); File GSL/RNG.pm Ref Fills output piddle with random integer values from the hypergeometric distribution.
If a population contains C<$n1> elements of type 1 and C<$n2> elements of
type 2 then the hypergeometric distribution gives the probability of obtaining
C<$x> elements of type 1 in C<$t> samples from the population without replacement. Module PDL::GSL::RNGlog PDL::Ops Bad log processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Ref the natural logarithm File Ops.pm Sig a(); [o]b() Module PDL::Ops Example $y = log $x;
$x->inplace->log; # modify $x inplace8 gdImageBlue PDL::IO::GD File IO/GD.pm Module PDL::IO::GD9ran_tdist PDL::GSL::RNG Module PDL::GSL::RNG File GSL/RNG.pm Ref Fills output piddle with random variates from the t-distribution (AKA Student's
t-distribution) with C<$nu> degrees of freedom. Usage $piddle = $rng->ran_tdist($nu,[list of integers = output piddle dims]);
$rng->ran_tdist($nu,$output_piddle);�transpose PDL::Basic Usage $y = transpose($w); Ref transpose rows and columns. File Basic.pm Example pdl> $w = sequence(3,2)
pdl> p $w
[
[0 1 2]
[3 4 5]
]
pdl> p transpose( $w )
[
[0 3]
[1 4]
[2 5]
] Module PDL::Basic�med2df PDL::Image2D Usage $new = med2df $old, $xwidth, $ywidth, {OPTIONS} Opt Boundary - controls what values are assumed for the image when kernel
crosses its edge:
=> Default - periodic boundary conditions (i.e. wrap around axis)
=> Reflect - reflect at boundary
=> Truncate - truncate at boundary
=> Replicate - repeat boundary pixel values File Image2D.pm Ref 2D median-convolution of an array in a pxq window (smoothing) Module PDL::Image2D Example $smoothed = med2df $image, 3, 3, {Boundary => Reflect} Bad med2df does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Sig a(m,n); [o]b(m,n); int __p_size; int __q_size; int opty PDL::GSLSF::GEGENBAUER PDL::GSLSF::GEGENBAUER Ref Module: PDL interface to GSL Special Functions File GSLSF/GEGENBAUER.pm� ngood PDL::Bad Module PDL::Bad File Bad.pm Ref Returns the number of good values in a piddle Usage $x = ngood($data); Bad Accepts good and bad input piddles; output is a Perl scalar
and therefore is always good.Q PDL::API PDL::API File API.pod Ref Manual: making piddles from Perl and C/XS codeLgsl_sf_sin_err PDL::GSLSF::TRIG Bad gsl_sf_sin_err does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::GSLSF::TRIG Ref Sin(x) for quantity with an associated error. File GSLSF/TRIG.pm Sig double x(); double dx(); double [o]y(); double [o]e()+gsl_sf_erf_Z PDL::GSLSF::ERF Bad gsl_sf_erf_Z does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::GSLSF::ERF Ref Z(x) : Abramowitz+Stegun 26.2.1 File GSLSF/ERF.pm Sig double x(); double [o]y(); double [o]e()R PDL::Delta PDL::Delta Ref Manual: PDL changes between V1.0 and V2.0 File Delta.pod Cprodover PDL::Complex Bad Cprodover does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::Complex File Complex.pm Ref Project via product to N-1 dimension Sig a(m=2,n); [o]c(m=2)� rgbtogr PDL::ImageRGB Usage $gr = $rgb->rgbtogr Module PDL::ImageRGB Ref Converts an RGB image to a grey scale using standard transform File ImageRGB.pm� fftconvolve PDL::FFT Usage $kernel = kernctr($image,$smallk);
fftconvolve($image,$kernel); Module PDL::FFT File FFT.pm Ref N-dimensional convolution with periodic boundaries (FFT method)6 PDL::FFT PDL::FFT Ref Module: FFTs for PDL File FFT.pmC gdImageFilledRectangle PDL::IO::GD Module PDL::IO::GD File IO/GD.pm� generate_badval_init PDL::Core::Dev Module PDL::Core::Dev Ref prints on C<STDOUT> XS text with badval initialisation, for F<Core.xs>. File Core/Dev.pm� integrate PDL::Func File Func.pm Ref Integrate the function stored in the PDL::Func
object, if the scheme is C<Hermite>. Module PDL::Func Usage my $ans = $obj->integrate( index => pdl( 2, 5 ) );
my $ans = $obj->integrate( x => pdl( 2.3, 4.5 ) );1diff_central PDL::GSL::DIFF Bad diff_central does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. File GSL/DIFF.pm Ref info not available Sig double x(); double [o] res(); double [o] abserr(); SV* function Module PDL::GSL::DIFF�centroid2d PDL::Image2D Bad Bad pixels are excluded from the centroid calculation. If all elements are
bad (or the pixel sum is 0 - but why would you be centroiding
something with negatives in...) then the output values are set bad. Ref Refine a list of object positions in 2D image by centroiding in a box File Image2D.pm Sig im(m,n); x(); y(); box(); [o]xcen(); [o]ycen() Module PDL::Image2D5 SetPixel PDL::IO::GD File IO/GD.pm Module PDL::IO::GDEcsumover PDL::Ufunc Bad csumover processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Usage $y = dsumover($x); Ref Project via sum to N-1 dimensions File Ufunc.pm Sig a(n); cdouble [o]b() Example $spectrum = dsumover $image->xchg(0,1) Module PDL::Ufunc�gsl_sf_hyperg_2F1_conj PDL::GSLSF::HYPERG Bad gsl_sf_hyperg_2F1_conj does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Sig double x(); double [o]y(); double [o]e(); double a; double b; double c Ref Gauss hypergeometric function 2F1[aR + I aI, aR - I aI, c, x] File GSLSF/HYPERG.pm Module PDL::GSLSF::HYPERG�atstr PDL::Char File Char.pm Ref Function to fetch one string value from a PDL::Char type PDL, given a position within the PDL.
The input position of the string, not a character in the string. The length of the input
string is the implied first dimension. Module PDL::Char Usage $char = PDL::Char->new( [['abc', 'def', 'ghi'], ['jkl', 'mno', 'pqr']] );
print $char->atstr(0,1);
# Prints:
# jkl= gdImageSetPixels PDL::IO::GD Module PDL::IO::GD File IO/GD.pm; get_PngEx_data PDL::IO::GD Module PDL::IO::GD File IO/GD.pm�slice PDL::Slices Usage $slice = $data->slice([2,3],'x',[2,2,0],"-1:1:-1", "*3"); Example $x->slice('1:3'); # return the second to fourth elements of $x
$x->slice('3:1'); # reverse the above
$x->slice('-2:1'); # return last-but-one to second elements of $x Module PDL::Slices Ref Extract rectangular slices of a piddle, from a string specifier,
an array ref specifier, or a combination. File Slices.pmXgsl_sf_fermi_dirac_mhalf PDL::GSLSF::FERMI_DIRAC Module PDL::GSLSF::FERMI_DIRAC Ref Complete integral F_{-1/2}(x) File GSLSF/FERMI_DIRAC.pm Sig double x(); double [o]y(); double [o]e() Bad gsl_sf_fermi_dirac_mhalf does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.� grandom PDL::Primitive Usage $x = grandom([type], $nx, $ny, $nz,...);
$x = grandom $y; Module PDL::Primitive Ref Constructor which returns piddle of Gaussian random numbers File Primitive.pm(new_or_inplace PDL::Core Usage $w = new_or_inplace(shift());
$w = new_or_inplace(shift(),$preferred_type); Module PDL::Core File Core.pm Ref Return back either the argument pdl or a copy of it depending on whether
it be flagged in-place or no. Handy for building inplace-aware functions.m PDL::GSLSF::DAWSON PDL::GSLSF::DAWSON Ref Module: PDL interface to GSL Special Functions File GSLSF/DAWSON.pm� PDL::IO::Dumper::stringify_PDL PDL::IO::Dumper Ref Turn a PDL into a 1-part perl expr [Internal routine] File IO/Dumper.pm Module PDL::IO::Dumper� dummy PDL::Core Ref Insert a 'dummy dimension' of given length (defaults to 1) File Core.pm Module PDL::Core Example pdl> p sequence(3)->dummy(0,3)
[
[0 0 0]
[1 1 1]
[2 2 2]
] Usage $y = $x->dummy($position[,$dimsize]);� convert PDL::Core Example $y = convert $x, long
$y = convert $x, ushort Module PDL::Core Ref Generic datatype conversion function File Core.pm Usage $y = convert($x, $newtypenum);| mouse_moved PDL::Graphics::TriD::ButtonControl File Graphics/TriD/ButtonControl.pm Module PDL::Graphics::TriD::ButtonControlt _rows PDL::IO::FITS Module PDL::IO::FITS File IO/FITS.pm Ref Return the number of rows in a variable for table entryFgsl_sf_debye_1 PDL::GSLSF::DEBYE Module PDL::GSLSF::DEBYE Ref D_n(x) := n/x^n Integrate[t^n/(e^t - 1), {t,0,x}] File GSLSF/DEBYE.pm Sig double x(); double [o]y(); double [o]e() Bad gsl_sf_debye_1 does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.dmult PDL::Ops Sig a(); b(); [o]c(); int swap Ref multiply two piddles File Ops.pm Module PDL::Ops Example $c = mult $x, $y, 0; # explicit call with trailing 0
$c = $x * $y; # overloaded call
$x->inplace->mult($y,0); # modify $x inplace Bad mult processes bad values.
The state of the bad-value flag of the output piddles is unknown. pnmout PDL::IO::Pnm Bad pnmout does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Ref Write a line of pnm data. File IO/Pnm.pm Sig a(m); int israw; int isbin; char *fd Module PDL::IO::Pnm!ran_poisson PDL::GSL::RNG Module PDL::GSL::RNG File GSL/RNG.pm Ref Fills output piddle by with random integer values from the Poisson distribution with mean C<$mu>. Usage $piddle = $rng->ran_poisson($mu,[list of integers = output piddle dims]);
$rng->ran_poisson($mu,$output_piddle);� podi PDL::Slatec Module PDL::Slatec Sig a(n,n);[o]det(two=2);int job() File Slatec.pm Bad podi does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.� t_quartic PDL::Transform Module PDL::Transform File Transform.pm Ref Quartic scaling -- cylindrical pincushion (n-d; with inverse) Usage $t = t_quartic(<options>);9gsl_sf_angle_restrict_pos PDL::GSLSF::TRIG Bad gsl_sf_angle_restrict_pos does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Sig double [o]y() File GSLSF/TRIG.pm Ref Force an angle to lie in the range [0,2 pi). Module PDL::GSLSF::TRIGcos PDL::Ops Module PDL::Ops Example $y = cos $x;
$x->inplace->cos; # modify $x inplace Ref the cos function File Ops.pm Sig a(); [o]b() Bad cos processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles..Cp2r PDL::Complex Bad Cp2r does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::Complex Sig r(m=2); [o]p(m=2) Ref convert complex numbers in polar (mod,arg) form to rectangular form. Works inplace File Complex.pm�gsl_sf_rect_to_polar PDL::GSLSF::TRIG Bad gsl_sf_rect_to_polar does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::GSLSF::TRIG File GSLSF/TRIG.pm Ref Convert rectlinear to polar coordinates. return argument in range [-pi, pi]. Sig double x(); double y(); double [o]r(); double [o]t(); double [o]re(); double [o]te()Bchcm PDL::Slatec Bad chcm does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. File Slatec.pm Ref Check the given piecewise cubic Hermite function for monotonicity. Sig x(n);f(n);d(n);int check();int [o]ismon(n);int [o]ierr() Module PDL::Slatec�fitpoly1d PDL::Fit::Polynomial Module PDL::Fit::Polynomial Example $yfit = fitpoly1d $data,2; # Least-squares line fit
($yfit, $coeffs) = fitpoly1d $x, $y, 4; # Fit a cubic Sig x(n); y(n); [o]yfit(n); [o]coeffs(order) File Fit/Polynomial.pm Ref Fit 1D polynomials to data using min chi^2 (least squares) Opt Options:
Weights Weights to use in fit, e.g. 1/$sigma**2 (default=1) Usage ($yfit, [$coeffs]) = fitpoly1d [$xdata], $data, $order, [Options...]T PDL::IO::GD PDL::IO::GD Ref Module: Interface to the GD image library. File IO/GD.pmmslice PDL::Core Ref Convenience interface to L<slice|PDL::Slices/slice>,
allowing easier inclusion of dimensions in perl code. File Core.pm Module PDL::Core Example # below is the same as $x->slice("5:7,:,3:4:2")
$w = $x->mslice([5,7],X,[3,4,2]); Usage $w = $x->mslice(...);c pp_boundscheck PDL::PP Ref Control state of PDL bounds checking activity File PP.pod Module PDL::PP^gsl_sf_conicalP_0 PDL::GSLSF::LEGENDRE Module PDL::GSLSF::LEGENDRE Sig double x(); double [o]y(); double [o]e(); double lambda Ref Conical Function P^{0}_{-1/2 + I lambda}(x) File GSLSF/LEGENDRE.pm Bad gsl_sf_conicalP_0 does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.p PDL::GSLSF::POW_INT PDL::GSLSF::POW_INT File GSLSF/POW_INT.pm Ref Module: PDL interface to GSL Special Functionsa PDL::Opt::Simplex PDL::Opt::Simplex File Opt/Simplex.pm Ref Module: Simplex optimization routines�gsl_sf_exprel_n PDL::GSLSF::EXP Bad gsl_sf_exprel_n does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Ref N-relative Exponential. exprel_N(x) = N!/x^N (exp(x) - Sum[x^k/k!, {k,0,N-1}]) = 1 + x/(N+1) + x^2/((N+1)(N+2)) + ... = 1F1(1,1+N,x) File GSLSF/EXP.pm Sig double x(); double [o]y(); double [o]e(); int n Module PDL::GSLSF::EXP�rescale2d PDL::Image2D Bad rescale2d ignores the bad-value flag of the input piddles.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. File Image2D.pm Ref The first piddle is rescaled to the dimensions of the second
(expanding or meaning values as needed) and then added to it in place.
Nothing useful is returned. Sig Int(m,n); O(p,q) Module PDL::Image2Dbandover PDL::Ufunc Module PDL::Ufunc Example $spectrum = andover $image->xchg(0,1) Ref Project via and to N-1 dimensions File Ufunc.pm Sig a(n); int+ [o]b() Usage $y = andover($x); Bad 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,
as it will not contain any bad values.�qagi_meat PDL::GSL::INTEG Ref info not available File GSL/INTEG.pm Sig (double epsabs();double epsrel(); int limit();
double [o] result(); double [o] abserr(); int n(); int [o] ierr();int gslwarn();; SV* function) Module PDL::GSL::INTEG Bad qagi_meat does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.P PDL::IO::Misc PDL::IO::Misc Ref Module: misc IO routines for PDL File IO/Misc.pm� cplx PDL::Complex Usage cplx($real_valued_pdl) Ref Cast a real-valued piddle to the complex datatype. File Complex.pm Module PDL::Complexran_gamma PDL::GSL::RNG File GSL/RNG.pm Ref Fills output piddle with random variates from the gamma distribution. Module PDL::GSL::RNG Usage $piddle = $rng->ran_gamma($pa,$pb,[list of integers = output piddle dims]);
$rng->ran_gamma($pa,$pb,$output_piddle);� ran_chisq_var PDL::GSL::RNG Usage $piddle = $rng->ran_chisq_var($nu_piddle); Module PDL::GSL::RNG File GSL/RNG.pm Ref Similar to L</ran_chisq> except that it takes the distribution
parameters as a piddle and returns a piddle of equal dimensions.\gsl_sf_complex_sin PDL::GSLSF::TRIG Module PDL::GSLSF::TRIG Ref Sin(z) for complex z File GSLSF/TRIG.pm Sig double zr(); double zi(); double [o]x(); double [o]y(); double [o]xe(); double [o]ye() Bad gsl_sf_complex_sin does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.� PDL::IO::Dumper::big_PDL PDL::IO::Dumper Module PDL::IO::Dumper Ref Identify whether a PDL is ``big'' [Internal routine] File IO/Dumper.pmmeq PDL::Ops Bad eq processes bad values.
The state of the bad-value flag of the output piddles is unknown. Example $c = eq $x, $y, 0; # explicit call with trailing 0
$c = $x == $y; # overloaded call
$x->inplace->eq($y,0); # modify $x inplace Module PDL::Ops Sig a(); b(); [o]c(); int swap File Ops.pm Ref binary I<equal to> operation (C<==>)� Cacosh PDL::Complex Sig a(m=2); [o]c(m=2) File Complex.pm Ref Works inplace Module PDL::Complex Bad Cacosh does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.u barf PDL::Core File Core.pm Ref Standard error reporting routine for PDL. Example At the perl level: Module PDL::Coreran_exppow_var PDL::GSL::RNG Usage $piddle = $rng->ran_exppow_var($a_piddle, $b_piddle); Module PDL::GSL::RNG Ref Similar to L</ran_exppow> except that it takes the distribution
parameters as a piddle and returns a piddle of equal dimensions. File GSL/RNG.pma PDL::Threading PDL::Threading Ref Manual: Tutorial for PDL's Threading feature File Threading.pod=patchbad2d PDL::Image2D Sig a(m,n); [o]b(m,n) Ref patch bad pixels out of 2D images containing bad values File Image2D.pm Module PDL::Image2D Bad patchbad2d handles bad values. The output piddle I<may> contain
bad values, depending on the pattern of bad values in the input piddle. Usage $patched = patchbad2d $data;� imagrgb3d PDL::Graphics::TriD Usage imagrdb3d piddle(3,x,y), {OPTIONS}
imagrdb3d [piddle,...], {OPTIONS} Ref 2D RGB image plot as an object inside a 3D space File Graphics/TriD.pm Example e.g. Module PDL::Graphics::TriD&gsl_sf_airy_Ai PDL::GSLSF::AIRY Sig double x(); double [o]y(); double [o]e() File GSLSF/AIRY.pm Ref Airy Function Ai(x). Module PDL::GSLSF::AIRY Bad gsl_sf_airy_Ai does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.� or PDL::Ufunc File Ufunc.pm Ref Return the logical or of all elements in a piddle. Module PDL::Ufunc Bad This routine handles bad values. Usage $x = or($data);� flows PDL::Core Usage something if $x->flows; $hmm = flows($x); Ref Whether or not a piddle is indulging in dataflow File Core.pm Module PDL::Coreran_fdist_var PDL::GSL::RNG Ref Similar to L</ran_fdist> except that it takes the distribution
parameters as a piddle and returns a piddle of equal dimensions. File GSL/RNG.pm Module PDL::GSL::RNG Usage $piddle = $rng->ran_fdist_var($nu1_piddle, $nu2_piddle);|rebin PDL::ImageND Module PDL::ImageND Sig a(m); [o]b(n); int ns => n Ref N-dimensional rebinning algorithm File ImageND.pm Usage $new = rebin $x, $dim1, $dim2,..;.
$new = rebin $x, $template;
$new = rebin $x, $template, {Norm => 1}; Bad rebin does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.� axisvalues PDL::Primitive Module PDL::Primitive Ref Internal routine File Primitive.pm Sig [o,nc]a(n) Bad axisvalues does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.�fitgauss1d PDL::Fit::Gaussian Usage ($cen, $pk, $fwhm, $back, $err, $fit) = fitgauss1d($x, $data); File Fit/Gaussian.pm Ref Fit 1D Gassian to data piddle Sig xval(n); data(n); [o]xcentre();[o]peak_ht(); [o]fwhm();
[o]background();int [o]err(); [o]datafit(n);
[t]sig(n); [t]ytmp(n); [t]yytmp(n); [t]rtmp(n); Example ($cen, $pk, $fwhm, $back, $err, $fit) = fitgauss1d($x, $data); Module PDL::Fit::Gaussian+polyvalue PDL::Slatec File Slatec.pm Ref Use the coefficients C<c> generated by C<polyfit> (or C<polfit>) to evaluate
the polynomial fit of degree C<l>, along with the first C<nder> of its
derivatives, at a specified point C<x>. Module PDL::Slatec Usage ($yfit, $yp) = polyvalue($l, $nder, $x, $c); ran_cauchy PDL::GSL::RNG Usage $piddle = $rng->ran_cauchy($pa,[list of integers = output piddle dims]);
$rng->ran_cauchy($pa,$output_piddle); Module PDL::GSL::RNG Ref Fills output piddle with random variates from the Cauchy distribution with scale parameter C<$pa>. File GSL/RNG.pm7 ColorExact PDL::IO::GD File IO/GD.pm Module PDL::IO::GD� kernctr PDL::ImageND Usage $kernel = kernctr($image,$smallk);
fftconvolve($image,$kernel); File ImageND.pm Ref `centre' a kernel (auxiliary routine to fftconvolve) Module PDL::ImageND� set PDL::Func Module PDL::Func Ref Set attributes for a PDL::Func object. File Func.pm Usage my $nset = $obj->set( x => $newx, y => $newy );
my $nset = $obj->set( { x => $newx, y => $newy } );� set PDL::Core Ref Set a single value inside a piddle File Core.pm Module PDL::Core Example pdl> $x = sequence 3,4
pdl> set $x, 2,1,99
pdl> p $x
[
[ 0 1 2]
[ 3 4 99]
[ 6 7 8]
[ 9 10 11]
] Usage set $piddle, @position, $valueeborover PDL::Ufunc Example $spectrum = borover $image->xchg(0,1) Module PDL::Ufunc File Ufunc.pm Ref Project via bitwise or to N-1 dimensions Sig a(n); [o]b() Usage $y = borover($x); Bad 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,
as it will not contain any bad values.gbessyn PDL::Math Sig a(); int n(); [o]b() File Math.pm Ref The regular Bessel function of the first kind, Y_n
.
This takes a second int argument which gives the order
of the function required.
Works inplace. Module PDL::Math Bad bessyn processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.� get PDL::Func Usage my $x = $obj->get( x );
my ( $x, $y ) = $obj->get( qw( x y ) ); Module PDL::Func Ref Get attributes from a PDL::Func object. File Func.pm{get PDL::GSL::RNG Usage $piddle = $rng->get($list_of_integers)
$rng->get($piddle); File GSL/RNG.pm Ref This function creates a piddle with given dimensions or accepts an
existing piddle and fills it. get() returns integer values
between a minimum and a maximum specific to every RNG. Module PDL::GSL::RNG Example $x = zeroes 5,6;
$o = $rng->get(10,10); $rng->get($x);M PDL::MATLAB PDL::MATLAB Ref Manual: A guide for MATLAB users. File MATLAB.pod� write_png PDL::IO::GD Bad write_png does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. File IO/GD.pm Sig byte img(x,y); byte lut(i,j); char* filename Module PDL::IO::GD�ran_negative_binomial PDL::GSL::RNG Usage $piddle = $rng->ran_negative_binomial($p,$n,[list of integers = output piddle dims]);
$rng->ran_negative_binomial($p,$n,$output_piddle); Ref Fills output piddle with random integer values from the negative binomial
distribution, the number of failures occurring before C<$n> successes in
independent trials with probability C<$p> of success. Note that C<$n> is
not required to be an integer. File GSL/RNG.pm Module PDL::GSL::RNG� indexND PDL::Slices Example $out = $source->indexND( $index, [$method] ) Module PDL::Slices Ref Find selected elements in an N-D piddle, with optional boundary handling File Slices.pm!gsl_sf_gammainv PDL::GSLSF::GAMMA Bad gsl_sf_gammainv does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::GSLSF::GAMMA Sig double x(); double [o]y(); double [o]e() File GSLSF/GAMMA.pm Ref 1/Gamma(x)Fgsl_sf_debye_3 PDL::GSLSF::DEBYE Module PDL::GSLSF::DEBYE Sig double x(); double [o]y(); double [o]e() File GSLSF/DEBYE.pm Ref D_n(x) := n/x^n Integrate[t^n/(e^t - 1), {t,0,x}] Bad gsl_sf_debye_3 does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.tgsl_sf_airy_Ai_scaled PDL::GSLSF::AIRY Bad gsl_sf_airy_Ai_scaled does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::GSLSF::AIRY Sig double x(); double [o]y(); double [o]e() File GSLSF/AIRY.pm Ref Scaled Airy Function Ai(x). Ai(x) for x < 0 and exp(+2/3 x^{3/2}) Ai(x) for x > 0.� t_radial PDL::Transform Usage $f = t_radial(<options>); File Transform.pm Ref Convert Cartesian to radial/cylindrical coordinates. (2-D/3-D; with inverse) Module PDL::Transform4 SetClip PDL::IO::GD File IO/GD.pm Module PDL::IO::GDEgsl_sf_atanint PDL::GSLSF::EXPINT Bad gsl_sf_atanint does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. File GSLSF/EXPINT.pm Ref AtanInt(x) := Integral[ Arctan[t]/t, {t,0,x}] Sig double x(); double [o]y(); double [o]e() Module PDL::GSLSF::EXPINT^zeroes PDL::Core Usage # usage type (i):
$w = zeroes([type], $nx, $ny, $nz,...);
$w = PDL->zeroes([type], $nx, $ny, $nz,...);
$w = $pdl->zeroes([type], $nx, $ny, $nz,...);
# usage type (ii):
$w = zeroes $y;
$w = $y->zeroes
zeroes inplace $w; # Equivalent to $w .= 0;
$w->inplace->zeroes; # "" File Core.pm Ref construct a zero filled piddle from dimension list or template piddle. Module PDL::Core Example pdl> $z = zeroes 4,3
pdl> p $z
[
[0 0 0 0]
[0 0 0 0]
[0 0 0 0]
]
pdl> $z = zeroes ushort, 3,2 # Create ushort array
[ushort() etc. with no arg returns a PDL::Types token]�gsl_sf_hyperg_1F1 PDL::GSLSF::HYPERG Bad gsl_sf_hyperg_1F1 does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::GSLSF::HYPERG File GSLSF/HYPERG.pm Ref Confluent hypergeometric function for integer parameters. 1F1[a,b,x] = M(a,b,x) Sig double x(); double [o]y(); double [o]e(); double a; double b� bytescl PDL::ImageRGB Usage $scale = $im->bytescl([$top]) Ref Scales a pdl into a specified data range (default 0-255) File ImageRGB.pm Module PDL::ImageRGB�polyfit PDL::Slatec Bad This version of polyfit handles bad values correctly. Bad values in
$y are ignored for the fit and give computed values on the fitted
curve in the return. Bad values in $x or $w are ignored for the fit and
result in bad elements in the output. Usage ($ndeg, $r, $ierr, $c, $coeffs, $rms) = polyfit($x, $y, $w, $maxdeg, [$eps]); Ref Fit discrete data in a least squares sense by polynomials
in one variable. Handles threading correctly--one can pass in a 2D PDL (as C<$y>)
and it will pass back a 2D PDL, the rows of which are the polynomial regression
results (in C<$r> corresponding to the rows of $y. File Slatec.pm Module PDL::Slatec< purge PDL::DiskCache File DiskCache.pm Module PDL::DiskCache#whist PDL::Basic File Basic.pm Ref Create a weighted histogram of a piddle Example pdl> p $y
[13 10 13 10 9 13 9 12 11 10 10 13 7 6 8 10 11 7 12 9 11 11 12 6 12 7]
pdl> $wt = grandom($y->nelem)
pdl> $h = whist $y, $wt, 0, 20, 1 # hist with step 1, min 0 and 20 bins
pdl> p $h
[0 0 0 0 0 0 -0.49552342 1.7987439 0.39450696 4.0073722 -2.6255299 -2.5084501 2.6458365 4.1671676 0 0 0 0 0 0] Module PDL::Basic Usage $hist = whist($data, $wt, [$min,$max,$step]);
($xvals,$hist) = whist($data, $wt, [$min,$max,$step]);pgsl_sf_synchrotron_2 PDL::GSLSF::SYNCHROTRON Bad gsl_sf_synchrotron_2 does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Sig double x(); double [o]y(); double [o]e() Ref Second synchroton function: synchrotron_2(x) = x * K_{2/3}(x) File GSLSF/SYNCHROTRON.pm Module PDL::GSLSF::SYNCHROTRONKgsl_sf_bessel_jl PDL::GSLSF::BESSEL Module PDL::GSLSF::BESSEL File GSLSF/BESSEL.pm Ref Regular Sphericl Bessel Function J_n(x). Sig double x(); double [o]y(); double [o]e(); int n Bad gsl_sf_bessel_jl does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.8gsl_sf_Shi PDL::GSLSF::EXPINT Bad gsl_sf_Shi does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Sig double x(); double [o]y(); double [o]e() Ref Shi(x) := Integrate[ Sinh[t]/t, {t,0,x}] File GSLSF/EXPINT.pm Module PDL::GSLSF::EXPINThgsl_sf_bessel_J_array PDL::GSLSF::BESSEL Bad gsl_sf_bessel_J_array does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Ref Array of Regular Bessel Functions J_{s}(x) to J_{s+n-1}(x). File GSLSF/BESSEL.pm Sig double x(); double [o]y(num); int s; int n=>num Module PDL::GSLSF::BESSEL� asin PDL::Math Bad asin processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::Math Sig a(); [o]b() File Math.pmh zlinvals PDL::Basic Module PDL::Basic Ref Z axis values between endpoints (see L</zvals>). File Basic.pm� PDL::Graphics::TriD::MathGraph PDL::Graphics::TriD::MathGraph Ref Module: Mathematical Graph objects for PDL File Graphics/TriD/MathGraph.pmUran_lognormal PDL::GSL::RNG Usage $piddle = $rng->ran_lognormal($mu,$sigma,[list of integers = output piddle dims]);
$rng->ran_lognormal($mu,$sigma,$output_piddle); Ref Fills output piddle with random variates from the lognormal distribution with
parameters C<$mu> (location) and C<$sigma> (scale). File GSL/RNG.pm Module PDL::GSL::RNGw realfft PDL::FFT Usage realfft($real); Module PDL::FFT Ref One-dimensional FFT of real function [inplace]. File FFT.pm� wpnm PDL::IO::Pnm Ref Write a pnm (portable bitmap/pixmap, pbm/ppm) file into a file. File IO/Pnm.pm Module PDL::IO::Pnm Usage $im = wpnm $pdl, $file, $format[, $raw];(ran_exponential PDL::GSL::RNG Ref Fills output piddle with random variates from the exponential distribution with mean C<$mu>. File GSL/RNG.pm Module PDL::GSL::RNG Usage $piddle = $rng->ran_exponential($mu,[list of integers = output piddle dims]);
$rng->ran_exponential($mu,$output_piddle);� Csqrt PDL::Complex Ref Works inplace File Complex.pm Sig a(m=2); [o]c(m=2) Module PDL::Complex Bad Csqrt does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.a PDL::Options PDL::Options File Options.pm Ref Module: simplifies option passing by hash in PerlDLf indexNDb PDL::Slices Module PDL::Slices File Slices.pm Ref Backwards-compatibility alias for indexND&rotate PDL::Slices Bad rotate does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Sig x(n); indx shift(); [oca]y(n) File Slices.pm Ref Shift vector elements along with wrap. Flows data back&forth. Module PDL::Slices6 Rectangle PDL::IO::GD File IO/GD.pm Module PDL::IO::GD� band PDL::Ufunc Bad This routine handles bad values. Usage $x = band($data); Ref Return the bitwise and of all elements in a piddle. File Ufunc.pm Module PDL::Ufunce PDL::Fit::Gaussian PDL::Fit::Gaussian File Fit/Gaussian.pm Ref Module: routines for fitting gaussiansCabs PDL::Complex Module PDL::Complex Ref complex C<abs()> (also known as I<modulus>) File Complex.pm Sig a(m=2); [o]c() Bad Cabs does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.� readflex PDL::IO::FlexRaw Usage Module PDL::IO::FlexRaw Ref Read a binary file with flexible format specification File IO/FlexRaw.pm� do_print pdl2 Module pdl2 Example pdl> $x = pdl(3,2) File pdl2.pod Ref Toggle print-by-default on and off (default value: off)y do_print PDL::Perldl2::Plugin::PrintControl Module PDL::Perldl2::Plugin::PrintControl File Perldl2/Plugin/PrintControl.pm? gdImageDashedLines PDL::IO::GD File IO/GD.pm Module PDL::IO::GD� grabpic3d PDL::Graphics::TriD File Graphics/TriD.pm Ref Grab a 3D image from the screen. Module PDL::Graphics::TriD Usage $pic = grabpic3d();m PDL::GSLSF::EXPINT PDL::GSLSF::EXPINT File GSLSF/EXPINT.pm Ref Module: PDL interface to GSL Special Functions$gsl_sf_lnchoose PDL::GSLSF::GAMMA Module PDL::GSLSF::GAMMA Ref log(n choose m) File GSLSF/GAMMA.pm Sig n(); m(); double [o]y(); double [o]e() Bad gsl_sf_lnchoose does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.~ ButtonRelease PDL::Graphics::TriD::ButtonControl Module PDL::Graphics::TriD::ButtonControl File Graphics/TriD/ButtonControl.pm
gsl_sf_fact PDL::GSLSF::GAMMA Module PDL::GSLSF::GAMMA Ref n! File GSLSF/GAMMA.pm Sig x(); double [o]y(); double [o]e() Bad gsl_sf_fact does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. bitnot PDL::Ops Example $y = ~ $x;
$x->inplace->bitnot; # modify $x inplace Module PDL::Ops Sig a(); [o]b() Ref unary bit negation File Ops.pm Bad bitnot processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.� deep_copy PDL::IO::Dumper Module PDL::IO::Dumper File IO/Dumper.pm Ref Convenience function copies a complete perl data structure by the
brute force method of "eval sdump". vzeroes PDL::Matrix Example print $v = vsequence(2);
[
[0]
[1]
] Module PDL::Matrix Names vzeroes,vones,vsequence Ref constructs a PDL::Matrix object with matrix dimensions (n x 1),
therefore only the first scalar argument is used. File Matrix.pmP _read_flexhdr PDL::IO::FlexRaw Module PDL::IO::FlexRaw File IO/FlexRaw.pm Usage 6 Interlace PDL::IO::GD File IO/GD.pm Module PDL::IO::GD0graticule PDL::Transform::Cartography Usage $lonlatp = graticule(<grid-spacing>,<line-segment-size>);
$lonlatp = graticule(<grid-spacing>,<line-segment-size>,1); Module PDL::Transform::Cartography Ref (Cartography) PDL constructor - generate a lat/lon grid. File Transform/Cartography.pm� _rabs PDL::Ops Ref Returns the absolute value of a number. File Ops.pm Sig a(); [o]b() Module PDL::Ops Bad _rabs processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.� set_wh PDL::Graphics::TriD::ButtonControl File Graphics/TriD/ButtonControl.pm Ref Define the width and Height of the window for button control Module PDL::Graphics::TriD::ButtonControltypesrtkeys PDL::Types Ref Returns an array of keys of typehash sorted in order of type complexity File Types.pm Module PDL::Types Example pdl> @typelist = PDL::Types::typesrtkeys;
pdl> print @typelist;
PDL_B PDL_S PDL_US PDL_L PDL_IND PDL_LL PDL_F PDL_D6 gdImageSX PDL::IO::GD File IO/GD.pm Module PDL::IO::GDderiv2 PDL::GSL::INTERP Usage Example Example: Module PDL::GSL::INTERP Ref The deriv2 function returns the second derivative
of the interpolating function at a given point.
It will barf with an "input domain error" if you try to extrapolate. File GSL/INTERP.pm� PDL::Graphics::TriD::Objects PDL::Graphics::TriD::Objects Ref Module: Simple Graph Objects for TriD File Graphics/TriD/Objects.pmRiis PDL::Graphics::IIS Usage iis $image, [ { MIN => $min, MAX => $max,
TITLE => 'pretty picture',
FRAME => 2 } ]
iis $image, [$min,$max] Module PDL::Graphics::IIS Sig image(m,n),[\%options]) or (image(m,n),[min(),max()] Ref Displays an image on a IIS device (e.g. SAOimage/Ximtool) File Graphics/IIS.pm� cosh PDL::Math Sig a(); [o]b() File Math.pm Module PDL::Math Bad cosh processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.I read_png_true PDL::IO::GD File IO/GD.pm Sig $filename Module PDL::IO::GDC gdImageColorClosestHWB PDL::IO::GD File IO/GD.pm Module PDL::IO::GD| PDL::GSLSF::SYNCHROTRON PDL::GSLSF::SYNCHROTRON File GSLSF/SYNCHROTRON.pm Ref Module: PDL interface to GSL Special Functions0gsl_sf_lnsinh PDL::GSLSF::TRIG Module PDL::GSLSF::TRIG Ref Log(Sinh(x)) with GSL semantics. File GSLSF/TRIG.pm Sig double x(); double [o]y(); double [o]e() Bad gsl_sf_lnsinh does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.D load_lut PDL::IO::GD File IO/GD.pm Sig $filename Module PDL::IO::GDLgsl_sf_cos_err PDL::GSLSF::TRIG Module PDL::GSLSF::TRIG File GSLSF/TRIG.pm Ref Cos(x) for quantity with an associated error. Sig double x(); double dx(); double [o]y(); double [o]e() Bad gsl_sf_cos_err does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.Fgsl_sf_debye_4 PDL::GSLSF::DEBYE Bad gsl_sf_debye_4 does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::GSLSF::DEBYE Sig double x(); double [o]y(); double [o]e() Ref D_n(x) := n/x^n Integrate[t^n/(e^t - 1), {t,0,x}] File GSLSF/DEBYE.pm1 Line PDL::IO::GD Module PDL::IO::GD File IO/GD.pm�which PDL::Primitive Sig mask(n); indx [o] inds(m) File Primitive.pm Ref Returns indices of non-zero values from a 1-D PDL Example pdl> $x = sequence(10); p $x
[0 1 2 3 4 5 6 7 8 9]
pdl> $indx = which($x>6); p $indx
[7 8 9] Module PDL::Primitive Bad which processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Usage $i = which($mask);4 SetTile PDL::IO::GD Module PDL::IO::GD File IO/GD.pm� dprod PDL::Ufunc Module PDL::Ufunc File Ufunc.pm Ref Return the product (in double precision) of all elements in a piddle. Usage $x = dprod($data); Bad This routine handles bad values.� t_az_eqa PDL::Transform::Cartography File Transform/Cartography.pm Ref (Cartography) Azimuthal equal-area projection (az.; auth.) Module PDL::Transform::Cartography Usage $t = t_az_eqa(<options>);�uniqind PDL::Primitive Bad Bad values are not considered unique by uniqind and are ignored. Example PDL> p pdl(2,2,2,4,0,-1,6,6)->uniqind
[5 4 1 3 6] # the 0 at index 4 is returned 2nd, but... Module PDL::Primitive File Primitive.pm Ref Return the indices of all unique elements of a piddle
The order is in the order of the values to be consistent
with uniq. C<NaN> values never compare equal with any
other value and so are always unique. This follows the
Matlab usage.�orig_badvalue PDL::Bad Ref returns the original value used to represent bad values for
a given type. File Bad.pm Example $orig_badval = orig_badvalue( float );
$x = ones(ushort,10);
print "The original bad data value for ushort is: ",
$x->orig_badvalue(), "\n"; Module PDL::Bad Bad This method does not care if you call it on an input piddle
that has bad values. It always returns a Perl scalar
with the original bad value for the associated type.�gsl_sf_conicalP_sph_reg PDL::GSLSF::LEGENDRE Bad gsl_sf_conicalP_sph_reg does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. File GSLSF/LEGENDRE.pm Ref Regular Spherical Conical Function P^{-1/2-l}_{-1/2 + I lambda}(x) Sig double x(); double [o]y(); double [o]e(); int l; double lambda Module PDL::GSLSF::LEGENDRE� writeflex PDL::IO::FlexRaw Usage Module PDL::IO::FlexRaw Ref Write a binary file with flexible format specification File IO/FlexRaw.pm� got_complex_version PDL::Core::Dev File Core/Dev.pm Ref PDL::Core::Dev::got_complex_version($func_name, $num_params) Module PDL::Core::Dev{ PDL::Graphics::IIS PDL::Graphics::IIS Ref Module: Display PDL images on IIS devices (saoimage/ximtool) File Graphics/IIS.pm^orover PDL::Ufunc Bad 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,
as it will not contain any bad values. Usage $y = orover($x); File Ufunc.pm Ref Project via or to N-1 dimensions Sig a(n); int+ [o]b() Example $spectrum = orover $image->xchg(0,1) Module PDL::Ufunc\gsl_sf_complex_cos PDL::GSLSF::TRIG Module PDL::GSLSF::TRIG Sig double zr(); double zi(); double [o]x(); double [o]y(); double [o]xe(); double [o]ye() Ref Cos(z) for complex z File GSLSF/TRIG.pm Bad gsl_sf_complex_cos does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.unthread PDL::Slices Module PDL::Slices Ref All threaded dimensions are made real again. File Slices.pm Sig P(); C(); int atind Bad unthread does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.U PDL::Bugs PDL::Bugs File Bugs.pod Ref Manual: How to diagnose and report PDL problems*minimum PDL::Ufunc Ref Project via minimum to N-1 dimensions File Ufunc.pm Sig a(n); [o]c() Module PDL::Ufunc Example $spectrum = minimum $image->xchg(0,1) Bad Output is set bad if all elements of the input are bad,
otherwise the bad flag is cleared for the output piddle. Usage $y = minimum($x);0gsl_sf_psi_n PDL::GSLSF::PSI Module PDL::GSLSF::PSI File GSLSF/PSI.pm Ref Poly-Gamma Function psi^(n)(x) Sig double x(); double [o]y(); double [o]e(); int n Bad gsl_sf_psi_n does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.Ngsl_sf_dawson PDL::GSLSF::DAWSON Bad gsl_sf_dawson does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Sig double x(); double [o]y(); double [o]e() File GSLSF/DAWSON.pm Ref Dawsons integral: Exp[-x^2] Integral[ Exp[t^2], {t,0,x}] Module PDL::GSLSF::DAWSONu PDL::IO::Storable PDL::IO::Storable Ref Module: helper functions to make PDL usable with Storable File IO/Storable.pm.mnparm PDL::Minuit Module PDL::Minuit File Minuit.pm Ref info not available Sig int a(); double b(); double c(); double d(); double e(); int [o] ia(); char* str Bad mnparm does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.g PDL::GSLSF::POLY PDL::GSLSF::POLY File GSLSF/POLY.pm Ref Module: PDL interface to GSL Special Functions� t_lambert PDL::Transform::Cartography Usage $t = t_lambert(<options>); File Transform/Cartography.pm Ref (Cartography) Lambert conic projection (conic; conformal) Module PDL::Transform::Cartography� fdump PDL::IO::Dumper Usage use PDL::IO::Dumper;
fdump(<VAR>,$filename);
...
<VAR> = frestore($filename); Module PDL::IO::Dumper Ref Dump a data structure to a file File IO/Dumper.pm�setbadat PDL::Bad Example pdl> $x = sequence 3,4
pdl> $x->setbadat 2,1
pdl> p $x
[
[ 0 1 2]
[ 3 4 BAD]
[ 6 7 8]
[ 9 10 11]
] Module PDL::Bad File Bad.pm Ref Set the value to bad at a given position. Usage setbadat $piddle, @position Bad This method can be called on piddles that have bad values.
The remainder of the arguments should be Perl scalars indicating
the position to set as bad. The output piddle will have bad values
and will have its badflag turned on.T fits_field_cmp PDL::IO::FITS Ref fits_field_cmp File IO/FITS.pm Module PDL::IO::FITS1 Arcs PDL::IO::GD Module PDL::IO::GD File IO/GD.pml PDL::Graphics::TriD::VRML PDL::Graphics::TriD::VRML Ref Module: TriD VRML backend File Graphics/TriD/VRML.pm7 Rectangles PDL::IO::GD File IO/GD.pm Module PDL::IO::GDk PDL::Graphics::TriD::Labels PDL::Graphics::TriD::Labels File Graphics/TriD/Labels.pm Ref Module: Text tools> gdImageFilledArcs PDL::IO::GD File IO/GD.pm Module PDL::IO::GDY maxover_n_ind PDL::Ufunc Module PDL::Ufunc File Ufunc.pm Ref Synonym for maximum_n_ind.< mn_emat PDL::Minuit Module PDL::Minuit File Minuit.pm Usage � erfc PDL::Math Bad erfc processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. File Math.pm Ref The complement of the error function. Works inplace. Sig a(); [o]b() Module PDL::Math� pcoef PDL::Slatec File Slatec.pm Sig int l();c();[o]tc(bar);a(foo) Module PDL::Slatec Bad pcoef does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.t PDL::Graphics::LUT PDL::Graphics::LUT File Graphics/LUT.pm Ref Module: provides access to a number of look-up tables� t_linear PDL::Transform Usage $f = t_linear({options}); Module PDL::Transform Ref Linear (affine) transformations with optional offset File Transform.pm: gdImageCharUp PDL::IO::GD File IO/GD.pm Module PDL::IO::GD� gslinteg_qagi PDL::GSL::INTEG Usage File GSL/INTEG.pm Ref Please check the GSL documentation for more information. Module PDL::GSL::INTEG Example Example:- float PDL::Core Module PDL::Core File Core.pm^ pp_done PDL::PP Ref Mark the end of PDL::PP definitions in the file File PP.pod Module PDL::PP� gslinteg_qag PDL::GSL::INTEG Module PDL::GSL::INTEG Example Example: File GSL/INTEG.pm Ref Please check the GSL documentation for more information. Usage � dims PDL::Core Ref Return piddle dimensions as a perl list File Core.pm Example pdl> p @tmp = dims zeroes 10,3,22
10 3 22 Module PDL::Core Usage @dims = $piddle->dims; @dims = dims($piddle);-vsearch_insert_leftmost PDL::Primitive Module PDL::Primitive Sig vals(); x(n); indx [o]idx() File Primitive.pm Ref Determine the insertion point for values in a sorted array, inserting before duplicates. Usage $idx = vsearch_insert_leftmost($vals, $x); Bad needs major (?) work to handles bad values3 to_pdl PDL::IO::GD File IO/GD.pm Module PDL::IO::GD�repulse PDL::Graphics::TriD::Rout Module PDL::Graphics::TriD::Rout Sig (coords(nc,np);
[o]vecs(nc,np);
int [t]links(np);;
double boxsize;
int dmult;
double a;
double b;
double c;
double d;
) File Graphics/TriD/Rout.pm Ref Repulsive potential for molecule-like constructs. Bad repulse does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.,ran_pareto PDL::GSL::RNG Usage $piddle = $rng->ran_pareto($pa,$lb,[list of integers = output piddle dims]);
$rng->ran_pareto($pa,$lb,$output_piddle); Module PDL::GSL::RNG File GSL/RNG.pm Ref Fills output piddle with random variates from the Pareto distribution of
order C<$pa> and scale C<$lb>.� stretcher PDL::MatrixOps Ref Return a diagonal matrix with the specified diagonal elements File MatrixOps.pm Sig a(n); [o]b(n,n) Module PDL::MatrixOps Usage $mat = stretcher($eigenvalues);Cscale PDL::Complex Module PDL::Complex File Complex.pm Ref mixed complex/real multiplication Sig a(m=2); b(); [o]c(m=2) Bad Cscale does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.< FilledRectangle PDL::IO::GD Module PDL::IO::GD File IO/GD.pmSgsl_sf_zeta PDL::GSLSF::ZETA Bad gsl_sf_zeta does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. File GSLSF/ZETA.pm Ref Riemann Zeta Function zeta(x) = Sum[ k^(-s), {k,1,Infinity} ], s != 1.0 Sig double x(); double [o]y(); double [o]e() Module PDL::GSLSF::ZETAlndtri PDL::Math Bad ndtri processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::Math Ref The value for which the area under the
Gaussian probability density function (integrated from
minus infinity) is equal to the argument (cf L</erfi>). Works inplace. File Math.pm Sig a(); [o]b()� hdr PDL::Core Module PDL::Core Example $pdl->hdr->{CDELT1} = 1; File Core.pm Ref Retrieve or set header information from a piddleu PDL::Course PDL::Course File Course.pod Ref Manual: A journey through PDL's documentation, from beginner to advanced.Q PDL::Core::Dev PDL::Core::Dev Ref Module: PDL development module File Core/Dev.pm6 gdImageSY PDL::IO::GD Module PDL::IO::GD File IO/GD.pm? gdImageColorsTotal PDL::IO::GD Module PDL::IO::GD File IO/GD.pmi pptemplate pptemplate Ref Script: script to generate Makefile.PL and PP file skeleton File pptemplate.podo x PDL::Primitive Sig a(i,z), b(x,i),[o]c(x,z) Ref Matrix multiplication File Primitive.pm Module PDL::Primitivev TBD PDL::Graphics::OpenGL::Perl::OpenGL File Graphics/OpenGL/Perl/OpenGL.pm Module PDL::Graphics::OpenGL::Perl::OpenGL4 GetClip PDL::IO::GD Module PDL::IO::GD File IO/GD.pm� circ_mean PDL::ImageND File ImageND.pm Ref Smooths an image by applying circular mean.
Optionally takes the center to be used. Module PDL::ImageND Usage circ_mean($im);
circ_mean($im,{Center => [10,10]});8 ColorsTotal PDL::IO::GD File IO/GD.pm Module PDL::IO::GDH read_png_lut PDL::IO::GD File IO/GD.pm Sig $filename Module PDL::IO::GD�setvaltobad PDL::Bad Bad The output always has its bad flag set, even if it does not contain
any bad values (use L</check_badflag> to check
whether there are any bad values in the output).
Any bad values in the input piddles are copied across to the output piddle. Module PDL::Bad Example $x = sequence(10) % 3;
$x->inplace->setvaltobad( 0 );
print "$x\n";
[BAD 1 2 BAD 1 2 BAD 1 2 BAD] Ref Set bad all those elements which equal the supplied value. File Bad.pm Sig a(); [o]b(); double value� all PDL::Ufunc Ref Return true if all elements in piddle set File Ufunc.pm Example if (all $x>15) { print "all values are greater than 15\n" } Module PDL::Ufunc Bad See L</and> for comments on what happens when all elements
in the check are bad.� t_hammer PDL::Transform::Cartography File Transform/Cartography.pm Ref (Cartography) Hammer/Aitoff elliptical projection (az.; auth.) Module PDL::Transform::Cartography� min PDL::GSL::RNG File GSL/RNG.pm Ref Return the minimum value generable by this RNG. Example $min = $rng->min(); $max = $rng->max(); Module PDL::GSL::RNG Usage $integer = $rng->min();� min PDL::Ufunc Usage $x = min($data); Bad This routine handles bad values. Module PDL::Ufunc Ref Return the minimum of all elements in a piddle. File Ufunc.pm� gslinteg_qagiu PDL::GSL::INTEG Usage Example Example: Module PDL::GSL::INTEG File GSL/INTEG.pm Ref Please check the GSL documentation for more information.gbessjn PDL::Math Bad bessjn processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Ref The regular Bessel function of the first kind, J_n
.
This takes a second int argument which gives the order
of the function required.
Works inplace. File Math.pm Sig a(); int n(); [o]b() Module PDL::Math�gsl_sf_lngamma PDL::GSLSF::GAMMA Ref Log[Gamma(x)], x not a negative integer Uses real Lanczos method. Determines the sign of Gamma[x] as well as Log[|Gamma[x]|] for x < 0. So Gamma[x] = sgn * Exp[result_lg]. File GSLSF/GAMMA.pm Sig double x(); double [o]y(); double [o]s(); double [o]e() Module PDL::GSLSF::GAMMA Bad gsl_sf_lngamma does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.�qng_meat PDL::GSL::INTEG Sig (double a(); double b(); double epsabs();
double epsrel(); double [o] result(); double [o] abserr();
int [o] neval(); int [o] ierr(); int gslwarn(); SV* function) Ref info not available File GSL/INTEG.pm Module PDL::GSL::INTEG Bad qng_meat does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.�gsl_sf_complex_dilog PDL::GSLSF::DILOG Module PDL::GSLSF::DILOG Sig double r(); double t(); double [o]re(); double [o]im(); double [o]ere(); double [o]eim() File GSLSF/DILOG.pm Ref DiLogarithm(z), for complex argument z = r Exp[i theta]. Bad gsl_sf_complex_dilog does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.>gsl_sf_airy_Ai_deriv PDL::GSLSF::AIRY Bad gsl_sf_airy_Ai_deriv does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::GSLSF::AIRY Ref Derivative Airy Function Ai`(x). File GSLSF/AIRY.pm Sig double x(); double [o]y(); double [o]e()Z pp_addxs PDL::PP File PP.pod Ref Add extra XS code to the generated XS file Module PDL::PPSpdl PDL::Core Module PDL::Core Example $x = pdl [1..10]; # 1D array
$x = pdl ([1..10]); # 1D array
$x = pdl (1,2,3,4); # Ditto
$y = pdl [[1,2,3],[4,5,6]]; # 2D 3x2 array
$y = pdl "[[1,2,3],[4,5,6]]"; # Ditto (slower)
$y = pdl "[1 2 3; 4 5 6]"; # Ditto
$y = pdl q[1 2 3; 4 5 6]; # Ditto, using the q quote operator
$y = pdl "1 2 3; 4 5 6"; # Ditto, less obvious, but still works
$y = pdl 42 # 0-dimensional scalar
$c = pdl $x; # Make a new copy File Core.pm Ref PDL constructor - creates new piddle from perl scalars/arrays, piddles, and strings Usage $double_pdl = pdl(SCALAR|ARRAY REFERENCE|ARRAY|STRING); # default type
$type_pdl = pdl(PDL::Type,SCALAR|ARRAY REFERENCE|ARRAY|STRING);� t_utm PDL::Transform::Cartography Usage $t = t_utm(<zone>,<options>); Ref (Cartography) Universal Transverse Mercator projection (cylindrical) File Transform/Cartography.pm Module PDL::Transform::Cartography� rfft PDL::Slatec Module PDL::Slatec Example $v_out = PDL::Slatec::rfft($azero,$x,$y);
print $v_in, $vout
[1 0 1 0] [1 0 1 0] Ref reverse Fast Fourier Transform File Slatec.pmR pp_addpm PDL::PP Module PDL::PP Ref Add code to the generated .pm file File PP.pod� swcols PDL::IO::Misc Usage @str = swcols format, pdl1,pdl2,pdl3,...;
or $str = swcols format, pdl1,pdl2,pdl3,...; Module PDL::IO::Misc File IO/Misc.pm Ref generate string list from C<sprintf> format specifier and a list of piddlesg PDL::GSLSF::AIRY PDL::GSLSF::AIRY Ref Module: PDL interface to GSL Special Functions File GSLSF/AIRY.pm@dcumusumover PDL::Ufunc Example $spectrum = cumusumover $image->xchg(0,1) Module PDL::Ufunc Sig a(n); double [o]b(n) Ref Cumulative sum File Ufunc.pm Usage $y = cumusumover($x); Bad dcumusumover processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.H vsequence PDL::Matrix File Matrix.pm Module PDL::Matrix Crossref vzeroes� avg PDL::Ufunc Module PDL::Ufunc File Ufunc.pm Ref Return the average of all elements in a piddle. Usage $x = avg($data); Bad This routine handles bad values.< mn_stat PDL::Minuit File Minuit.pm Module PDL::Minuit Usage d PDL::GSLSF::LOG PDL::GSLSF::LOG File GSLSF/LOG.pm Ref Module: PDL interface to GSL Special Functions� maximum_n_ind PDL::Ufunc Bad Not yet been converted to ignore bad values Sig a(n); indx [o]c(m) File Ufunc.pm Ref Returns the index of C<m> maximum elements Module PDL::UfuncNset_colortable PDL::Graphics::TriD::Contours Usage $table is passed in as either a piddle of [3,n] colors, where n is the
number of contour levels, or as a reference to a function which
expects the number of contour levels as an argument and returns a
[3,n] piddle. It should be straight forward to use the
L<PDL::Graphics::LUT> tables in a function which subsets the 256
colors supplied by the look up table into the number of colors needed
by Contours. Module PDL::Graphics::TriD::Contours Sig $table Ref Sets contour level colors based on the color table. File Graphics/TriD/Contours.pm� atan PDL::Math Module PDL::Math Sig a(); [o]b() File Math.pm Bad atan processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.< gdImageGetPixel PDL::IO::GD File IO/GD.pm Module PDL::IO::GDF gdImageColorAllocateAlpha PDL::IO::GD Module PDL::IO::GD File IO/GD.pm� thread2 PDL::Core Usage $xx = $x->thread2(3,1) File Core.pm Ref Explicit threading over specified dims using thread id 2. Example Wibble Module PDL::Core3gsl_sf_gamma PDL::GSLSF::GAMMA Bad gsl_sf_gamma does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::GSLSF::GAMMA File GSLSF/GAMMA.pm Ref Gamma(x), x not a negative integer Sig double x(); double [o]y(); double [o]e()� ninterpol PDL::ImageND Module PDL::ImageND File ImageND.pm Ref N-dimensional interpolation routine Sig ninterpol(point(),data(n),[o]value()) Usage $value = ninterpol($point, $data);#histogram PDL::Primitive Bad histogram processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Usage $h = histogram($data, $step, $min, $numbins);
$hist = zeroes $numbins; # Put histogram in existing piddle.
histogram($data, $hist, $step, $min, $numbins); File Primitive.pm Ref Calculates a histogram for given stepsize and minimum. Sig in(n); int+[o] hist(m); double step; double min; int msize => m Example pdl> p histogram(pdl(1,1,2),1,0,3)
[0 2 1] Module PDL::Primitivemapfraw PDL::IO::FastRaw Module PDL::IO::FastRaw File IO/FastRaw.pm Ref Memory map a raw format binary file (see the module docs also) Opt The C<mapfraw> command
supports the following options (not all combinations make sense): Usage $pdl3 = mapfraw("fname2",{ReadOnly => 1});B gdImageGetTransparent PDL::IO::GD Module PDL::IO::GD File IO/GD.pm5 StringFT PDL::IO::GD Module PDL::IO::GD File IO/GD.pm�setbadtonan PDL::Bad Usage $y = $x->setbadtonan;
$x->inplace->setbadtonan; Bad This method processes input piddles with bad values. The output piddles will
not contain bad values (insofar as NaN is not Bad as far as PDL is concerned)
and the output piddle does not have its bad flag set. As an inplace
operation, it clears the bad flag. Module PDL::Bad File Bad.pm Ref Sets Bad values to NaN Sig a(); [o] b();z ridl PDL::IO::IDL Ref Read an IDL save file from a file.
File IO/IDL.pm Module PDL::IO::IDL Usage $x = ridl("foo.sav");
Ugsl_sf_bessel_Inu PDL::GSLSF::BESSEL Module PDL::GSLSF::BESSEL File GSLSF/BESSEL.pm Ref Modified Cylindrical Bessel Function I_nu(x). Sig double x(); double [o]y(); double [o]e(); double n Bad gsl_sf_bessel_Inu does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.}rCpolynomial PDL::Complex Module PDL::Complex Sig coeffs(n); x(c=2,m); [o]out(c=2,m) Ref evaluate the polynomial with (real) coefficients C<coeffs> at the (complex) position(s) C<x>. C<coeffs[0]> is the constant term. File Complex.pm Bad rCpolynomial does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.u PDL::GSL::DIFF PDL::GSL::DIFF Ref Module: PDL interface to numerical differentiation routines in GSL File GSL/DIFF.pmkhelp PDL::Doc::Perldl File Doc/Perldl.pm Ref print documentation about a PDL function or module or show a PDL manual Module PDL::Doc::Perldl Example pdl> help 'PDL::Tutorials' # show the guide to PDL tutorials
pdl> help 'PDL::Slices' # show the docs in the PDL::Slices module
pdl> help 'slice' # show docs on the 'slice' function Usage help 'func'D pdl2 pdl2 File pdl2.pod Ref Script: Simple shell (version 2) for PDLgsl_sf_lnfact PDL::GSLSF::GAMMA Module PDL::GSLSF::GAMMA Sig x(); double [o]y(); double [o]e() File GSLSF/GAMMA.pm Ref ln n! Bad gsl_sf_lnfact does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.�gsl_sf_bessel_I_scaled_array PDL::GSLSF::BESSEL Module PDL::GSLSF::BESSEL File GSLSF/BESSEL.pm Ref Array of Scaled Regular Modified Bessel Functions exp(-|x|) I_{s}(x) to exp(-|x|) I_{s+n-1}(x). Sig double x(); double [o]y(num); int s; int n=>num Bad gsl_sf_bessel_I_scaled_array does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.� ndims PDL::Core Module PDL::Core File Core.pm Ref Returns the number of dimensions in a piddle. Alias
for L<getndims|PDL::Core/getndims>.: AlphaBlending PDL::IO::GD File IO/GD.pm Module PDL::IO::GDCsinh PDL::Complex Module PDL::Complex File Complex.pm Ref sinh (a) = (exp (a) - exp (-a)) / 2. Works inplace Sig a(m=2); [o]c(m=2) Bad Csinh does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.� PDL::Fit::Linfit PDL::Fit::Linfit Ref Module: routines for fitting data with linear combinations of functions. File Fit/Linfit.pm�append PDL::Primitive Bad append does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. File Primitive.pm Ref append two piddles by concatenating along their first dimensions Sig a(n); b(m); [o] c(mn) Example $x = ones(2,4,7);
$y = sequence 5;
$c = $x->append($y); # size of $c is now (7,4,7) (a jumbo-piddle ;) Module PDL::Primitive� subs PDL::Lvalue File Lvalue.pm Ref test if routine is a known PDL lvalue sub Module PDL::Lvalue Example print "slice is an lvalue sub" if PDL::Lvalue->subs('slice'); pct PDL::Ufunc Module PDL::Ufunc Ref Return the specified percentile of all elements in a piddle. The
specified percentile (p) must be between 0.0 and 1.0. When the
specified percentile falls between data points, the result is
interpolated. File Ufunc.pm Usage $x = pct($data, $pct);7 BoundsSafe PDL::IO::GD File IO/GD.pm Module PDL::IO::GD5fsolver_meat PDL::GSL::MROOT Module PDL::GSL::MROOT Ref info not available File GSL/MROOT.pm Sig double xfree(n); double epsabs(); int method(); SV* function1 Bad fsolver_meat does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.,gsl_sf_taylorcoeff PDL::GSLSF::GAMMA Bad gsl_sf_taylorcoeff does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Sig double x(); double [o]y(); double [o]e(); int n File GSLSF/GAMMA.pm Ref x^n / n! Module PDL::GSLSF::GAMMAh PDL::GSL::RNG PDL::GSL::RNG File GSL/RNG.pm Ref Module: PDL interface to RNG and randist routines in GSL} write_png_best PDL::IO::GD File IO/GD.pm Module PDL::IO::GD Example write_png_best( $img(piddle), $lut(piddle), $filename )3diff_backward PDL::GSL::DIFF Bad diff_backward does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::GSL::DIFF File GSL/DIFF.pm Ref info not available Sig double x(); double [o] res(); double [o] abserr(); SV* function�conv2d PDL::Image2D Opt Boundary - controls what values are assumed for the image when kernel
crosses its edge:
=> Default - periodic boundary conditions
(i.e. wrap around axis)
=> Reflect - reflect at boundary
=> Truncate - truncate at boundary
=> Replicate - repeat boundary pixel values Usage $new = conv2d $old, $kernel, {OPTIONS} Module PDL::Image2D Example $smoothed = conv2d $image, ones(3,3), {Boundary => Reflect} File Image2D.pm Ref 2D convolution of an array with a kernel (smoothing) Bad Unlike the FFT routines, conv2d is able to process bad values. Sig a(m,n); kern(p,q); [o]b(m,n); int opt ran_binomial_var PDL::GSL::RNG File GSL/RNG.pm Ref Similar to L</ran_binomial> except that it takes the distribution
parameters as a piddle and returns a piddle of equal dimensions. Module PDL::GSL::RNG Usage $piddle = $rng->ran_binomial_var($p_piddle, $n_piddle);o pp_beginwrap PDL::PP Module PDL::PP File PP.pod Ref Add BEGIN-block wrapping to code for the generated .pm file� minimum_ind PDL::Ufunc Module PDL::Ufunc Ref Like minimum but returns the index rather than the value File Ufunc.pm Sig a(n); indx [o] c() Bad Output is set bad if all elements of the input are bad,
otherwise the bad flag is cleared for the output piddle.� points3d PDL::Graphics::TriD Usage points3d piddle(3), {OPTIONS}
points3d [piddle,...], {OPTIONS} Module PDL::Graphics::TriD Example Example: Ref 3D points plot, defined by a variety of contexts File Graphics/TriD.pm� ran_cauchy_var PDL::GSL::RNG Usage $piddle = $rng->ran_cauchy_var($a_piddle); Module PDL::GSL::RNG File GSL/RNG.pm Ref Similar to L</ran_cauchy> except that it takes the distribution
parameters as a piddle and returns a piddle of equal dimensions.� lu_decomp PDL::MatrixOps Sig a(m,m); [o]lu(m,m); [o]perm(m); [o]parity File MatrixOps.pm Ref LU decompose a matrix, with row permutation Module PDL::MatrixOps Usage ($lu, $perm, $parity) = lu_decomp($x);ywhistogram PDL::Primitive Bad whistogram processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Usage $h = whistogram($data, $weights, $step, $min, $numbins);
$hist = zeroes $numbins; # Put histogram in existing piddle.
whistogram($data, $weights, $hist, $step, $min, $numbins); Sig in(n); float+ wt(n);float+[o] hist(m); double step; double min; int msize => m Ref Calculates a histogram from weighted data for given stepsize and minimum. File Primitive.pm Example pdl> p whistogram(pdl(1,1,2), pdl(0.1,0.1,0.5), 1, 0, 4)
[0 0.2 0.5 0] Module PDL::PrimitiveN PDL::Index PDL::Index Ref Manual: an index of PDL documentation File Index.podsin PDL::Ops Bad sin processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Ref the sin function File Ops.pm Sig a(); [o]b() Module PDL::Ops Example $y = sin $x;
$x->inplace->sin; # modify $x inplacewmpeg PDL::IO::Pic Ref Write an image sequence (a (3,x,y,n) byte pdl) as an animation. File IO/Pic.pm Example $anim->wmpeg("GreatAnimation.mpg")
or die "can't create mpeg1 output"; Module PDL::IO::Pic Usage $piddle->wmpeg('movie.mpg'); # $piddle is (3,x,y,nframes) byteBgsl_sf_multiply PDL::GSLSF::ELEMENTARY Module PDL::GSLSF::ELEMENTARY Ref Multiplication. File GSLSF/ELEMENTARY.pm Sig double x(); double xx(); double [o]y(); double [o]e() Bad gsl_sf_multiply does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.} PDL::Func PDL::Func Ref Module: interpolation, integration, & gradient estimation (differentiation) of functions File Func.pm] gslinteg_qng PDL::GSL::INTEG File GSL/INTEG.pm Example Example: Module PDL::GSL::INTEG Usage � thread3 PDL::Core Usage $xx = $x->thread3(3,1) Example Wibble Module PDL::Core File Core.pm Ref Explicit threading over specified dims using thread id 3.�gsl_sf_synchrotron_1 PDL::GSLSF::SYNCHROTRON Bad gsl_sf_synchrotron_1 does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. File GSLSF/SYNCHROTRON.pm Ref First synchrotron function: synchrotron_1(x) = x Integral[ K_{5/3}(t), {t, x, Infinity}] Sig double x(); double [o]y(); double [o]e() Module PDL::GSLSF::SYNCHROTRON�gsl_sf_coulomb_CL_e PDL::GSLSF::COULOMB Bad gsl_sf_coulomb_CL_e does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Sig double L(); double eta(); double [o]y(); double [o]e() File GSLSF/COULOMB.pm Ref Coulomb wave function normalization constant. [Abramowitz+Stegun 14.1.8, 14.1.9]. Module PDL::GSLSF::COULOMB�gsl_sf_airy_Bi_deriv_scaled PDL::GSLSF::AIRY Sig double x(); double [o]y(); double [o]e() File GSLSF/AIRY.pm Ref Derivative Scaled Airy Function Bi(x). Bi`(x) for x < 0 and exp(+2/3 x^{3/2}) Bi`(x) for x > 0. Module PDL::GSLSF::AIRY Bad gsl_sf_airy_Bi_deriv_scaled does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.latan2 PDL::Ops Example $c = $x->atan2($y,0); # explicit function call
$c = atan2 $a, $b; # overloaded use
$x->inplace->atan2($y,0); # modify $x inplace Module PDL::Ops Sig a(); b(); [o]c(); int swap Ref elementwise C<atan2> of two piddles File Ops.pm Bad atan2 processes bad values.
The state of the bad-value flag of the output piddles is unknown.� fhdr PDL::Core Module PDL::Core Example $pdl->fhdr->{CDELT1} = 1; Ref Retrieve or set FITS header information from a piddle File Core.pmoadd_module PDL::Doc Usage use PDL::Doc; PDL::Doc::add_module("my::module"); Ref The C<add_module> function allows you to add POD from a particular Perl
module that you've installed somewhere in @INC. It searches for the
active PDL document database and the module's .pod and .pm files, and
scans and indexes the module into the database. File Doc.pm Module PDL::Doc uniq PDL::Primitive Ref return all unique elements of a piddle File Primitive.pm Module PDL::Primitive Example PDL> p pdl(2,2,2,4,0,-1,6,6)->uniq
[-1 0 2 4 6] # 0 is returned 2nd (sorted order) Bad Bad values are not considered unique by uniq and are ignored.� write_true_png PDL::IO::GD Bad write_true_png does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::IO::GD Sig img(x,y,z); char* filename File IO/GD.pm?xlogvals PDL::Basic Usage $w = zeroes(100,100);
$x = $w->xlogvals(1e-6,1e-3);
$y = $w->ylinvals(1e-4,1e3);
# calculate Z for X between 1e-6 and 1e-3 and
# Y between 1e-4 and 1e3.
$z = f($x,$y); Ref X axis values logarithmically spaced between endpoints (see L</xvals>). File Basic.pm Module PDL::Basic6 SaveAlpha PDL::IO::GD File IO/GD.pm Module PDL::IO::GD� attributes PDL::Func Example PDL::Func->attributes;
Flags Attribute
SGR x
SGR y
G err Module PDL::Func Ref Print out the flags for the attributes of a PDL::Func object. File Func.pm Usage $obj->attributes;
PDL::Func->attributes;; SetAntiAliased PDL::IO::GD File IO/GD.pm Module PDL::IO::GDYcheck_badflag PDL::Bad Bad This method accepts piddles with or without bad values. It
returns a Perl scalar with the final bad-value flag, so it
never returns bad values itself. Ref Clear the bad-value flag of a piddle if it does not
contain any bad values File Bad.pm Example print "State of bad flag == ", $pdl->check_badflag; Module PDL::Bad� lut_data PDL::Graphics::LUT Usage my ( $l, $r, $g, $b ) = lut_data( $table, [ $reverse, [ $ramp ] ] ); File Graphics/LUT.pm Ref Load in the requested colour table and intensity ramp. Module PDL::Graphics::LUT&ran_negative_binomial_var PDL::GSL::RNG Usage $piddle = $rng->ran_negative_binomial_var($p_piddle, $n_piddle); Module PDL::GSL::RNG Ref Similar to L</ran_negative_binomial> except that it takes the distribution
parameters as a piddle and returns a piddle of equal dimensions. File GSL/RNG.pmD mones PDL::Matrix File Matrix.pm Module PDL::Matrix Crossref mzeroes� Ctanh PDL::Complex Bad Ctanh does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::Complex Ref Works inplace File Complex.pm Sig a(m=2); [o]c(m=2)2chid PDL::Slatec Module PDL::Slatec Sig x(n);f(n);d(n);int check();int ia();int ib();[o]ans();int [o]ierr() File Slatec.pm Ref Integrate (x,f(x)) between data points. Bad chid does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.Tgsl_sf_bessel_Jnu PDL::GSLSF::BESSEL Bad gsl_sf_bessel_Jnu does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. File GSLSF/BESSEL.pm Ref Regular Cylindrical Bessel Function J_nu(x). Sig double x(); double [o]y(); double [o]e(); double n Module PDL::GSLSF::BESSELd PDL::GSLSF::PSI PDL::GSLSF::PSI Ref Module: PDL interface to GSL Special Functions File GSLSF/PSI.pmd PDL::GSLSF::ERF PDL::GSLSF::ERF Ref Module: PDL interface to GSL Special Functions File GSLSF/ERF.pmland2 PDL::Ops Bad and2 processes bad values.
The state of the bad-value flag of the output piddles is unknown. Module PDL::Ops Example $c = and2 $x, $y, 0; # explicit call with trailing 0
$c = $x & $y; # overloaded call
$x->inplace->and2($y,0); # modify $x inplace Ref binary I<and> of two piddles File Ops.pm Sig a(); b(); [o]c(); int swap�ran_pascal PDL::GSL::RNG File GSL/RNG.pm Ref Fills output piddle with random integer values from the Pascal distribution.
The Pascal distribution is simply a negative binomial distribution
(see L</ran_negative_binomial>) with an integer value of C<$n>. Module PDL::GSL::RNG Usage $piddle = $rng->ran_pascal($p,$n,[list of integers = output piddle dims]);
$rng->ran_pascal($p,$n,$output_piddle);4 Polygon PDL::IO::GD File IO/GD.pm Module PDL::IO::GDran_gamma_var PDL::GSL::RNG Module PDL::GSL::RNG Ref Similar to L</ran_gamma> except that it takes the distribution
parameters as a piddle and returns a piddle of equal dimensions. File GSL/RNG.pm Usage $piddle = $rng->ran_gamma_var($a_piddle, $b_piddle); bessj1 PDL::Math Module PDL::Math Sig a(); [o]b() Ref The regular Bessel function of the first kind, J_n Works inplace. File Math.pm Bad bessj1 processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.� wim PDL::IO::Pic Module PDL::IO::Pic File IO/Pic.pm Ref Write a pdl to an image file with selected type (or using filename extensions) Usage wim $pdl,$file;
$pdl->wim("foo.gif",{LUT=>$lut});� isnull PDL::Core Usage croak("Input piddle mustn't be null!")
if $input_piddle->isnull; File Core.pm Ref Test whether a piddle is null Module PDL::Core8 gdImageChar PDL::IO::GD File IO/GD.pm Module PDL::IO::GD/chim PDL::Slatec File Slatec.pm Ref Calculate the derivatives of (x,f(x)) using cubic Hermite interpolation. Sig x(n);f(n);[o]d(n);int [o]ierr() Module PDL::Slatec Bad chim does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.B gdImageFilledEllipses PDL::IO::GD Module PDL::IO::GD File IO/GD.pm�lmfit PDL::Fit::LM Opt Maxiter: maximum number of iterations before giving up
Eps: convergence criterion for fit; success when normalized change
in chisquare smaller than Eps File Fit/LM.pm Ref Levenberg-Marquardt fitting of a user supplied model function Example ($ym,$finalp,$covar,$iters) =
lmfit $x, $y, $sigma, \&expfunc, $initp, {Maxiter => 300, Eps => 1e-3}; Module PDL::Fit::LM� ran_additive_poisson PDL::GSL::RNG Usage $rng->ran_additive_poisson($mu,$piddle); Ref Add Poisson noise of given C<$mu> to a C<$piddle>. File GSL/RNG.pm Example $rng->ran_additive_poisson(1,$image); Module PDL::GSL::RNG�gsl_sf_ellint_E PDL::GSLSF::ELLINT Bad gsl_sf_ellint_E does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::GSLSF::ELLINT Sig double phi(); double k(); double [o]y(); double [o]e() File GSLSF/ELLINT.pm Ref Legendre form of incomplete elliptic integrals E(phi,k) = Integral[ Sqrt[1 - k^2 Sin[t]^2], {t, 0, phi}]1threadI PDL::Slices Sig P(); C(); int id; SV *list Ref internal File Slices.pm Example $y = $x->threadI(0,1,5); # thread over dims 1,5 in id 1 Module PDL::Slices Bad threadI does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.~ipow PDL::Ops Bad ipow does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Ref raise piddle C<$a> to integer power C<$b> File Ops.pm Sig a(); b(); [o] ans() Example $c = $x->ipow($y,0); # explicit function call
$c = ipow $x, $y;
$x->inplace->ipow($y,0); # modify $x inplace Module PDL::Ops|ran_discrete PDL::GSL::RNG Usage $piddle = $rng->ran_discrete($discrete_dist_handle,$num); File GSL/RNG.pm Ref Is used to get the desired samples once a proper handle has been
enstablished (see ran_discrete_preproc()). Example $prob = pdl [0.1,0.3,0.6];
$ddh = $rng->ran_discrete_preproc($prob);
$o = $rng->ran_discrete($discrete_dist_handle,100); Module PDL::GSL::RNG gsl_sf_lndoublefact PDL::GSLSF::GAMMA Ref ln n!! File GSLSF/GAMMA.pm Sig x(); double [o]y(); double [o]e() Module PDL::GSLSF::GAMMA Bad gsl_sf_lndoublefact does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.. double PDL::Core Module PDL::Core File Core.pm ran_rayleigh_tail_var PDL::GSL::RNG Module PDL::GSL::RNG File GSL/RNG.pm Ref Similar to L</ran_rayleigh_tail> except that it takes the distribution
parameters as a piddle and returns a piddle of equal dimensions. Usage $piddle = $rng->ran_rayleigh_tail_var($a_piddle, $sigma_piddle);�badinfo PDL::Doc::Perldl Module PDL::Doc::Perldl Example pdl> badinfo 'inner'
Bad value support for inner (in module PDL::Primitive)
If "a() * b()" contains only bad data, "c()" is set bad. Otherwise "c()"
will have its bad flag cleared, as it will not contain any bad values. File Doc/Perldl.pm Ref provides information on the bad-value support of a function Usage badinfo 'func'gwhere PDL::Primitive Usage $i = $x->where($x+5 > 0); # $i contains those elements of $x
# where mask ($x+5 > 0) is 1
$i .= -5; # Set those elements (of $x) to -5. Together, these
# commands clamp $x to a maximum of -5. Module PDL::Primitive File Primitive.pm Ref Use a mask to select values from one or more data PDLs� PDL::Perldl2::Profile::Perldl2 PDL::Perldl2::Profile::Perldl2 Ref Module: profile for Perldl2 shell File Perldl2/Profile/Perldl2.pm/ SX PDL::IO::GD Module PDL::IO::GD File IO/GD.pm7gsl_sf_log PDL::GSLSF::LOG Sig double x(); double [o]y(); double [o]e() Ref Provide a logarithm function with GSL semantics. File GSLSF/LOG.pm Module PDL::GSLSF::LOG Bad gsl_sf_log does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.9 PDL PDL Ref Module: the Perl Data Language File ../PDL.pm� max PDL::Ufunc Module PDL::Ufunc Ref Return the maximum of all elements in a piddle. File Ufunc.pm Usage $x = max($data); Bad This routine handles bad values.� max PDL::GSL::RNG Usage $integer = $rng->max(); Example $min = $rng->min(); $max = $rng->max(); Module PDL::GSL::RNG Ref Return the maximum value generable by the RNG. File GSL/RNG.pm-whereND PDL::Primitive Usage $sdata = whereND $data, $mask
($s1, $s2, ..., $sn) = whereND $d1, $d2, ..., $dn, $mask Ref C<where> with support for ND masks and threading File Primitive.pm Example $data = sequence(4,3,2); # example data array
$mask4 = (random(4)>0.5); # example 1-D mask array, has $n4 true values
$mask43 = (random(4,3)>0.5); # example 2-D mask array, has $n43 true values
$sdat4 = whereND $data, $mask4; # $sdat4 is a [$n4,3,2] pdl
$sdat43 = whereND $data, $mask43; # $sdat43 is a [$n43,2] pdl Module PDL::Primitivevgsl_sf_bessel_kl_scaled PDL::GSLSF::BESSEL Sig double x(); double [o]y(); double [o]e(); int n File GSLSF/BESSEL.pm Ref Scaled IrRegular Modified Spherical Bessel Function exp(-|x|) k_n(x). Module PDL::GSLSF::BESSEL Bad gsl_sf_bessel_kl_scaled does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.l pp_addbegin PDL::PP File PP.pod Ref Sets code to be added at the top of the generate .pm file Module PDL::PPUsvd PDL::MatrixOps Sig a(n,m); [o]u(n,m); [o,phys]z(n); [o]v(n,n) File MatrixOps.pm Ref Singular value decomposition of a matrix. Module PDL::MatrixOps Bad svd ignores the bad-value flag of the input piddles.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Usage ($u, $s, $v) = svd($x);U minover_ind PDL::Ufunc Module PDL::Ufunc Ref Synonym for minimum_ind. File Ufunc.pmVgsl_sf_bessel_Ynu PDL::GSLSF::BESSEL Module PDL::GSLSF::BESSEL Sig double x(); double [o]y(); double [o]e(); double n Ref IrRegular Cylindrical Bessel Function J_nu(x). File GSLSF/BESSEL.pm Bad gsl_sf_bessel_Ynu does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.� ifft PDL::FFT Usage ifft($real,$imag); Module PDL::FFT Sig [o,nc]real(n); [o,nc]imag(n) Ref Complex inverse 1-D FFT of the "real" and "imag" arrays [inplace]. A single
cfloat/cdouble input piddle can also be used. File FFT.pmS PDL::IO::FITS PDL::IO::FITS File IO/FITS.pm Ref Module: Simple FITS support for PDLexp PDL::Ops Bad exp processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::Ops Example $y = exp $x;
$x->inplace->exp; # modify $x inplace Sig a(); [o]b() Ref the exponential function File Ops.pm� PDL::Perldl2::Plugin::PDLCommands PDL::Perldl2::Plugin::PDLCommands File Perldl2/Plugin/PDLCommands.pm Ref Module: implement perldl aliases/escapesNgsl_sf_expint_Ei PDL::GSLSF::EXPINT Bad gsl_sf_expint_Ei does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Ref Ei(x) := PV Integrate[ Exp[-t]/t, {t,-x,Infinity}] File GSLSF/EXPINT.pm Sig double x(); double [o]y(); double [o]e() Module PDL::GSLSF::EXPINT� ran_tdist_var PDL::GSL::RNG Usage $piddle = $rng->ran_tdist_var($nu_piddle); File GSL/RNG.pm Ref Similar to L</ran_tdist> except that it takes the distribution
parameters as a piddle and returns a piddle of equal dimensions. Module PDL::GSL::RNGp matinv PDL::Slatec Usage ($inv) = matinv($mat) Module PDL::Slatec File Slatec.pm Ref Inverse of a square matrixDgsl_sf_bessel_Yn PDL::GSLSF::BESSEL Bad gsl_sf_bessel_Yn does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Ref IrRegular Bessel Function Y_n(x). File GSLSF/BESSEL.pm Sig double x(); double [o]y(); double [o]e(); int n Module PDL::GSLSF::BESSEL< gdImageString16 PDL::IO::GD File IO/GD.pm Module PDL::IO::GD� ran_choose_vec PDL::GSL::RNG Module PDL::GSL::RNG File GSL/RNG.pm Ref Chooses C<$n> values from C<@vec>. Usage @chosen = $rng->ran_choose_vec($n,@vec);linfit1d PDL::Fit::Linfit Usage ($yfit, [$coeffs]) = linfit1d [$xdata], $data, $fitFuncs, [Options...] Opt Options:
Weights Weights to use in fit, e.g. 1/$sigma**2 (default=1) Module PDL::Fit::Linfit Example # Generate data from a set of functions
$xvalues = sequence(100);
$data = 3*$xvalues + 2*cos($xvalues) + 3*sin($xvalues*2); File Fit/Linfit.pm Ref 1D Fit linear combination of supplied functions to data using min chi^2 (least squares). Sig xdata(n); ydata(n); $fitFuncs(n,order); [o]yfit(n); [o]coeffs(order)<cumusumover PDL::Ufunc Bad cumusumover processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Usage $y = cumusumover($x); Sig a(n); int+ [o]b(n) Ref Cumulative sum File Ufunc.pm Module PDL::Ufunc Example $spectrum = cumusumover $image->xchg(0,1)� t_offset PDL::Transform Ref Convenience interface to L</t_linear>. File Transform.pm Module PDL::Transform Usage $f = t_offset(<shift>)> ColorClosestAlpha PDL::IO::GD Module PDL::IO::GD File IO/GD.pminner2 PDL::Primitive Bad inner2 processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::Primitive Sig a(n); b(n,m); c(m); [o]d() Ref Inner product of two vectors and a matrix File Primitive.pm5 SetStyle PDL::IO::GD File IO/GD.pm Module PDL::IO::GD�setstr PDL::Char Usage $char = PDL::Char->new( [['abc', 'def', 'ghi'], ['jkl', 'mno', 'pqr']] );
$char->setstr(0,1, 'foobar');
print $char; # 'string' bound to "", perl stringify function
# Prints:
# [
# ['abc' 'def' 'ghi']
# ['foo' 'mno' 'pqr']
# ]
$char->setstr(2,1, 'f');
print $char; # 'string' bound to "", perl stringify function
# Prints:
# [
# ['abc' 'def' 'ghi']
# ['foo' 'mno' 'f'] -> note that this 'f' is stored "f\0\0"
# ] Module PDL::Char Ref Function to set one string value in a character PDL. The input position is
the position of the string, not a character in the string. The first dimension
is assumed to be the length of the string. File Char.pm� earth_coast PDL::Transform::Cartography Ref (Cartography) PDL constructor - coastline map of Earth File Transform/Cartography.pm Module PDL::Transform::Cartography Usage $x = earth_coast()� indadd PDL::Primitive Module PDL::Primitive Example Simple Example: Ref Threaded Index Add: Add C<a> to the C<ind> element of C<sum>, i.e: File Primitive.pm Sig a(); indx ind(); [o] sum(m) Bad The routine barfs if any of the indices are bad.� imagrgb PDL::Graphics::TriD Example e.g. Module PDL::Graphics::TriD File Graphics/TriD.pm Ref 2D RGB image plot (see also imag2d) Usage imagrgb piddle(3,x,y), {OPTIONS}
imagrgb [piddle,...], {OPTIONS}2 Green PDL::IO::GD File IO/GD.pm Module PDL::IO::GDI Ctan PDL::Complex Module PDL::Complex Ref Complex tangent File Complex.pm6 StringTTF PDL::IO::GD File IO/GD.pm Module PDL::IO::GD� using PDL::Slices Usage line $pdl->using(1,2); Module PDL::Slices Example pdl> $pdl = rcols("file");
pdl> line $pdl->using(1,2); Ref Returns array of column numbers requested File Slices.pma PDL::CallExt PDL::CallExt File CallExt.pm Ref Module: call functions in external shared libraries1 Blue PDL::IO::GD Module PDL::IO::GD File IO/GD.pmeone2nd PDL::Primitive Module PDL::Primitive Example pdl> $x=pdl [[[1,2],[-1,1]], [[0,-3],[3,2]]]; $c=$x->clump(-1)
pdl> $maxind=maximum_ind($c); p $maxind;
6
pdl> print one2nd($x, maximum_ind($c))
0 1 1
pdl> p $x->at(0,1,1)
3 Ref Converts a one dimensional index piddle to a set of ND coordinates File Primitive.pm Usage @coords=one2nd($x, $indices)ran_logarithmic PDL::GSL::RNG Ref Fills output piddle with random integer values from the logarithmic distribution. File GSL/RNG.pm Module PDL::GSL::RNG Usage $piddle = $rng->ran_logarithmic($p,[list of integers = output piddle dims]);
$rng->ran_logarithmic($p,$output_piddle);= gdImageRectangle PDL::IO::GD Module PDL::IO::GD File IO/GD.pmCsin PDL::Complex Bad Csin does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::Complex Sig a(m=2); [o]c(m=2) File Complex.pm Ref sin (a) = 1/(2*i) * (exp (a*i) - exp (-a*i)). Works inplaceGmedover PDL::Ufunc Sig a(n); [o]b(); [t]tmp(n) File Ufunc.pm Ref Project via median to N-1 dimensions Module PDL::Ufunc Example $spectrum = medover $image->xchg(0,1) Bad medover processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Usage $y = medover($x);s PDL::GSLSF::LEGENDRE PDL::GSLSF::LEGENDRE Ref Module: PDL interface to GSL Special Functions File GSLSF/LEGENDRE.pm< gdImageSetStyle PDL::IO::GD File IO/GD.pm Module PDL::IO::GD�histogram2d PDL::Primitive Usage $h = histogram2d($datax, $datay, $stepx, $minx,
$nbinx, $stepy, $miny, $nbiny);
$hist = zeroes $nbinx, $nbiny; # Put histogram in existing piddle.
histogram2d($datax, $datay, $hist, $stepx, $minx,
$nbinx, $stepy, $miny, $nbiny); Bad histogram2d processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Example pdl> p histogram2d(pdl(1,1,1,2,2),pdl(2,1,1,1,1),1,0,3,1,0,3)
[
[0 0 0]
[0 2 2]
[0 1 0]
] Module PDL::Primitive Sig (ina(n); inb(n); int+[o] hist(ma,mb); double stepa; double mina; int masize => ma;
double stepb; double minb; int mbsize => mb;) Ref Calculates a 2d histogram. File Primitive.pm` PDL::Fit::LM PDL::Fit::LM Ref Module: Levenberg-Marquardt fitting routine for PDL File Fit/LM.pm�yvals PDL::Basic Example pdl> print yvals zeroes(5,10)
[
[0 0 0 0 0]
[1 1 1 1 1]
[2 2 2 2 2]
[3 3 3 3 3]
[4 4 4 4 4]
[5 5 5 5 5]
[6 6 6 6 6]
[7 7 7 7 7]
[8 8 8 8 8]
[9 9 9 9 9]
] Module PDL::Basic Ref Fills a piddle with Y index values. See the CAVEAT for L</xvals>. File Basic.pm Usage $x = yvals($somearray); yvals(inplace($somearray));
$x = yvals([OPTIONAL TYPE],$nx,$ny,$nz...);�gsl_sf_ellint_F PDL::GSLSF::ELLINT Bad gsl_sf_ellint_F does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Ref Legendre form of incomplete elliptic integrals F(phi,k) = Integral[1/Sqrt[1 - k^2 Sin[t]^2], {t, 0, phi}] File GSLSF/ELLINT.pm Sig double phi(); double k(); double [o]y(); double [o]e() Module PDL::GSLSF::ELLINTsgsl_sf_bessel_K_array PDL::GSLSF::BESSEL Module PDL::GSLSF::BESSEL Ref Array of IrRegular Modified Bessel Functions K_{s}(x) to K_{s+n-1}(x). File GSLSF/BESSEL.pm Sig double x(); double [o]y(num); int s; int n=>num Bad gsl_sf_bessel_K_array does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.c lattice3d PDL::Graphics::TriD Module PDL::Graphics::TriD Ref alias for mesh3d File Graphics/TriD.pm� freeze PDL::IO::Storable Ref freeze a piddle using L<Storable> File IO/Storable.pm Module PDL::IO::Storable Example $x = random 12,10;
$frozen = $x->freeze;j PDL::GSLSF::DEBYE PDL::GSLSF::DEBYE File GSLSF/DEBYE.pm Ref Module: PDL interface to GSL Special Functions� creal PDL::Ops Module PDL::Ops File Ops.pm Ref Returns the real part of a complex number. Sig a(); [o]b() Bad creal processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.�rot2d PDL::Image2D Sig im(m,n); float angle(); bg(); int aa(); [o] om(p,q) File Image2D.pm Ref rotate an image by given C<angle> Example # rotate by 10.5 degrees with antialiasing, set missing values to 7
$rot = $im->rot2d(10.5,7,1); Module PDL::Image2D Bad rot2d ignores the bad-value flag of the input piddles.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.B gdImageColorAllocates PDL::IO::GD File IO/GD.pm Module PDL::IO::GDapprox PDL::Core Usage $res = approx $x, $y [, $eps] File Core.pm Ref test for approximately equal values (relaxed C<==>) Example # ok if all corresponding values in
# piddles are within 1e-8 of each other
print "ok\n" if all approx $x, $y, 1e-8; Module PDL::Coreu datatypes_header PDL::Types Module PDL::Types Ref return C header text for F<pdl.h> and F<pdlsimple.h>. File Types.pmjgsl_sf_legendre_H3d_array PDL::GSLSF::LEGENDRE Bad gsl_sf_legendre_H3d_array does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Sig double [o]y(num); int l=>num; double lambda; double eta File GSLSF/LEGENDRE.pm Ref Array of H3d(ell), for l from 0 to n-1. Module PDL::GSLSF::LEGENDRE� max2d_ind PDL::Image2D Bad Bad values are excluded from the search. If all pixels
are bad then the output is set bad. File Image2D.pm Ref Return value/position of maximum value in 2D image Sig a(m,n); [o]val(); int [o]x(); int[o]y() Module PDL::Image2D0 longlong PDL::Core Module PDL::Core File Core.pmran_gumbel2 PDL::GSL::RNG Usage $piddle = $rng->ran_gumbel2($pa,$pb,[list of integers = output piddle dims]);
$rng->ran_gumbel2($pa,$pb,$output_piddle); File GSL/RNG.pm Ref Fills output piddle with random variates from the Type-2 Gumbel distribution. Module PDL::GSL::RNG� generate_core_flags PDL::Core::Dev Module PDL::Core::Dev File Core/Dev.pm Ref prints on C<STDOUT> XS text with core flags, for F<Core.xs>. mn_init PDL::Minuit File Minuit.pm Ref The function mn_init() does the basic initialization of the fit. The first argument
has to be a reference to the function to be minimized. The function
to be minimized has to receive five arguments
($npar,$grad,$fval,$xval,$iflag). The first is the number
of parameters currently variable. The second is the gradient
of the function (which is not necessarily used, see
the Minuit documentation). The third is the current value of the
function. The fourth is a piddle with the values of the parameters.
The fifth is an integer flag, which indicates what
the function is supposed to calculate. The function has to
return the values ($fval,$grad), the function value and
the function gradient. Example Example: Module PDL::Minuit Usage � gslinteg_qagp PDL::GSL::INTEG Usage Module PDL::GSL::INTEG Example Example: File GSL/INTEG.pm Ref Please check the GSL documentation for more information.Pgsl_sf_poch PDL::GSLSF::GAMMA Module PDL::GSLSF::GAMMA File GSLSF/GAMMA.pm Ref Pochammer (Apell) symbol (a)_x := Gamma[a + x]/Gamma[x] Sig double x(); double [o]y(); double [o]e(); double a Bad gsl_sf_poch does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.� ezfftb PDL::Slatec Ref File Slatec.pm Sig [o]r(n);azero();a(n);b(n);wsave(foo) Module PDL::Slatec Bad ezfftb does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.E gdImageColorClosestAlpha PDL::IO::GD File IO/GD.pm Module PDL::IO::GDX PDL::Primitive PDL::Primitive File Primitive.pm Ref Module: primitive operations for pdl'inner2t PDL::Primitive Bad inner2t processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::Primitive File Primitive.pm Ref Efficient Triple matrix product C<a*b*c> Sig a(j,n); b(n,m); c(m,k); [t]tmp(n,k); [o]d(j,k))� nslice PDL::Core Module PDL::Core File Core.pm Ref C<nslice> was an internally used interface for L<PDL::NiceSlice>,
but is now merely a springboard to L<PDL::Slices>. It is deprecated
and likely to disappear in PDL 3.0. Cconj PDL::Complex Bad Cconj does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::Complex File Complex.pm Ref complex conjugation. Works inplace Sig a(m=2); [o]c(m=2)< ColorExactAlpha PDL::IO::GD Module PDL::IO::GD File IO/GD.pm; gdImageCompare PDL::IO::GD File IO/GD.pm Module PDL::IO::GDU PDL::Philosophy PDL::Philosophy File Philosophy.pod Ref Manual: Why did we write PDL?5 String16 PDL::IO::GD File IO/GD.pm Module PDL::IO::GD� list PDL::Core Usage @tmp = list $x; Bad list converts any bad values into the string 'BAD'. Module PDL::Core Example for (list $x) {
# Do something on each value...
} File Core.pm Ref Convert piddle to perl list3 String PDL::IO::GD File IO/GD.pm Module PDL::IO::GDuzvals PDL::Basic Usage $x = zvals($somearray); zvals(inplace($somearray));
$x = zvals([OPTIONAL TYPE],$nx,$ny,$nz...); Ref Fills a piddle with Z index values. See the CAVEAT for L</xvals>. File Basic.pm Module PDL::Basic Example pdl> print zvals zeroes(3,4,2)
[
[
[0 0 0]
[0 0 0]
[0 0 0]
[0 0 0]
]
[
[1 1 1]
[1 1 1]
[1 1 1]
[1 1 1]
]
]� axisvals PDL::Basic Usage $z = axisvals ($piddle, $nth); Module PDL::Basic File Basic.pm Ref Fills a piddle with index values on Nth dimension� qsort PDL::Ufunc Bad Bad values are moved to the end of the array: Module PDL::Ufunc Example print qsort random(10); Sig a(n); [o]b(n) File Ufunc.pm Ref Quicksort a vector into ascending order.wtstat PDL::Primitive Bad Bad values are ignored in any calculation; C<$b> will only
have its bad flag set if the output contains any bad data. Sig a(n); wt(n); avg(); [o]b(); int deg File Primitive.pm Ref Weighted statistical moment of given degree Module PDL::Primitivedetslatec PDL::Slatec Example $mat = zeroes(5,5); $mat->diagonal(0,1) .= 1; # unity matrix
$det = detslatec $mat; Module PDL::Slatec Sig detslatec(mat(n,m); [o] det()) Ref compute the determinant of an invertible matrix File Slatec.pm Usage $determinant = detslatec $matrix;� contour_segments PDL::Graphics::TriD::Rout File Graphics/TriD/Rout.pm Ref This is the interface for the pp routine contour_segments_internal
- it takes 3 piddles as input Module PDL::Graphics::TriD::Rout�gsl_sf_lnpoch PDL::GSLSF::GAMMA Sig double x(); double [o]y(); double [o]s(); double [o]e(); double a File GSLSF/GAMMA.pm Ref Logarithm of Pochammer (Apell) symbol, with sign information. result = log( |(a)_x| ), sgn = sgn( (a)_x ) where (a)_x := Gamma[a + x]/Gamma[a] Module PDL::GSLSF::GAMMA Bad gsl_sf_lnpoch does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.ran_lognormal_var PDL::GSL::RNG Module PDL::GSL::RNG File GSL/RNG.pm Ref Similar to L</ran_lognormal> except that it takes the distribution
parameters as a piddle and returns a piddle of equal dimensions. Usage $piddle = $rng->ran_lognormal_var($mu_piddle, $sigma_piddle);� rfits PDL::IO::FITS File IO/FITS.pm Ref Simple piddle FITS reader. Example $pdl = rfits('file.fits'); # Read a simple FITS image Module PDL::IO::FITS� Catanh PDL::Complex Bad Catanh does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Ref Works inplace File Complex.pm Sig a(m=2); [o]c(m=2) Module PDL::Complex� t_sinusoidal PDL::Transform::Cartography Usage $t = t_sinusoidal(<options>); File Transform/Cartography.pm Ref (Cartography) Sinusoidal projection (authalic) Module PDL::Transform::Cartography chfe PDL::Slatec Bad chfe does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::Slatec Sig x(n);f(n);d(n);int check();xe(ne);[o]fe(ne);int [o]ierr() Ref Interpolate function values. File Slatec.pmq rdcm PDL::IO::Dicom Module PDL::IO::Dicom Ref Read a dicom image. File IO/Dicom.pm Usage $dcm = rdcm("filename"))conv1d PDL::Primitive Sig a(m); kern(p); [o]b(m); int reflect Ref 1D convolution along first dimension File Primitive.pm Example $con = conv1d sequence(10), pdl(-1,0,1); Module PDL::Primitive Bad WARNING: C<conv1d> processes bad values in its inputs as
the numeric value of C<< $pdl->badvalue >> so it is not
recommended for processing pdls with bad values in them
unless special care is taken.conv1d ignores the bad-value flag of the input piddles.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.� PDL::IO::Dumper::find_PDLs PDL::IO::Dumper File IO/Dumper.pm Ref Walk a data structure and dump PDLs [Internal routine] Module PDL::IO::Dumper� print_by_default PDL::Perldl2::Plugin::PrintControl Module PDL::Perldl2::Plugin::PrintControl File Perldl2/Plugin/PrintControl.pmyngoodover PDL::Bad Bad ngoodover processes input values that are bad. The output piddle will not have
any bad values, but the bad flag will be set if the input piddle had its bad
flag set. Usage $x = ngoodover($y); Sig a(n); indx [o] b() Ref Find the number of good elements along the 1st dimension. File Bad.pm Module PDL::Bad Example $spectrum = ngoodover $image->xchg(0,1) norm PDL::Primitive Module PDL::Primitive Ref Normalises a vector to unit Euclidean length File Primitive.pm Sig vec(n); [o] norm(n) Bad norm processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.8 DashedLines PDL::IO::GD Module PDL::IO::GD File IO/GD.pm sqrt PDL::Ops Ref elementwise square root File Ops.pm Sig a(); [o]b() Example $y = sqrt $x;
$x->inplace->sqrt; # modify $x inplace Module PDL::Ops Bad sqrt processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.k PDL::Tips PDL::Tips File Tips.pod Ref Manual: Small tidbits of useful arcana. Programming tidbits and such.Fprodover PDL::Ufunc Usage $y = prodover($x); Bad prodover processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Example $spectrum = prodover $image->xchg(0,1) Module PDL::Ufunc File Ufunc.pm Ref Project via product to N-1 dimensions Sig a(n); int+ [o]b()< gdImageSetBrush PDL::IO::GD File IO/GD.pm Module PDL::IO::GD� t_mercator PDL::Transform::Cartography Ref (Cartography) Mercator projection (cylindrical; conformal) File Transform/Cartography.pm Module PDL::Transform::Cartography Usage $t = t_mercator(<options>);m PDL::GSLSF::ELLINT PDL::GSLSF::ELLINT Ref Module: PDL interface to GSL Special Functions File GSLSF/ELLINT.pm3gsl_sf_legendre_Ql PDL::GSLSF::LEGENDRE Bad gsl_sf_legendre_Ql does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. File GSLSF/LEGENDRE.pm Ref Q_l(x) Sig double x(); double [o]y(); double [o]e(); int l Module PDL::GSLSF::LEGENDRE� t_caree PDL::Transform::Cartography Usage $t = t_caree(<options>); Ref (Cartography) Plate Caree projection (cylindrical; equidistant) File Transform/Cartography.pm Module PDL::Transform::Cartographytgsl_sf_airy_Bi_scaled PDL::GSLSF::AIRY Module PDL::GSLSF::AIRY Ref Scaled Airy Function Bi(x). Bi(x) for x < 0 and exp(+2/3 x^{3/2}) Bi(x) for x > 0. File GSLSF/AIRY.pm Sig double x(); double [o]y(); double [o]e() Bad gsl_sf_airy_Bi_scaled does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.1 Char PDL::IO::GD Module PDL::IO::GD File IO/GD.pm� t_albers PDL::Transform::Cartography Module PDL::Transform::Cartography Ref (Cartography) Albers conic projection (conic; authalic) File Transform/Cartography.pm Usage $t = t_albers(<options>)�wcols PDL::IO::Misc Example $x = random(4); $y = ones(4);
wcols $x, $y+2, 'foo.dat';
wcols $x, $y+2, *STDERR;
wcols $x, $y+2, '|wc'; Module PDL::IO::Misc File IO/Misc.pm Ref Write ASCII columns into file from 1D or 2D piddles and/or 1D listrefs efficiently. Usage wcols $data1, $data2, $data3,..., *HANDLE|"outfile", [\%options]; # or
wcols $format_string, $data1, $data2, $data3,..., *HANDLE|"outfile", [\%options];[gsl_sf_hzeta PDL::GSLSF::ZETA Bad gsl_sf_hzeta does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. File GSLSF/ZETA.pm Ref Hurwicz Zeta Function zeta(s,q) = Sum[ (k+q)^(-s), {k,0,Infinity} ] Sig double s(); double [o]y(); double [o]e(); double q Module PDL::GSLSF::ZETA� atanh PDL::Math Sig a(); [o]b() File Math.pm Module PDL::Math Bad atanh processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.Nwhistogram2d PDL::Primitive Sig (ina(n); inb(n); float+ wt(n);float+[o] hist(ma,mb); double stepa; double mina; int masize => ma;
double stepb; double minb; int mbsize => mb;) File Primitive.pm Ref Calculates a 2d histogram from weighted data. Module PDL::Primitive Example pdl> p whistogram2d(pdl(1,1,1,2,2),pdl(2,1,1,1,1),pdl(0.1,0.2,0.3,0.4,0.5),1,0,3,1,0,3)
[
[ 0 0 0]
[ 0 0.5 0.9]
[ 0 0.1 0]
] Bad whistogram2d processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Usage $h = whistogram2d($datax, $datay, $weights,
$stepx, $minx, $nbinx, $stepy, $miny, $nbiny);
$hist = zeroes $nbinx, $nbiny; # Put histogram in existing piddle.
whistogram2d($datax, $datay, $weights, $hist,
$stepx, $minx, $nbinx, $stepy, $miny, $nbiny);Tqsortvec PDL::Ufunc Example print qsortvec pdl([[1,2],[0,500],[2,3],[4,2],[3,4],[3,5]]);
[
[ 0 500]
[ 1 2]
[ 2 3]
[ 3 4]
[ 3 5]
[ 4 2]
] Module PDL::Ufunc Sig a(n,m); [o]b(n,m) File Ufunc.pm Ref Sort a list of vectors lexicographically. Bad Vectors with bad components should be moved to the end of the array:� routine PDL::Func Usage my $name = $obj->routine; Module PDL::Func File Func.pm Ref Returns the name of the last routine called by a PDL::Func object.� sdump PDL::IO::Dumper Module PDL::IO::Dumper File IO/Dumper.pm Ref Dump a data structure to a string. Usage use PDL::IO::Dumper;
$s = sdump(<VAR>);
...
<VAR> = eval $s;_gsl_sf_laguerre_n PDL::GSLSF::LAGUERRE Bad gsl_sf_laguerre_n does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. File GSLSF/LAGUERRE.pm Ref Evaluate generalized Laguerre polynomials. Sig double x(); double [o]y(); double [o]e(); int n; double a Module PDL::GSLSF::LAGUERRE� geco PDL::Slatec Bad geco does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. File Slatec.pm Sig a(n,n);int [o]ipvt(n);[o]rcond();[o]z(n) Module PDL::Slatec� gslinteg_qawf PDL::GSL::INTEG Usage Example Example: Module PDL::GSL::INTEG File GSL/INTEG.pm Ref Please check the GSL documentation for more information.�qagp_meat PDL::GSL::INTEG Bad qagp_meat does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::GSL::INTEG Sig (double pts(l); double epsabs();double epsrel();int limit();
double [o] result(); double [o] abserr();int n();int [o] ierr();int gslwarn();; SV* function) Ref info not available File GSL/INTEG.pm? gdImageCopyResized PDL::IO::GD Module PDL::IO::GD File IO/GD.pm stats PDL::Primitive Ref Calculates useful statistics on a piddle File Primitive.pm Module PDL::Primitive Bad Bad values are handled; if all input values are bad, then all of the output
values are flagged bad. Usage ($mean,$prms,$median,$min,$max,$adev,$rms) = stats($piddle,[$weights]);9 ColorClosest PDL::IO::GD File IO/GD.pm Module PDL::IO::GD� t_compose PDL::Transform Module PDL::Transform File Transform.pm Ref Function composition: f(g(x)), f(g(h(x))), ... Usage $f2 = t_compose($f, $g,[...]);
$f2 = $f->compose($g[,$h,$i,...]);
$f2 = $f x $g x ...;�gsl_sf_gamma_inc_P PDL::GSLSF::GAMMA Module PDL::GSLSF::GAMMA Sig double x(); double [o]y(); double [o]e(); double a File GSLSF/GAMMA.pm Ref Complementary Normalized Incomplete Gamma Function P(a,x) = 1/Gamma(a) Integral[ t^(a-1) e^(-t), {t,0,x} ] Bad gsl_sf_gamma_inc_P does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.!vsearch_bin_exclusive PDL::Primitive Ref Determine the index for values in a sorted array of bins, lower bound exclusive. File Primitive.pm Sig vals(); x(n); indx [o]idx() Module PDL::Primitive Bad needs major (?) work to handles bad values Usage $idx = vsearch_bin_exclusive($vals, $x);� mesh3d PDL::Graphics::TriD Ref 3D mesh plot, defined by a variety of contexts File Graphics/TriD.pm Example Example: Module PDL::Graphics::TriD Usage mesh3d piddle(3,x,y), {OPTIONS}
mesh3d [piddle,...], {OPTIONS}� deriv PDL::GSL::INTERP Usage Module PDL::GSL::INTERP Example Example: File GSL/INTERP.pm Ref The deriv function returns the derivative of the
interpolating function at a given point.
It will barf with an "input domain error" if you try to extrapolate.? re PDL::Complex Names re,im Module PDL::Complex File Complex.pm� sclr PDL::Core File Core.pm Ref return a single value from a piddle as a scalar Module PDL::Core Example $val = $x(10)->sclr;
$val = sclr inner($x,$y);P PDL::Types PDL::Types Ref Module: define fundamental PDL Datatypes File Types.pmCpow PDL::Complex Bad Cpow does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Sig a(m=2); b(m=2); [o]c(m=2) File Complex.pm Ref complex C<pow()> (C<**>-operator) Module PDL::Complexran_gumbel2_var PDL::GSL::RNG Usage $piddle = $rng->ran_gumbel2_var($a_piddle, $b_piddle); Module PDL::GSL::RNG File GSL/RNG.pm Ref Similar to L</ran_gumbel2> except that it takes the distribution
parameters as a piddle and returns a piddle of equal dimensions. ran_logistic_var PDL::GSL::RNG Module PDL::GSL::RNG File GSL/RNG.pm Ref Similar to L</ran_logistic> except that it takes the distribution
parameters as a piddle and returns a piddle of equal dimensions. Usage $piddle = $rng->ran_logistic_var($m_piddle);� lu_decomp2 PDL::MatrixOps Usage ($lu, $perm, $parity) = lu_decomp2($x); Module PDL::MatrixOps Ref LU decompose a matrix, with no row permutation File MatrixOps.pm Sig a(m,m); [o]lu(m,m)� PDL::Graphics::TriD::ButtonControl PDL::Graphics::TriD::ButtonControl Ref Module: default event handler subroutines File Graphics/TriD/ButtonControl.pmB gdImageSetAntiAliased PDL::IO::GD File IO/GD.pm Module PDL::IO::GD,chia PDL::Slatec Ref Integrate (x,f(x)) over arbitrary limits. File Slatec.pm Sig x(n);f(n);d(n);int check();la();lb();[o]ans();int [o]ierr() Module PDL::Slatec Bad chia does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.simplex PDL::Opt::Simplex Module PDL::Opt::Simplex Ref Simplex optimization routine File Opt/Simplex.pm Usage ($optimum,$ssize,$optval) = simplex($init,$initsize,$minsize,
$maxiter,
sub {evaluate_func_at($_[0])},
sub {display_simplex($_[0])}
);� writefraw PDL::IO::FastRaw Opt The C<writefraw> command
supports the following option: Usage writefraw($pdl,"fname");
writefraw($pdl,"fname", {Header => 'headerfname'}); Module PDL::IO::FastRaw Ref Write a raw format binary file File IO/FastRaw.pmg PDL::GSLSF::TRIG PDL::GSLSF::TRIG Ref Module: PDL interface to GSL Special Functions File GSLSF/TRIG.pm� sever PDL::Core Ref sever any links of this piddle to parent piddles File Core.pm Module PDL::Core Example $x = $pdl->index(pdl(0,3,7))->sever;
$x++; # important: $pdl is not modified! log10 PDL::Ops Bad log10 processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::Ops Example $y = log10 $x;
$x->inplace->log10; # modify $x inplace Ref the base 10 logarithm File Ops.pm Sig a(); [o]b()� typefld PDL::Types Example pdl> print PDL::Types::typefld('PDL_IND',realctype)
long Module PDL::Types Ref Returns specified field (C<$fld>) for specified type (C<$type>)
by querying type hash File Types.pm Usage PDL::Types::typefld($type,$fld);Bgsl_sf_expint_3 PDL::GSLSF::EXPINT Ref Ei_3(x) := Integral[ Exp[-t^3], {t,0,x}] File GSLSF/EXPINT.pm Sig double x(); double [o]y(); double [o]e() Module PDL::GSLSF::EXPINT Bad gsl_sf_expint_3 does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.� integ PDL::GSL::INTERP File GSL/INTERP.pm Ref The integ function returns the integral
of the interpolating function between two points.
It will barf with an "input domain error" if you try to extrapolate. Module PDL::GSL::INTERP Example Example: Usage s PDL::GSLSF::COUPLING PDL::GSLSF::COUPLING File GSLSF/COUPLING.pm Ref Module: PDL interface to GSL Special FunctionsNgsl_sf_bessel_yl PDL::GSLSF::BESSEL Module PDL::GSLSF::BESSEL Sig double x(); double [o]y(); double [o]e(); int n Ref IrRegular Spherical Bessel Function y_n(x). File GSLSF/BESSEL.pm Bad gsl_sf_bessel_yl does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.� addlabels PDL::Graphics::TriD::Contours Usage $contour->addlabels($labelint,$segint,$font); Module PDL::Graphics::TriD::Contours File Graphics/TriD/Contours.pm Ref Add labels to a contour plot ran_bernoulli_var PDL::GSL::RNG Usage $piddle = $rng->ran_bernoulli_var($p_piddle); Module PDL::GSL::RNG Ref Similar to L</ran_bernoulli> except that it takes the distribution
parameters as a piddle and returns a piddle of equal dimensions. File GSL/RNG.pm� PDL::Doc::Perldl::finddoc PDL::Doc::Perldl Module PDL::Doc::Perldl Ref Internal interface to the PDL documentation searcher File Doc/Perldl.pmEgsl_sf_lnbeta PDL::GSLSF::GAMMA Module PDL::GSLSF::GAMMA File GSLSF/GAMMA.pm Ref Logarithm of Beta Function Log[B(a,b)] Sig double a(); double b(); double [o]y(); double [o]e() Bad gsl_sf_lnbeta does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.� line3d PDL::Graphics::TriD Usage line3d piddle(3,x), {OPTIONS}
line3d [CONTEXT], {OPTIONS} File Graphics/TriD.pm Ref 3D line plot, defined by a variety of contexts. Example Example: Module PDL::Graphics::TriD� PDL::IO::Dumper::dump_PDL PDL::IO::Dumper Module PDL::IO::Dumper File IO/Dumper.pm Ref Generate 1- or 2-part expr for a PDL [Internal routine]KdiagonalI PDL::Slices Example $y = $x->diagonal(0,2,5); Module PDL::Slices File Slices.pm Ref Returns the multidimensional diagonal over the specified dimensions. Sig P(); C(); SV *list Bad diagonalI does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.Hgsl_sf_erf PDL::GSLSF::ERF Module PDL::GSLSF::ERF Sig double x(); double [o]y(); double [o]e() Ref Error Function erf(x) := 2/Sqrt[Pi] Integrate[Exp[-t^2], {t,0,x}] File GSLSF/ERF.pm Bad gsl_sf_erf does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.> ColorResolveAlpha PDL::IO::GD File IO/GD.pm Module PDL::IO::GDgsl_sf_choose PDL::GSLSF::GAMMA Module PDL::GSLSF::GAMMA Ref n choose m File GSLSF/GAMMA.pm Sig n(); m(); double [o]y(); double [o]e() Bad gsl_sf_choose does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.0 Red PDL::IO::GD File IO/GD.pm Module PDL::IO::GD7 write_WBMP PDL::IO::GD Module PDL::IO::GD File IO/GD.pm�gsl_sf_hyperg_2F1_conj_renorm PDL::GSLSF::HYPERG Ref Renormalized Gauss hypergeometric function 2F1[aR + I aI, aR - I aI, c, x] / Gamma[c] File GSLSF/HYPERG.pm Sig double x(); double [o]y(); double [o]e(); double a; double b; double c Module PDL::GSLSF::HYPERG Bad gsl_sf_hyperg_2F1_conj_renorm does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.dat PDL::Core Example pdl> $x = sequence 3,4
pdl> p $x->at(1,2)
7 Module PDL::Core File Core.pm Ref Returns a single value inside a piddle as perl scalar.
If the piddle is a native complex value (cdouble, cfloat), it will
be stringified. Usage $z = at($piddle, @position); $z=$piddle->at(@position); Bad at converts any bad values into the string 'BAD'.aran_binomial PDL::GSL::RNG Usage $piddle = $rng->ran_binomial($p,$n,[list of integers = output piddle dims]);
$rng->ran_binomial($p,$n,$output_piddle); File GSL/RNG.pm Ref Fills output piddle with random integer values from the binomial distribution, the number of
successes in C<$n> independent trials with probability C<$p>. Module PDL::GSL::RNGe PDL::Tutorials PDL::Tutorials File Tutorials.pod Ref Manual: A guide to PDL's tutorial documentation.9 gdImageAlpha PDL::IO::GD File IO/GD.pm Module PDL::IO::GD� usage PDL::Doc::Perldl Usage usage 'func' Module PDL::Doc::Perldl Example pdl> usage 'inner' File Doc/Perldl.pm Ref Prints usage information for a PDL function{gsl_sf_pochrel PDL::GSLSF::GAMMA Bad gsl_sf_pochrel does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::GSLSF::GAMMA Sig double x(); double [o]y(); double [o]e(); double a File GSLSF/GAMMA.pm Ref Relative Pochammer (Apell) symbol ((a,x) - 1)/x where (a,x) = (a)_x := Gamma[a + x]/Gamma[a]\splitdim PDL::Slices Bad splitdim does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::Slices Example $y = $x->splitdim(2,3); Sig P(); C(); int nthdim; int nsp Ref Splits a dimension in the parent piddle (opposite of L<clump|PDL::Core/clump>) File Slices.pminterpND PDL::Primitive Module PDL::Primitive Example $source = 10*xvals(10,10) + yvals(10,10);
$index = pdl([[2.2,3.5],[4.1,5.0]],[[6.0,7.4],[8,9]]);
print $source->interpND( $index ); File Primitive.pm Ref Interpolate values from an N-D piddle, with switchable method� determinant PDL::MatrixOps Usage $det = determinant($x); Module PDL::MatrixOps Sig a(m,m) Ref Determinant of a square matrix, using recursive descent (threadable). File MatrixOps.pm� fft PDL::FFT Usage fft($real,$imag); Module PDL::FFT Ref Complex 1-D FFT of the "real" and "imag" arrays [inplace]. A single
cfloat/cdouble input piddle can also be used. File FFT.pm Sig [o,nc]real(n); [o,nc]imag(n)� fft PDL::Slatec Example $v_in = pdl(1,0,1,0);
($azero,$x,$y) = PDL::Slatec::fft($v_in); Module PDL::Slatec Ref Fast Fourier Transform File Slatec.pm`intover PDL::Ufunc Module PDL::Ufunc Example $spectrum = intover $image->xchg(0,1) Ref Project via integral to N-1 dimensions File Ufunc.pm Sig a(n); float+ [o]b() Usage $y = intover($x); Bad intover ignores the bad-value flag of the input piddles.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.] PDL::ImageND PDL::ImageND Ref Module: useful image processing in N dimensions File ImageND.pm� lgamma PDL::Math Bad lgamma processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Sig a(); [o]b(); int[o]s() File Math.pm Ref log gamma function Module PDL::Mathrgsl_sf_polar_to_rect PDL::GSLSF::TRIG Bad gsl_sf_polar_to_rect does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Sig double r(); double t(); double [o]x(); double [o]y(); double [o]xe(); double [o]ye() File GSLSF/TRIG.pm Ref Convert polar to rectlinear coordinates. Module PDL::GSLSF::TRIGXmodeover PDL::Ufunc Bad modeover does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Usage $y = modeover($x); Sig data(n); [o]out(); [t]sorted(n) Ref Project via mode to N-1 dimensions File Ufunc.pm Module PDL::Ufunc Example $spectrum = modeover $image->xchg(0,1)b PDL::Filter::Linear PDL::Filter::Linear Ref Module: linear filtering for PDL File Filter/Linear.pmM maxover PDL::Ufunc Ref Synonym for maximum. File Ufunc.pm Module PDL::Ufunc� t_scale PDL::Transform Ref Convenience interface to L</t_linear>. File Transform.pm Module PDL::Transform Usage $f = t_scale(<scale>)A gdImageFilledPolygon PDL::IO::GD Module PDL::IO::GD File IO/GD.pm�ran_gaussian PDL::GSL::RNG Ref Fills output piddle with random values from Gaussian distribution with mean zero and standard deviation C<$sigma>. File GSL/RNG.pm Example $o = $rng->ran_gaussian($sigma,10,10);
$rng->ran_gaussian($sigma,$o); Module PDL::GSL::RNG Usage $piddle = $rng->ran_gaussian($sigma,[list of integers = output piddle dims]);
$rng->ran_gaussian($sigma, $output_piddle);� invert PDL::Transform Usage $out = $t->invert($data);
$out = $data->invert($t); Ref Apply an inverse transformation to some input coordinates. File Transform.pm Sig data(); PDL::Transform t Module PDL::Transform� ran_beta_var PDL::GSL::RNG Usage $piddle = $rng->ran_beta_var($a_piddle, $b_piddle); Module PDL::GSL::RNG File GSL/RNG.pm Ref Similar to L</ran_beta> except that it takes the distribution
parameters as a piddle and returns a piddle of equal dimensions.nlt PDL::Ops File Ops.pm Ref the binary E<lt> (less than) operation Sig a(); b(); [o]c(); int swap Module PDL::Ops Example $c = lt $x, $y, 0; # explicit call with trailing 0
$c = $x < $y; # overloaded call
$x->inplace->lt($y,0); # modify $x inplace Bad lt processes bad values.
The state of the bad-value flag of the output piddles is unknown.� flat PDL::Core File Core.pm Ref flatten a piddle (alias for C<< $pdl->clump(-1) >>) Example $srt = $pdl->flat->qsort; Module PDL::Core� lu_backsub PDL::MatrixOps Usage ($lu,$perm,$par) = lu_decomp($x); Sig lu(m,m); perm(m); b(m) Ref Solve a x = b for matrix a, by back substitution into a's LU decomposition. File MatrixOps.pm Module PDL::MatrixOps� lut_ramps PDL::Graphics::LUT Usage @ramps = lut_ramps(); Module PDL::Graphics::LUT File Graphics/LUT.pm Ref Return, as a list, the names of the available intensity ramps.� XResizeWindow PDL::Graphics::OpenGL::Perl::OpenGL Usage XResizeWindow(x,y) Module PDL::Graphics::OpenGL::Perl::OpenGL File Graphics/OpenGL/Perl/OpenGL.pmD vones PDL::Matrix File Matrix.pm Module PDL::Matrix Crossref vzeroes/gsl_sf_lncosh PDL::GSLSF::TRIG Ref Log(Cos(x)) with GSL semantics. File GSLSF/TRIG.pm Sig double x(); double [o]y(); double [o]e() Module PDL::GSLSF::TRIG Bad gsl_sf_lncosh does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.� isempty PDL::Core Module PDL::Core Ref Test whether a piddle is empty File Core.pm Usage print "The piddle has zero dimension\n" if $pdl->isempty;� rim PDL::IO::Pic Usage $x = rim($file);
or rim($x,$file); File IO/Pic.pm Ref Read images in most formats, with improved RGB handling. Module PDL::IO::Pic�rasc PDL::IO::Misc Usage $pdl->rasc("filename"|FILEHANDLE [,$noElements]); File IO/Misc.pm Ref Simple function to slurp in ASCII numbers quite quickly,
although error handling is marginal (to nonexistent). Module PDL::IO::Misc Example # (test.num is an ascii file with 20 numbers. One number per line.)
$in = PDL->null;
$num = 20;
$in->rasc('test.num',20);
$imm = zeroes(float,20,2);
$imm->rasc('test.num');U maxover_ind PDL::Ufunc Ref Synonym for maximum_ind. File Ufunc.pm Module PDL::UfuncO PDL::Reduce PDL::Reduce Ref Module: a C<reduce> function for PDL File Reduce.pm�which_both PDL::Primitive Example pdl> $x = sequence(10); p $x
[0 1 2 3 4 5 6 7 8 9]
pdl> ($small, $big) = which_both ($x >= 5); p "$small\n $big"
[5 6 7 8 9]
[0 1 2 3 4] Module PDL::Primitive Sig mask(n); indx [o] inds(m); indx [o]notinds(q) Ref Returns indices of zero and nonzero values in a mask PDL File Primitive.pm Usage ($i, $c_i) = which_both($mask); Bad which_both processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.; gdImageGetClip PDL::IO::GD Module PDL::IO::GD File IO/GD.pmgconvolveND PDL::ImageND Sig k0(); SV *k; SV *aa; SV *a Ref Speed-optimized convolution with selectable boundary conditions File ImageND.pm Module PDL::ImageND Bad convolveND does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Usage $new = convolveND($x, $kernel, [ {options} ]);� PDL::Graphics::TriD::Contours PDL::Graphics::TriD::Contours File Graphics/TriD/Contours.pm Ref Module: 3D Surface contours for TriDzgsl_sf_conicalP_half PDL::GSLSF::LEGENDRE Bad gsl_sf_conicalP_half does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::GSLSF::LEGENDRE Sig double x(); double [o]y(); double [o]e(); double lambda Ref Irregular Spherical Conical Function P^{1/2}_{-1/2 + I lambda}(x) File GSLSF/LEGENDRE.pm� sum PDL::Ufunc Module PDL::Ufunc File Ufunc.pm Ref Return the sum of all elements in a piddle. Usage $x = sum($data); Bad This routine handles bad values.� nbad PDL::Bad Usage $x = nbad($data); Bad Accepts good and bad input piddles; output is a Perl scalar
and therefore is always good. Module PDL::Bad File Bad.pm Ref Returns the number of bad values in a piddle/gsl_sf_transport_5 PDL::GSLSF::TRANSPORT Ref J(5,x) File GSLSF/TRANSPORT.pm Sig double x(); double [o]y(); double [o]e() Module PDL::GSLSF::TRANSPORT Bad gsl_sf_transport_5 does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.� hcpy PDL::Core Example $x = rfits('foo.fits')->hcpy(0);
$x = rfits('foo.fits')->hcpy(1); Module PDL::Core Ref Switch on/off automatic header copying, with PDL pass-through File Core.pmUgsl_sf_bessel_Knu PDL::GSLSF::BESSEL File GSLSF/BESSEL.pm Ref Modified Cylindrical Bessel Function K_nu(x). Sig double x(); double [o]y(); double [o]e(); double n Module PDL::GSLSF::BESSEL Bad gsl_sf_bessel_Knu does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.�Datatype_conversions PDL::Core Usage $y = double $x; $y = ushort [1..10];
# all of the above listed shorthands behave similarly Module PDL::Core Example pdl> p $x=sqrt float [1..10]
[1 1.41421 1.73205 2 2.23607 2.44949 2.64575 2.82843 3 3.16228]
pdl> p byte $x
[1 1 1 2 2 2 2 2 3 3] Ref byte|short|ushort|long|indx|longlong|float|double|cfloat|cdouble (shorthands to convert datatypes) File Core.pmdgsl_sf_fermi_dirac_int PDL::GSLSF::FERMI_DIRAC Bad gsl_sf_fermi_dirac_int does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. File GSLSF/FERMI_DIRAC.pm Ref Complete integral F_j(x) for integer j Sig double x(); double [o]y(); double [o]e(); int j Module PDL::GSLSF::FERMI_DIRAC< gdImageSetPixel PDL::IO::GD File IO/GD.pm Module PDL::IO::GD� twiddle3d PDL::Graphics::TriD Module PDL::Graphics::TriD File Graphics/TriD.pm Ref Wait for the user to rotate the image in 3D space.y write_true_png_best PDL::IO::GD Module PDL::IO::GD Example write_true_png_best( $img(piddle), $filename ) File IO/GD.pmtnbadover PDL::Bad Usage $x = nbadover($y); Bad nbadover processes input values that are bad. The output piddle will not have
any bad values, but the bad flag will be set if the input piddle had its bad
flag set. Example $spectrum = nbadover $image->xchg(0,1) Module PDL::Bad Sig a(n); indx [o] b() File Bad.pm Ref Find the number of bad elements along the 1st dimension.qsorti PDL::Ufunc Module PDL::Ufunc Example $ix = qsorti $x;
print $x->index($ix); # Sorted list Ref Quicksort a vector and return index of elements in ascending order. File Ufunc.pm Sig a(n); indx [o]indx(n) Bad Bad elements are moved to the end of the array:/gsl_sf_transport_4 PDL::GSLSF::TRANSPORT Sig double x(); double [o]y(); double [o]e() File GSLSF/TRANSPORT.pm Ref J(4,x) Module PDL::GSLSF::TRANSPORT Bad gsl_sf_transport_4 does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.� cc8compt PDL::Image2D Example $segmented = cc8compt( $image > $threshold ); Module PDL::Image2D Ref Connected 8-component labeling of a binary image. File Image2D.pm� TIEARRAY PDL::DiskCache Module PDL::DiskCache Ref Tied-array constructor; invoked by perl during object construction. File DiskCache.pm Usage TIEARRAY(class,\@f,\%options)d Inline::Pdlpp Inline::Pdlpp Ref Manual: Write PDL Subroutines inline with PDL::PP File PP-Inline.pod� poco PDL::Slatec Bad poco does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::Slatec Sig a(n,n);rcond();[o]z(n);int [o]info() File Slatec.pmr PDL::Fit::Polynomial PDL::Fit::Polynomial Ref Module: routines for fitting with polynomials File Fit/Polynomial.pmgmodulo PDL::Ops Bad modulo processes bad values.
The state of the bad-value flag of the output piddles is unknown. Module PDL::Ops Example $c = $x->modulo($y,0); # explicit function call
$c = $a % $b; # overloaded use
$x->inplace->modulo($y,0); # modify $x inplace File Ops.pm Ref elementwise C<modulo> operation Sig a(); b(); [o]c(); int swap� ran_laplace_var PDL::GSL::RNG Usage $piddle = $rng->ran_laplace_var($a_piddle); File GSL/RNG.pm Ref Similar to L</ran_laplace> except that it takes the distribution
parameters as a piddle and returns a piddle of equal dimensions. Module PDL::GSL::RNGW PDL::PP PDL::PP File PP.pod Ref Manual: Generate PDL routines from concise descriptions� intersect PDL::Primitive Usage $set = intersect($x, $y); Module PDL::Primitive Example Find all numbers less that 100 that are of the form 2*y and 3*x Ref Calculate the intersection of two piddles File Primitive.pmK PDL::IO::IDL PDL::IO::IDL Ref Module: I/O of IDL Save Files
File IO/IDL.pmimag2d_update PDL::Graphics2D Usage $image = random(3,64,48)/2 + 0.25; # random pixel image
$win = imag2d($image); # create original image display File Graphics2D.pm Ref Update an existing imag2d window with new piddle data Module PDL::Graphics2DM minover PDL::Ufunc Module PDL::Ufunc Ref Synonym for minimum. File Ufunc.pm3gsl_sf_eta PDL::GSLSF::ZETA Bad gsl_sf_eta does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Ref Eta Function eta(s) = (1-2^(1-s)) zeta(s) File GSLSF/ZETA.pm Sig double x(); double [o]y(); double [o]e() Module PDL::GSLSF::ZETAk PDL::Graphics2D PDL::Graphics2D File Graphics2D.pm Ref Module: An object oriented interface to PDL graphics innerwt PDL::Primitive Sig a(n); b(n); c(n); [o]d() Ref Weighted (i.e. triple) inner product File Primitive.pm Module PDL::Primitive Bad innerwt processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.� rpiccan PDL::IO::Pic File IO/Pic.pm Ref Test which image formats can be read/written Example $im = PDL->rpic('PDL.jpg') if PDL->rpiccan('JPEG');
@wformats = PDL->wpiccan(); Module PDL::IO::Pic Names rpiccan,wpiccan�gsl_sf_lngamma_complex PDL::GSLSF::GAMMA Bad gsl_sf_lngamma_complex does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Ref Log[Gamma(z)] for z complex, z not a negative integer. Calculates: lnr = log|Gamma(z)|, arg = arg(Gamma(z)) in (-Pi, Pi] File GSLSF/GAMMA.pm Sig double zr(); double zi(); double [o]x(); double [o]y(); double [o]xe(); double [o]ye() Module PDL::GSLSF::GAMMA�dice PDL::Slices Module PDL::Slices Example pdl> $x = sequence(10,4)
pdl> p $x
[
[ 0 1 2 3 4 5 6 7 8 9]
[10 11 12 13 14 15 16 17 18 19]
[20 21 22 23 24 25 26 27 28 29]
[30 31 32 33 34 35 36 37 38 39]
]
pdl> p $x->dice([1,2],[0,3]) # Select columns 1,2 and rows 0,3
[
[ 1 2]
[31 32]
]
pdl> p $x->dice(X,[0,3])
[
[ 0 1 2 3 4 5 6 7 8 9]
[30 31 32 33 34 35 36 37 38 39]
]
pdl> p $x->dice([0,2,5])
[
[ 0 2 5]
[10 12 15]
[20 22 25]
[30 32 35]
] File Slices.pm Ref Dice rows/columns/planes out of a PDL using indexes for
each dimension. Usage $slice = $data->dice([0,2,6],[2,1,6]); # Dicing a 2-D array@ gdImageFillToBorder PDL::IO::GD File IO/GD.pm Module PDL::IO::GD�gsl_sf_hyperg_0F1 PDL::GSLSF::HYPERG Module PDL::GSLSF::HYPERG File GSLSF/HYPERG.pm Ref /* Hypergeometric function related to Bessel functions 0F1[c,x] = Gamma[c] x^(1/2(1-c)) I_{c-1}(2 Sqrt[x]) Gamma[c] (-x)^(1/2(1-c)) J_{c-1}(2 Sqrt[-x]) Sig double x(); double [o]y(); double [o]e(); double c Bad gsl_sf_hyperg_0F1 does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.� maptextfraw PDL::IO::FastRaw Ref Memory map a text file (see the module docs also). File IO/FastRaw.pm Module PDL::IO::FastRaw Opt The options other than Dims, Datatype of C<mapfraw> are
supported. Usage $pdl4 = maptextfraw("fname", {options}inner2d PDL::Primitive Bad inner2d processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::Primitive Sig a(n,m); b(n,m); [o]c() Ref Inner product over 2 dimensions. File Primitive.pm� ran_choose PDL::GSL::RNG Module PDL::GSL::RNG Ref Chooses values from C<$inpiddle> to C<$outpiddle>. File GSL/RNG.pm Usage $rng->ran_choose($inpiddle,$outpiddle);� nullcreate PDL::Core Module PDL::Core Example PDL::Derived->nullcreate(10)
returns PDL::Derived->null.
PDL->nullcreate($pdlderived)
returns $pdlderived->null. Ref Returns a 'null' piddle. File Core.pm Usage $x = PDL->nullcreate($arg)� imag2d PDL::Graphics2D Ref Display a 2-D image in a figure window File Graphics2D.pm Module PDL::Graphics2D Example use PDL::Graphics2D; # imports imag2d() and twiddle() Usage $window_id = imag2d($image, $name, $zoom, $x_off, $y_off);� mode PDL::Ufunc Module PDL::Ufunc File Ufunc.pm Ref Return the mode of all elements in a piddle. Usage $x = mode($data); Bad This routine handles bad values.� null PDL::Core File Core.pm Ref Returns a 'null' piddle. Example pdl> sumover sequence(10,10), $ans=null;p $ans
[45 145 245 345 445 545 645 745 845 945] Module PDL::Core Usage $x = null;n upd_data PDL::Core Module PDL::Core File Core.pm Ref Update the data pointer in a piddle to match its perl SV.Z PDL::Graphics::TriD PDL::Graphics::TriD File Graphics/TriD.pm Ref Module: PDL 3D interface� ximtool PDL::Graphics::IIS Usage ximtool[(command line options)] Ref Starts the Ximtool external program File Graphics/IIS.pm Example pdl> ximtool
pdl> ximtool (-maxColors => 64) Module PDL::Graphics::IIS=svdc PDL::Slatec Bad svdc does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Module PDL::Slatec Sig x(n,p);[o]s(p);[o]e(p);[o]u(n,p);[o]v(p,p);[o]work(n);int job();int [o]info() Ref singular value decomposition of a matrix File Slatec.pmF PDL::IO::Pic PDL::IO::Pic Ref Module: image I/O for PDL File IO/Pic.pmO PDL::FAQ PDL::FAQ File FAQ.pod Ref Manual: Frequently asked questions about PDL�polyfillv PDL::Image2D Example # increment intensity in area bounded by $poly using the pnpoly algorithm
$im->polyfillv($poly,{'Method'=>'pnpoly'})++; # legal in perl >= 5.6 Module PDL::Image2D File Image2D.pm Ref return the (dataflown) area of an image described by a polygon Usage polyfillv($im,$ps,[\%options]); Opt Method - Set the method used to determine which points lie in the polygon.
=> Default - internal PDL algorithm
=> pnpoly - use the L</pnpoly> algorithm5 WARNING: PDL::IO::GD Module PDL::IO::GD File IO/GD.pmH msequence PDL::Matrix Crossref mzeroes Module PDL::Matrix File Matrix.pm� PDL::Char PDL::Char Ref Module: PDL subclass which allows reading and writing of fixed-length character strings as byte PDLs File Char.pmVpolfit PDL::Slatec Bad polfit processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Sig x(n); y(n); w(n); int maxdeg(); int [o]ndeg(); [o]eps(); [o]r(n); int [o]ierr(); [o]a(foo); [o]coeffs(bar);[t]xtmp(n);[t]ytmp(n);[t]wtmp(n);[t]rtmp(n) File Slatec.pm Module PDL::Slatec.vsearch_insert_rightmost PDL::Primitive Bad needs major (?) work to handles bad values Usage $idx = vsearch_insert_rightmost($vals, $x); Ref Determine the insertion point for values in a sorted array, inserting after duplicates. File Primitive.pm Sig vals(); x(n); indx [o]idx() Module PDL::Primitive6 SetPixels PDL::IO::GD Module PDL::IO::GD File IO/GD.pmD read_png PDL::IO::GD Module PDL::IO::GD File IO/GD.pm Sig $filename k PDL::Objects PDL::Objects File Objects.pod Ref Manual: Object-Orientation, what is it and how to exploit itO PDL::Basic PDL::Basic File Basic.pm Ref Module: Basic utility functions for PDLA gdImageCopyResampled PDL::IO::GD Module PDL::IO::GD File IO/GD.pm� get_datatype PDL::Core Usage $x = $piddle->get_datatype; Module PDL::Core File Core.pm Ref Internal: Return the numeric value identifying the piddle datatype6 FilledArc PDL::IO::GD File IO/GD.pm Module PDL::IO::GD� sliceb PDL::Slices Bad sliceb does not process bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. File Slices.pm Ref info not available Sig P(); C(); SV *args Module PDL::Slices� t_projective PDL::Transform File Transform.pm Ref Projective transformation Module PDL::Transform Usage $t = t_projective(<options>);nran_rayleigh_tail PDL::GSL::RNG Module PDL::GSL::RNG Ref Fills output piddle with random variates from the tail of the Rayleigh distribution
with scale parameter C<$sigma> and a lower limit of C<$la>. File GSL/RNG.pm Usage $piddle = $rng->ran_rayleigh_tail($la,$sigma,[list of integers = output piddle dims]);
$rng->ran_rayleigh_tail($x,$sigma,$output_piddle);I PDL::Lite PDL::Lite File Lite.pm Ref Module: minimum PDL module OO loader� t_code PDL::Transform Module PDL::Transform File Transform.pm Ref Transform implementing arbitrary perl code. Usage $f = t_code(<func>,[<inv>],[options]);w pp_deprecate_module PDL::PP Module PDL::PP Ref Add runtime and POD warnings about a module being deprecated File PP.pod>sumover PDL::Ufunc Bad sumover processes bad values.
It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles. Usage $y = sumover($x); Ref Project via sum to N-1 dimensions File Ufunc.pm Sig a(n); int+ [o]b() Example $spectrum = sumover $image->xchg(0,1) Module PDL::Ufunc; GetTransparent PDL::IO::GD Module PDL::IO::GD File IO/GD.pm9 gdImageLines PDL::IO::GD File IO/GD.pm Module PDL::IO::GDpisgood PDL::Bad Bad This method works with input piddles that are bad. The output piddle
will never contain bad values, but its bad value flag will be the
same as the input piddle's flag. Ref Is a value good? File Bad.pm Sig a(); int [o]b() Module PDL::Bad Example $x = pdl(1,2,3);
$x->badflag(1);
set($x,1,$x->badvalue);
$y = isgood($x);
print $y, "\n";
[1 0 1]L PDL::Matrix::pdl PDL::Matrix Crossref mpdl File Matrix.pm Module PDL::Matrix: FilledEllipse PDL::IO::GD File IO/GD.pm Module PDL::IO::GD