PDL interactive shell

Writing PDL programs

Whenever you write a stand-alone PDL program (i.e. outside the "perldl" or "pdl2" shells) you must start the program with "use PDL;". This command imports the PDL module into Perl. Here is a sample PDL program:

  use PDL;             # Import main PDL module.
  use PDL::NiceSlice;  # Import additional PDL module.
  
  $b = pdl [2,3,4];              # Statements end in semicolon.
  $A = pdl [ [1,2,3],[4,5,6] ];  # 2-dimensional piddle.
  
  print $A x $b->transpose;

Save this file as "myprogram.pl" and run it with:

  perl myprogram.pl

New: Flexible syntax

1) Use a ';' to delimit rows:

  $b = pdl q[ 2,3,4 ];
  $A = pdl q[ 1,2,3 ; 4,5,6 ];

2) Use spaces to separate elements:

  $b = pdl q[ 2 3 4 ];
  $A = pdl q[ 1 2 3 ; 4 5 6 ];

Basically, as long as you put a "q" in front of the opening bracket, PDL should "do what you mean". So you can write in a syntax that is more comfortable for you.

General "gotchas"

Indices

In PDL, indices start at '0' (like C and Java), not 1 (like Scilab). For example, if $b is an array with 5 elements, the elements would be numbered from 0 to 4.

Displaying an object

Scilab normally displays object contents automatically. In PDL you display objects explicitly with the "print" command or the shortcut "p":

Scilab:

 --> a = 12
 a =  12.
 --> b = 23;       // Suppress output.
 -->
    

PerlDL:

 pdl> $a = 12    # No output.
 pdl> print $a   # Print object.
 12
 pdl> p $a       # "p" is a shorthand for "print" in the shell.
 12
    

Creating Piddles

Variables in PDL

Variables always start with the '$' sign.

 Scilab:    value  = 42
 PerlDL:    $value = 42
    

Basic syntax

Use the "pdl" constructor to create a new piddle.

 Scilab:    v  = [1,2,3,4]
 PerlDL:    $v = pdl [1,2,3,4]

 Scilab:    A  =      [ 1,2,3  ;  3,4,5 ]
 PerlDL:    $A = pdl [ [1,2,3] , [3,4,5] ]
    

Simple matrices

                      Scilab       PDL
                      ------       ------
  Matrix of ones      ones(5,5)    ones 5,5
  Matrix of zeros     zeros(5,5)   zeros 5,5
  Random matrix       rand(5,5)    random 5,5
  Linear vector       1:5          sequence 5
    

Notice that in PDL the parenthesis in a function call are often optional. It is important to keep an eye out for possible ambiguities. For example:

  pdl> p zeros 2, 2 + 2
    

Should this be interpreted as "zeros(2,2) + 2" or as "zeros 2, (2+2)"? Both are valid statements:

  pdl> p zeros(2,2) + 2
  [
   [2 2]
   [2 2]
  ]
  pdl> p zeros 2, (2+2)
  [
   [0 0]
   [0 0]
   [0 0]
   [0 0]
  ]
    

Rather than trying to memorize Perl's order of precedence, it is best to use parentheses to make your code unambiguous.

Linearly spaced sequences

  Scilab:   --> linspace(2,10,5)
            ans = 2.  4.  6.  8.  10.
  
  PerlDL:   pdl> p zeroes(5)->xlinvals(2,10)
            [2 4 6 8 10]
    

Explanation: Start with a 1-dimensional piddle of 5 elements and give it equally spaced values from 2 to 10.

Scilab has a single function call for this. On the other hand, PDL's method is more flexible:

  pdl> p zeros(5,5)->xlinvals(2,10)
  [
   [ 2  4  6  8 10]
   [ 2  4  6  8 10]
   [ 2  4  6  8 10]
   [ 2  4  6  8 10]
   [ 2  4  6  8 10]
  ]
  pdl> p zeros(5,5)->ylinvals(2,10)
  [
   [ 2  2  2  2  2]
   [ 4  4  4  4  4]
   [ 6  6  6  6  6]
   [ 8  8  8  8  8]
   [10 10 10 10 10]
  ]
  pdl> p zeros(3,3,3)->zlinvals(2,6)
  [
   [
    [2 2 2]
    [2 2 2]
    [2 2 2]
   ]
   [
    [4 4 4]
    [4 4 4]
    [4 4 4]
   ]
   [
    [6 6 6]
    [6 6 6]
    [6 6 6]
   ]
  ]
    

Slicing and indices

Extracting a subset from a collection of data is known as slicing. The PDL shell and Scilab have a similar syntax for slicing, but there are two important differences:

1) PDL indices start at 0, as in C and Java. Scilab starts indices at 1.

2) In Scilab you think "rows and columns". In PDL, think "x and y".

  Scilab                         PerlDL
  ------                         ------
  --> A                           pdl> p $A
  A =                            [
       1.  2.  3.                 [1 2 3]
       4.  5.  6.                 [4 5 6]
       7.  8.  9.                 [7 8 9]
                                 ]
  -------------------------------------------------------
  (row = 2, col = 1)             (x = 0, y = 1)
  --> A(2,1)                      pdl> p $A(0,1)
  ans =                          [
         4.                       [4]
                                 ]
  -------------------------------------------------------
  (row = 2 to 3, col = 1 to 2)   (x = 0 to 1, y = 1 to 2)
  --> A(2:3,1:2)                  pdl> p $A(0:1,1:2)
  ans =                          [
         4.  5.                   [4 5]
         7.  8.                   [7 8]
                                 ]
    

Matrix Operations

Matrix multiplication

 Scilab:    A * B
 PerlDL:    $A x $B
    

Element-wise multiplication

 Scilab:    A .* B
 PerlDL:    $A * $B
    

Transpose

 Scilab:    A'
 PerlDL:    $A->transpose
    

Functions that aggregate data

Scilab

In Scilab, these functions work along the entire data set by default, and an optional parameter "r" or "c" makes them act over rows or columns.

  --> A = [ 1,5,4  ;  4,2,1 ]
  A = 1.  5.  4.
      4.  2.  1.
  --> max(A)
  ans = 5
  --> max(A, "r")
  ans = 4.    5.    4.
  --> max(A, "c")
  ans = 5.
        4.
    

PDL

PDL offers two functions for each feature.

  sum   vs   sumover
  avg   vs   average
  max   vs   maximum
  min   vs   minimum
    

The long name works over a dimension, while the short name works over the entire piddle.

  pdl> p $A = pdl [ [1,5,4] , [4,2,1] ]
  [
   [1 5 4]
   [4 2 1]
  ]
  pdl> p $A->maximum
  [5 4]
  pdl> p $A->transpose->maximum
  [4 5 4]
  pdl> p $A->max
  5
    

Higher dimensional data sets

Scilab sees a vector as a 2D matrix.

  Scilab                       PerlDL
  ------                       ------
  --> vector = [1,2,3,4];       pdl> $vector = pdl [1,2,3,4]
  --> size(vector)              pdl> p $vector->dims
  ans = 1 4                    4
    

Scilab sees "[1,2,3,4]" as a 2D matrix (1x4 matrix). PDL sees it as a 1D vector: A single dimension of size 4.

But Scilab ignores the last dimension of a 4x1x1 matrix.

  Scilab                       PerlDL
  ------                       ------
  --> A = ones(4,1,1);          pdl> $A = ones 4,1,1
  --> size(A)                   pdl> p $A->dims
  ans = 4 1                    4 1 1
    

And Scilab treats a 4x1x1 matrix differently from a 1x1x4 matrix.

  Scilab                       PerlDL
  ------                       ------
  --> A = ones(1,1,4);          pdl> $A = ones 1,1,4
  --> size(A)                   pdl> p $A->dims
  ans = 1 1 4                  1 1 4
    

Scilab has no direct syntax for N-D arrays.

  pdl> $A = pdl [ [[1,2,3],[4,5,6]], [[2,3,4],[5,6,7]] ]
  pdl> p $A->dims
  3 2 2
    

Feature support.

In Scilab, several features are not available for N-D arrays. In PDL, just about any feature supported by 1D and 2D piddles, is equally supported by N-dimensional piddles. There is usually no distinction:

  Scilab                       PerlDL
  ------                       ------
  --> A = ones(3,3,3);         pdl> $A = ones(3,3,3);
  --> A'                       pdl> transpose $A
      => ERROR                         => OK
    

Loop Structures

  Scilab              PerlDL
  ------              ------
  for i = 1:10        for $i (1..10) {
      disp(i)             print $i
  end                 }

Note

Never use for-loops for numerical work. Perl's for-loops are faster than Scilab's, but they both pale against a "vectorized" operation. PDL has many tools that facilitate writing vectorized programs. These are beyond the scope of this guide. To learn more, see: PDL::Indexing, PDL::Threading, and PDL::PP.

Likewise, never use 1..10 for numerical work, even outside a for-loop. 1..10 is a Perl array. Perl arrays are designed for flexibility, not speed. Use piddles instead. To learn more, see the next section.

Piddles vs Perl Arrays

  @perl_array = 1..10;
  @perl_array = ( 12, "Hello" );
  @perl_array = ( 1, 2, 3, \@another_perl_array, sequence(5) );

Perl arrays allow you to create powerful data structures (see Data structures below), but they are not designed for numerical work. For that, use piddles:

  $pdl = pdl [ 1, 2, 3, 4 ];
  $pdl = sequence 10_000_000; 
  $pdl = ones 600, 600;

For example:

  $points =  pdl  1..10_000_000    # 4.7 seconds
  $points = sequence 10_000_000    # milliseconds

TIP: You can use underscores in numbers ("10_000_000" reads better than 10000000).

Conditionals

  Scilab                          PerlDL
  ------                          ------
  if value > MAX                  if ($value > $MAX) {
      disp("Too large")               print "Too large\n";
  elseif value < MIN              } elsif ($value < $MIN) {
      disp("Too small")               print "Too small\n";
  else                            } else {
      disp("Perfect!")                print "Perfect!\n";
  end                             }

Note

Here is a "gotcha":

  Scilab:  elseif
  PerlDL:  elsif
    

If your conditional gives a syntax error, check that you wrote your "elsif"'s correctly.

TIMTOWDI (There Is More Than One Way To Do It)

Perl was written by a linguist, and one of its defining properties is that statements can be formulated in different ways to give the language a more natural feel. For example, you are unlikely to say to a friend:

 "While I am not finished, I will keep working."

Human language is more flexible than that. Instead, you are more likely to say:

 "I will keep working until I am finished."

Owing to its linguistic roots, Perl is the only programming language with this sort of flexibility. For example, Perl has traditional while-loops and if-statements:

  while ( ! finished() ) {
      keep_working();
  }
  
  if ( ! wife_angry() ) {
      kiss_wife();
  }

But it also offers the alternative until and unless statements:

  until ( finished() ) {
      keep_working();
  }
  
  unless ( wife_angry() ) {
      kiss_wife();
  }

And Perl allows you to write loops and conditionals in "postfix" form:

  keep_working() until finished();
  
  kiss_wife() unless wife_angry();

In this way, Perl often allows you to write more natural, easy to understand code than is possible in more restrictive programming languages.

Functions

  Scilab                          PerlDL
  ------                          ------
  function retval = foo(x,y)      sub foo {
      retval = x.**2 + x.*y           my ($x, $y) = @_;
  endfunction                         return $x**2 + $x*$y;
                                  }

Don't be intimidated by all the new syntax. Here is a quick run through a function declaration in PDL:

1) "sub" stands for "subroutine".

2) "my" declares variables to be local to the function.

3) "@_" is a special Perl array that holds all the function parameters. This might seem like a strange way to do functions, but it allows you to make functions that take a variable number of parameters. For example, the following function takes any number of parameters and adds them together:

  sub mysum {
      my ($i, $total) = (0, 0);
      for $i (@_) {
          $total += $i;
      }
      return $total;
  }

4) You can assign values to several variables at once using the syntax:

  ($a, $b, $c) = (1, 2, 3);

So, in the previous examples:

  # This declares two local variables and initializes them to 0.
  my ($i, $total) = (0, 0);
  
  # This takes the first two elements of @_ and puts them in $x and $y.
  my ($x, $y) = @_;

5) The "return" statement gives the return value of the function, if any.

Data structures

Arrays

Perl arrays are similar to Scilab's lists. They are both a sequential data structure that can contain any data type.

  Scilab
  ------
  list( 1, 12, "hello", zeros(3,3) , list( 1, 2) );
  
  PerlDL
  ------
  @array = ( 1, 12, "hello" , zeros(3,3), [ 1, 2 ] )
    

Notice that Perl array's start with the "@" prefix instead of the "$" used by piddles.

To learn about Perl arrays, please go to <http://perldoc.perl.org/perldata.html> or run the command "perldoc perldata".

Hashes

Perl hashes are similar to Scilab's structure arrays:

  Scilab
  ------
  --> drink = struct('type', 'coke', 'size', 'large', 'myarray', ones(3,3,3))
  --> drink.type = 'sprite'
  --> drink.price = 12          // Add new field to structure array.
  
  PerlDL
  ------
  pdl> %drink = ( type => 'coke' , size => 'large', mypiddle => ones(3,3,3) )
  pdl> $drink{type} = 'sprite'
  pdl> $drink{price} = 12   # Add new field to hash.
    

Notice that Perl hashes start with the "%" prefix instead of the "@" for arrays and "$" used by piddles.

To learn about Perl hashes, please go to <http://perldoc.perl.org/perldata.html> or run the command "perldoc perldata".

Performance

PDL::Indexing

Level: Beginner

This beginner tutorial covers the standard "vectorization" feature that you already know from Scilab. Use this page to learn how to avoid for-loops to make your program more efficient.

PDL::Threading

Level: Intermediate

PDL's "vectorization" feature goes beyond what most numerical software can do. In this tutorial you'll learn how to "thread" over higher dimensions, allowing you to vectorize your program further than is possible in Scilab.

Benchmarks

Level: Intermediate

Perl comes with an easy to use benchmarks module to help you find how long it takes to execute different parts of your code. It is a great tool to help you focus your optimization efforts. You can read about it online (<http://perldoc.perl.org/Benchmark.html>) or through the command "perldoc Benchmark".

PDL::PP

Level: Advanced

PDL's Pre-Processor is one of PDL's most powerful features. You write a function definition in special markup and the pre-processor generates real C code which can be compiled. With PDL:PP you get the full speed of native C code without having to deal with the full complexity of the C language.

Plotting

PDL::Graphics::PGPLOT

Best for: Plotting 2D functions and data sets.

This is an interface to the venerable PGPLOT library. PGPLOT has been widely used in the academic and scientific communities for many years. In part because of its age, PGPLOT has some limitations compared to newer packages such as PLplot (e.g. no RGB graphics). But it has many features that still make it popular in the scientific community.

PDL::Graphics::PLplot

Best for: Plotting 2D functions as well as 2D and 3D data sets.

This is an interface to the PLplot plotting library. PLplot is a modern, open source library for making scientific plots. It supports plots of both 2D and 3D data sets. PLplot is best supported for unix/linux/macosx platforms. It has an active developers community and support for win32 platforms is improving.

PDL::Graphics::TriD

Best for: Plotting 3D functions.

The native PDL 3D graphics library using OpenGL as a backend for 3D plots and data visualization. With OpenGL, it is easy to manipulate the resulting 3D objects with the mouse in real time.

Writing GUIs

wxWidgets is designed to make your application look and feel like a native application in every platform. For example, the Perl IDE Padre is written with wxPerl.

Xcos / Scicos