SCILAB(1) User Contributed Perl Documentation SCILAB(1)NAMEPDL::Scilab - A guide for Scilab users.
INTRODUCTION
If you are a Scilab user, this page is for you. It explains the key
differences between Scilab and PDL to help you get going as quickly as
possible.
This document is not a tutorial. For that, go to PDL::QuickStart. This
document complements the Quick Start guide, as it highlights the key
differences between Scilab and PDL.
Perl
The key difference between Scilab and PDL is Perl.
Perl is a general purpose programming language with thousands of
modules freely available on the web. PDL is an extension of Perl. This
gives PDL programs access to more features than most numerical tools
can dream of. At the same time, most syntax differences between Scilab
and PDL are a result of its Perl foundation.
You do not have to learn much Perl to be effective with PDL. But if you
wish to learn Perl, there is excellent documentation available on-line
(<http://perldoc.perl.org>) or through the command "perldoc perl".
There is also a beginner's portal (<http://perl-begin.org>).
Perl's module repository is called CPAN (<http://www.cpan.org>) and it
has a vast array of modules. Run "perldoc cpan" for more information.
TERMINOLOGY: PIDDLE
Scilab typically refers to vectors, matrices, and arrays. Perl already
has arrays, and the terms "vector" and "matrix" typically refer to one-
and two-dimensional collections of data. Having no good term to
describe their object, PDL developers coined the term "piddle" to give
a name to their data type.
A piddle consists of a series of numbers organized as an N-dimensional
data set. Piddles provide efficient storage and fast computation of
large N-dimensional matrices. They are highly optimized for numerical
work.
For more information, see "Piddles vs Perl Arrays" later in this
document.
COMMAND WINDOW AND IDE
PDL does not come with a dedicated IDE. It does however come with an
interactive shell and you can use a Perl IDE to develop PDL programs.
PDL interactive shell
To start the interactive shell, open a terminal and run "perldl" or
"pdl2". As in Scilab, the interactive shell is the best way to learn
the language. To exit the shell, type "exit", just like Scilab.
Writing PDL programs
One popular IDE for Perl is called Padre (<http://padre.perlide.org>).
It is cross platform and easy to use.
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
In very recent versions of PDL (version 2.4.7 or later) there is a
flexible matrix syntax that can look extremely similar to Scilab:
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.
A MODULE FOR SCILAB USERS
Here is a module that Scilab users will want to use:
PDL::NiceSlice
Gives PDL a syntax for slices (sub-matrices) that is shorter and
more familiar to Scilab users.
// Scilab
b(1:5) --> Selects the first 5 elements from b.
# PDL without NiceSlice
$b->slice("0:4") --> Selects the first 5 elements from $b.
# PDL with NiceSlice
$b(0:4) --> Selects the first 5 elements from $b.
BASIC FEATURES
This section explains how PDL's syntax differs from Scilab. Most Scilab
users will want to start here.
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]
]
Warning
When you write a stand-alone PDL program you have to include
the PDL::NiceSlice module. See the previous section "MODULES
FOR SCILAB USERS" for more information.
use PDL; # Import main PDL module.
use PDL::NiceSlice; # Nice syntax for slicing.
$A = random 4,4;
print $A(0,1);
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
Some functions (like "sum", "max" and "min") aggregate data for an
N-dimensional data set. Scilab and PDL both give you the option to
apply these functions to the entire data set or to just one dimension.
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
A related issue is how Scilab and PDL understand data sets of higher
dimension. Scilab was designed for 1D vectors and 2D matrices with
higher dimensional objects added on top. In contrast, PDL was designed
for N-dimensional piddles from the start. This leads to a few surprises
in Scilab that don't occur in PDL:
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
Perl has many loop structures, but we will only show the one that is
most familiar to Scilab users:
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
It is important to note the difference between a Piddle and a Perl
array. Perl has a general-purpose array object that can hold any type
of element:
@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
Perl has many conditionals, but we will only show the one that is most
familiar to Scilab users:
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)
One of the most interesting differences between PDL and other tools is
the expressiveness of the Perl language. TIMTOWDI, or "There Is More
Than One Way To Do It", is Perl's motto.
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
PDL's syntax for declaring functions differs significantly from
Scilab's.
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.
ADDITIONAL FEATURES
Data structures
To create complex data structures, Scilab uses "lists" and "structs".
Perl's arrays and hashes offer similar functionality. This section is
only a quick overview of what Perl has to offer. To learn more about
this, please go to <http://perldoc.perl.org/perldata.html> or run the
command "perldoc perldata".
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 has powerful performance features, some of which are not normally
available in numerical computation tools. The following pages will
guide you through these features:
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 has full-featured plotting abilities. Unlike Scilab, PDL relies
more on third-party libraries (pgplot and PLplot) for its 2D plotting
features. Its 3D plotting and graphics uses OpenGL for performance and
portability. PDL has three main plotting modules:
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
Through Perl, PDL has access to all the major toolkits for creating a
cross platform graphical user interface. One popular option is wxPerl
(<http://wxperl.sourceforge.net>). These are the Perl bindings for
wxWidgets, a powerful GUI toolkit for writing cross-platform
applications.
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
Xcos (formerly Scicos) is a graphical dynamical system modeler and
simulator. It is part of the standard Scilab distribution. PDL and Perl
do not have a direct equivalent to Scilab's Xcos. If this feature is
important to you, you should probably keep a copy of Scilab around for
that.
COPYRIGHT
Copyright 2010 Daniel Carrera (dcarrera@gmail.com). You can distribute
and/or modify this document under the same terms as the current Perl
license.
See: http://dev.perl.org/licenses/
perl v5.18.1 2013-09-21 SCILAB(1)
