NAME
PDL::Types  define fundamental PDL Datatypes
SYNOPSIS
use PDL::Types;
$pdl = ushort( 2.0, 3.0 );
print "The actual c type used to store ushort's is '" .
$pdl>type>realctype() . "'\n";
The actual c type used to store ushort's is 'unsigned short'
DESCRIPTION
Internal module  holds all the PDL Type info. The type info can be accessed easily using the PDL::Type
object returned by the type method as shown in the synopsis.
Skip to the end of this document to find out how to change the set of types supported by PDL.
FUNCTIONS
A number of functions are available for module writers to get/process type information. These are used in various places (e.g. PDL::PP
, PDL::Core
) to generate the appropriate type loops, etc.
typesrtkeys
Returns an array of keys of typehash sorted in order of type complexity
pdl> @typelist = PDL::Types::typesrtkeys;
pdl> print @typelist;
PDL_SB PDL_B PDL_S PDL_US PDL_L PDL_UL PDL_IND PDL_ULL PDL_LL PDL_F PDL_D PDL_LD PDL_CF PDL_CD PDL_CLD
ppdefs
Returns an array of pp symbols for all real types. This informs the default GenericTypes
for pp_def
functions, making support for complex types require an "optin".
pdl> print PDL::Types::ppdefs
A B S U L K N P Q F D E
ppdefs_complex
Returns an array of pp symbols for all complex types.
pdl> print PDL::Types::ppdefs_complex
G C H
ppdefs_all
Returns an array of pp symbols for all types including complex.
pdl> print PDL::Types::ppdefs_all
A B S U L K N P Q F D E G C H
typesynonyms
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.
PDL TYPES OVERVIEW
As of 2.065, PDL supports these types:
 SByte

Signed 8bit value.
 Byte

Unsigned 8bit value.
 Short

Signed 16bit value.
 UShort

Unsigned 16bit value.
 Long

Signed 32bit value.
 ULong

Unsigned 32bit value.
 Indx

Signed value, same size as a pointer on the system in use.
 ULongLong

Unsigned 64bit value.
 LongLong

Signed 64bit value.
 Float

IEEE 754 singleprecision real floatingpoint value.
 Double

IEEE 754 doubleprecision real value.
 LDouble

A C99 "long double", defined as "at least as precise as a double", but often more precise.
 CFloat

A C99 complex singleprecision floatingpoint value.
 CDouble

A C99 complex doubleprecision floatingpoint value.
 CLDouble

A C99 complex "long double"  see above for description.
PDL::Type OBJECTS
This module declares one class  PDL::Type
 objects of this class are returned by the type method of an ndarray. It has several methods, listed below, which provide an easy way to access type information:
Additionally, comparison and stringification are overloaded so that you can compare and print type objects, e.g.
$nofloat = 1 if $pdl>type < float;
die "must be double" if $type != double;
For further examples check again the type method.
 enum

Returns the number representing this datatype (see get_datatype).
 symbol

Returns one of 'PDL_SB', 'PDL_B', 'PDL_S', 'PDL_US', 'PDL_L', 'PDL_UL', 'PDL_IND', 'PDL_ULL', 'PDL_LL', 'PDL_F', 'PDL_D', 'PDL_LD', 'PDL_CF', 'PDL_CD', or 'PDL_CLD'.
 ctype

Returns the macro used to represent this type in C code (eg 'PDL_Long').
 convertfunc

Synonym for
ctype
.  ppsym

The letter used to represent this type in PP code (eg 'U' for ushort).
 realctype

The actual C type used to store this type.
 shortctype

The value returned by
ctype
without the 'PDL_' prefix.  badvalue

The special numerical value used to represent bad values for this type. See "badvalue" in PDL::Bad for more details.
 isnan

Given a string representing a C value, will return a C expression for this type that indicates whether that value is NaN (for complex values, if either is NaN).
 isfinite

Given a string representing a C value, will return a C expression for this type that indicates whether that value is finite (for complex values, if both are finite).
 floatsuffix

The string appended to floatingpoint functions for this floatingpoint type. Dies if called on nonfloatingpoint type.
 orig_badvalue

The default special numerical value used to represent bad values for this type. (You can change the value that represents bad values for each type during runtime.) See the orig_badvalue routine in PDL::Bad for more details.
 bswap

Returns the appropriate
bswap*
from PDL::IO::Misc for the size of this type, including a noop for types of size 1. Note this means a oneline construction means you must call the return value:$pdl>type>bswap>($pdl);
 real

Returns whether the type is realonly (true) or can hold complex values (false).
die "Real data only!" if !$pdl>type>real;
 unsigned

Returns whether the type can hold signed values (false) or not (true).
 integer

Returns whether the type can hold noninteger, a.k.a. floatingpoint, values (false) or not (true).
DEVELOPER NOTES ON ADDING/REMOVING TYPES
You can change the types that PDL knows about by editing entries in the definition of the variable @types
that appears close to the top of the file Types.pm.PL (i.e. the file from which this module was generated).
Format of a type entry
Each entry in the @types
array is a hash reference. Here is an example taken from the actual code that defines the ushort
type:
{
identifier => 'US',
onecharident => 'U', # only needed if different from identifier
pdlctype => 'PDL_Ushort',
realctype => 'unsigned short',
ppforcetype => 'ushort',
usenan => 0,
packtype => 'S*',
defaultbadval => 'USHRT_MAX',
real=>1,
integer=>1,
unsigned=>1,
},
Before we start to explain the fields please take this important message on board: entries must be listed in order of increasing complexity. This is critical to ensure that PDL's type conversion works correctly. Basically, a less complex type will be converted to a more complex type as required.
Fields in a type entry
Each type entry has a number of required and optional entry.
A list of all the entries:
identifier
Required. A short sequence of uppercase letters that identifies this type uniquely. More than three characters is probably overkill.
onecharident
Optional. Only required if the
identifier
has more than one character. This should be a unique uppercase character that will be used to reference this type in PP macro expressions of theTBSULFD
type  see "$T" in PDL::PP.pdlctype
Required. The
typedef
ed name that will be used to access this type from C code.realctype
Required. The C compiler type that is used to implement this type. For portability reasons this one might be platform dependent.
ppforcetype
Required. The type name used in PP signatures to refer to this type.
usenan
Required. Flag that signals if this type has to deal with NaN issues. Generally only required for floating point types.
packtype
Required. The Perl pack type used to pack Perl values into the machine representation for this type. For details see
perldoc f pack
.integer
Required. Boolean  is this an integer type?
unsigned
Required. Boolean  is this an unsigned type?
real
Required. Boolean  is this a real (not complex) type?
realversion
String  the real version of this type (e.g. cdouble > 'D').
complexversion
String  the complex version of this type (e.g. double > 'C').
Also have a look at the entries at the top of Types.pm.PL.
The syntax is not written into stone yet and might change as the concept matures.
Other things you need to do
You need to check modules that do I/O (generally in the IO part of the directory tree). In the future we might add fields to type entries to automate this. This requires changes to those IO modules first though.
You should also make sure that any type macros in PP files (i.e. $TBSULFD...
) are updated to reflect the new type. PDL::PP::Dump has a mode to check for type macros requiring updating. Do something like
find . name \*.pd exec perl Mblib=. M'PDL::PP::Dump=typecheck' {} \;
from the PDL root directory after updating Types.pm.PL to check for such places.