1SCILAB(1) User Contributed Perl Documentation SCILAB(1)
2
6 PDL::Scilab - A guide for Scilab users.
7
9 If you are a Scilab user, this page is for you. It explains the key
10 differences between Scilab and PDL to help you get going as quickly as
11 possible.
12 This document is not a tutorial. For that, go to PDL::QuickStart. This
14 document complements the Quick Start guide, as it highlights the key
15 differences between Scilab and PDL.
16
18 The key difference between Scilab and PDL is Perl.
19 Perl is a general purpose programming language with thousands of
21 modules freely available on the web. PDL is an extension of Perl. This
22 gives PDL programs access to more features than most numerical tools
23 can dream of. At the same time, most syntax differences between Scilab
24 and PDL are a result of its Perl foundation.
25 You do not have to learn much Perl to be effective with PDL. But if you
27 wish to learn Perl, there is excellent documentation available on-line
28 (<http://perldoc.perl.org>) or through the command "perldoc perl".
29 There is also a beginner's portal (<http://perl-begin.org>).
30 Perl's module repository is called CPAN (<http://www.cpan.org>) and it
32 has a vast array of modules. Run "perldoc cpan" for more information.
33
35 Scilab typically refers to vectors, matrices, and arrays. Perl already
36 has arrays, and the terms "vector" and "matrix" typically refer to one-
37 and two-dimensional collections of data. Having no good term to
38 describe their object, PDL developers coined the term "piddle" to give
39 a name to their data type.
40 A piddle consists of a series of numbers organized as an N-dimensional
42 data set. Piddles provide efficient storage and fast computation of
43 large N-dimensional matrices. They are highly optimized for numerical
44 work.
45 For more information, see "Piddles vs Perl Arrays" later in this
47 document.
48
50 PDL does not come with a dedicated IDE. It does however come with an
51 interactive shell and you can use a Perl IDE to develop PDL programs.
52 PDL interactive shell
54 To start the interactive shell, open a terminal and run "perldl" or
55 "pdl2". As in Scilab, the interactive shell is the best way to learn
56 the language. To exit the shell, type "exit", just like Scilab.
57 Writing PDL programs
59 One popular IDE for Perl is called Padre (<http://padre.perlide.org>).
60 It is cross platform and easy to use.
61 Whenever you write a stand-alone PDL program (i.e. outside the "perldl"
63 or "pdl2" shells) you must start the program with "use PDL;". This
64 command imports the PDL module into Perl. Here is a sample PDL program:
65 use PDL; # Import main PDL module.
67 use PDL::NiceSlice; # Import additional PDL module.
68 $y = pdl [2,3,4]; # Statements end in semicolon.
70 $A = pdl [ [1,2,3],[4,5,6] ]; # 2-dimensional piddle.
71 print $A x $y->transpose;
73 Save this file as "myprogram.pl" and run it with:
75 perl myprogram.pl
77 New: Flexible syntax
79 In very recent versions of PDL (version 2.4.7 or later) there is a
80 flexible matrix syntax that can look extremely similar to Scilab:
81 1) Use a ';' to delimit rows:
83 $y = pdl q[ 2,3,4 ];
85 $A = pdl q[ 1,2,3 ; 4,5,6 ];
86 2) Use spaces to separate elements:
88 $y = pdl q[ 2 3 4 ];
90 $A = pdl q[ 1 2 3 ; 4 5 6 ];
91 Basically, as long as you put a "q" in front of the opening bracket,
93 PDL should "do what you mean". So you can write in a syntax that is
94 more comfortable for you.
95
97 Here is a module that Scilab users will want to use:
98 PDL::NiceSlice
100 Gives PDL a syntax for slices (sub-matrices) that is shorter and
101 more familiar to Scilab users.
102 // Scilab
104 b(1:5) --> Selects the first 5 elements from b.
105 # PDL without NiceSlice
107 $y->slice("0:4") --> Selects the first 5 elements from $y.
108 # PDL with NiceSlice
110 $y(0:4) --> Selects the first 5 elements from $y.
111
113 This section explains how PDL's syntax differs from Scilab. Most Scilab
114 users will want to start here.
115 General "gotchas"
117 Indices
118 In PDL, indices start at '0' (like C and Java), not 1 (like
119 Scilab). For example, if $y is an array with 5 elements, the
120 elements would be numbered from 0 to 4.
121 Displaying an object
123 Scilab normally displays object contents automatically. In PDL you
124 display objects explicitly with the "print" command or the
125 shortcut "p":
126 Scilab:
128 --> a = 12
130 a = 12.
131 --> b = 23; // Suppress output.
132 -->
133 PerlDL:
135 pdl> $x = 12 # No output.
137 pdl> print $x # Print object.
138 12
139 pdl> p $x # "p" is a shorthand for "print" in the shell.
140 12
141 Creating Piddles
143 Variables in PDL
144 Variables always start with the '$' sign.
145 Scilab: value = 42
147 PerlDL: $value = 42
148 Basic syntax
150 Use the "pdl" constructor to create a new piddle.
151 Scilab: v = [1,2,3,4]
153 PerlDL: $v = pdl [1,2,3,4]
154 Scilab: A = [ 1,2,3 ; 3,4,5 ]
156 PerlDL: $A = pdl [ [1,2,3] , [3,4,5] ]
157 Simple matrices
159 Scilab PDL
160 ------ ------
161 Matrix of ones ones(5,5) ones 5,5
162 Matrix of zeros zeros(5,5) zeros 5,5
163 Random matrix rand(5,5) random 5,5
164 Linear vector 1:5 sequence 5
165 Notice that in PDL the parenthesis in a function call are often
167 optional. It is important to keep an eye out for possible
168 ambiguities. For example:
169 pdl> p zeros 2, 2 + 2
171 Should this be interpreted as "zeros(2,2) + 2" or as "zeros 2,
173 (2+2)"? Both are valid statements:
174 pdl> p zeros(2,2) + 2
176 [
177 [2 2]
178 [2 2]
179 ]
180 pdl> p zeros 2, (2+2)
181 [
182 [0 0]
183 [0 0]
184 [0 0]
185 [0 0]
186 ]
187 Rather than trying to memorize Perl's order of precedence, it is
189 best to use parentheses to make your code unambiguous.
190 Linearly spaced sequences
192 Scilab: --> linspace(2,10,5)
193 ans = 2. 4. 6. 8. 10.
194 PerlDL: pdl> p zeroes(5)->xlinvals(2,10)
196 [2 4 6 8 10]
197 Explanation: Start with a 1-dimensional piddle of 5 elements and
199 give it equally spaced values from 2 to 10.
200 Scilab has a single function call for this. On the other hand,
202 PDL's method is more flexible:
203 pdl> p zeros(5,5)->xlinvals(2,10)
205 [
206 [ 2 4 6 8 10]
207 [ 2 4 6 8 10]
208 [ 2 4 6 8 10]
209 [ 2 4 6 8 10]
210 [ 2 4 6 8 10]
211 ]
212 pdl> p zeros(5,5)->ylinvals(2,10)
213 [
214 [ 2 2 2 2 2]
215 [ 4 4 4 4 4]
216 [ 6 6 6 6 6]
217 [ 8 8 8 8 8]
218 [10 10 10 10 10]
219 ]
220 pdl> p zeros(3,3,3)->zlinvals(2,6)
221 [
222 [
223 [2 2 2]
224 [2 2 2]
225 [2 2 2]
226 ]
227 [
228 [4 4 4]
229 [4 4 4]
230 [4 4 4]
231 ]
232 [
233 [6 6 6]
234 [6 6 6]
235 [6 6 6]
236 ]
237 ]
238 Slicing and indices
240 Extracting a subset from a collection of data is known as slicing.
241 The PDL shell and Scilab have a similar syntax for slicing, but
242 there are two important differences:
243 1) PDL indices start at 0, as in C and Java. Scilab starts indices
245 at 1.
246 2) In Scilab you think "rows and columns". In PDL, think "x and
248 y".
249 Scilab PerlDL
251 ------ ------
252 --> A pdl> p $A
253 A = [
254 1. 2. 3. [1 2 3]
255 4. 5. 6. [4 5 6]
256 7. 8. 9. [7 8 9]
257 ]
258 -------------------------------------------------------
259 (row = 2, col = 1) (x = 0, y = 1)
260 --> A(2,1) pdl> p $A(0,1)
261 ans = [
262 4. [4]
263 ]
264 -------------------------------------------------------
265 (row = 2 to 3, col = 1 to 2) (x = 0 to 1, y = 1 to 2)
266 --> A(2:3,1:2) pdl> p $A(0:1,1:2)
267 ans = [
268 4. 5. [4 5]
269 7. 8. [7 8]
270 ]
271 Warning
273 When you write a stand-alone PDL program you have to include
274 the PDL::NiceSlice module. See the previous section "MODULES
275 FOR SCILAB USERS" for more information.
276 use PDL; # Import main PDL module.
278 use PDL::NiceSlice; # Nice syntax for slicing.
279 $A = random 4,4;
281 print $A(0,1);
282 Matrix Operations
284 Matrix multiplication
285 Scilab: A * B
286 PerlDL: $A x $B
287 Element-wise multiplication
289 Scilab: A .* B
290 PerlDL: $A * $B
291 Transpose
293 Scilab: A'
294 PerlDL: $A->transpose
295 Functions that aggregate data
297 Some functions (like "sum", "max" and "min") aggregate data for an
298 N-dimensional data set. Scilab and PDL both give you the option to
299 apply these functions to the entire data set or to just one dimension.
300 Scilab In Scilab, these functions work along the entire data set by
302 default, and an optional parameter "r" or "c" makes them act
303 over rows or columns.
304 --> A = [ 1,5,4 ; 4,2,1 ]
306 A = 1. 5. 4.
307 4. 2. 1.
308 --> max(A)
309 ans = 5
310 --> max(A, "r")
311 ans = 4. 5. 4.
312 --> max(A, "c")
313 ans = 5.
314 4.
315 PDL PDL offers two functions for each feature.
317 sum vs sumover
319 avg vs average
320 max vs maximum
321 min vs minimum
322 The long name works over a dimension, while the short name
324 works over the entire piddle.
325 pdl> p $A = pdl [ [1,5,4] , [4,2,1] ]
327 [
328 [1 5 4]
329 [4 2 1]
330 ]
331 pdl> p $A->maximum
332 [5 4]
333 pdl> p $A->transpose->maximum
334 [4 5 4]
335 pdl> p $A->max
336 5
337 Higher dimensional data sets
339 A related issue is how Scilab and PDL understand data sets of higher
340 dimension. Scilab was designed for 1D vectors and 2D matrices with
341 higher dimensional objects added on top. In contrast, PDL was designed
342 for N-dimensional piddles from the start. This leads to a few surprises
343 in Scilab that don't occur in PDL:
344 Scilab sees a vector as a 2D matrix.
346 Scilab PerlDL
347 ------ ------
348 --> vector = [1,2,3,4]; pdl> $vector = pdl [1,2,3,4]
349 --> size(vector) pdl> p $vector->dims
350 ans = 1 4 4
351 Scilab sees "[1,2,3,4]" as a 2D matrix (1x4 matrix). PDL sees it
353 as a 1D vector: A single dimension of size 4.
354 But Scilab ignores the last dimension of a 4x1x1 matrix.
356 Scilab PerlDL
357 ------ ------
358 --> A = ones(4,1,1); pdl> $A = ones 4,1,1
359 --> size(A) pdl> p $A->dims
360 ans = 4 1 4 1 1
361 And Scilab treats a 4x1x1 matrix differently from a 1x1x4 matrix.
363 Scilab PerlDL
364 ------ ------
365 --> A = ones(1,1,4); pdl> $A = ones 1,1,4
366 --> size(A) pdl> p $A->dims
367 ans = 1 1 4 1 1 4
368 Scilab has no direct syntax for N-D arrays.
370 pdl> $A = pdl [ [[1,2,3],[4,5,6]], [[2,3,4],[5,6,7]] ]
371 pdl> p $A->dims
372 3 2 2
373 Feature support.
375 In Scilab, several features are not available for N-D arrays. In
376 PDL, just about any feature supported by 1D and 2D piddles, is
377 equally supported by N-dimensional piddles. There is usually no
378 distinction:
379 Scilab PerlDL
381 ------ ------
382 --> A = ones(3,3,3); pdl> $A = ones(3,3,3);
383 --> A' pdl> transpose $A
384 => ERROR => OK
385 Loop Structures
387 Perl has many loop structures, but we will only show the one that is
388 most familiar to Scilab users:
389 Scilab PerlDL
391 ------ ------
392 for i = 1:10 for $i (1..10) {
393 disp(i) print $i
394 end }
395 Note Never use for-loops for numerical work. Perl's for-loops are
397 faster than Scilab's, but they both pale against a "vectorized"
398 operation. PDL has many tools that facilitate writing vectorized
399 programs. These are beyond the scope of this guide. To learn
400 more, see: PDL::Indexing, PDL::Threading, and PDL::PP.
401 Likewise, never use 1..10 for numerical work, even outside a for-
403 loop. 1..10 is a Perl array. Perl arrays are designed for
404 flexibility, not speed. Use piddles instead. To learn more, see
405 the next section.
406 Piddles vs Perl Arrays
408 It is important to note the difference between a Piddle and a Perl
409 array. Perl has a general-purpose array object that can hold any type
410 of element:
411 @perl_array = 1..10;
413 @perl_array = ( 12, "Hello" );
414 @perl_array = ( 1, 2, 3, \@another_perl_array, sequence(5) );
415 Perl arrays allow you to create powerful data structures (see Data
417 structures below), but they are not designed for numerical work. For
418 that, use piddles:
419 $pdl = pdl [ 1, 2, 3, 4 ];
421 $pdl = sequence 10_000_000;
422 $pdl = ones 600, 600;
423 For example:
425 $points = pdl 1..10_000_000 # 4.7 seconds
427 $points = sequence 10_000_000 # milliseconds
428 TIP: You can use underscores in numbers ("10_000_000" reads better than
430 10000000).
431 Conditionals
433 Perl has many conditionals, but we will only show the one that is most
434 familiar to Scilab users:
435 Scilab PerlDL
437 ------ ------
438 if value > MAX if ($value > $MAX) {
439 disp("Too large") print "Too large\n";
440 elseif value < MIN } elsif ($value < $MIN) {
441 disp("Too small") print "Too small\n";
442 else } else {
443 disp("Perfect!") print "Perfect!\n";
444 end }
445 Note Here is a "gotcha":
447 Scilab: elseif
449 PerlDL: elsif
450 If your conditional gives a syntax error, check that you wrote
452 your "elsif"'s correctly.
453 TIMTOWDI (There Is More Than One Way To Do It)
455 One of the most interesting differences between PDL and other tools is
456 the expressiveness of the Perl language. TIMTOWDI, or "There Is More
457 Than One Way To Do It", is Perl's motto.
458 Perl was written by a linguist, and one of its defining properties is
460 that statements can be formulated in different ways to give the
461 language a more natural feel. For example, you are unlikely to say to a
462 friend:
463 "While I am not finished, I will keep working."
465 Human language is more flexible than that. Instead, you are more likely
467 to say:
468 "I will keep working until I am finished."
470 Owing to its linguistic roots, Perl is the only programming language
472 with this sort of flexibility. For example, Perl has traditional while-
473 loops and if-statements:
474 while ( ! finished() ) {
476 keep_working();
477 }
478 if ( ! wife_angry() ) {
480 kiss_wife();
481 }
482 But it also offers the alternative until and unless statements:
484 until ( finished() ) {
486 keep_working();
487 }
488 unless ( wife_angry() ) {
490 kiss_wife();
491 }
492 And Perl allows you to write loops and conditionals in "postfix" form:
494 keep_working() until finished();
496 kiss_wife() unless wife_angry();
498 In this way, Perl often allows you to write more natural, easy to
500 understand code than is possible in more restrictive programming
501 languages.
502 Functions
504 PDL's syntax for declaring functions differs significantly from
505 Scilab's.
506 Scilab PerlDL
508 ------ ------
509 function retval = foo(x,y) sub foo {
510 retval = x.**2 + x.*y my ($x, $y) = @_;
511 endfunction return $x**2 + $x*$y;
512 }
513 Don't be intimidated by all the new syntax. Here is a quick run through
515 a function declaration in PDL:
516 1) "sub" stands for "subroutine".
518 2) "my" declares variables to be local to the function.
520 3) "@_" is a special Perl array that holds all the function parameters.
522 This might seem like a strange way to do functions, but it allows you
523 to make functions that take a variable number of parameters. For
524 example, the following function takes any number of parameters and adds
525 them together:
526 sub mysum {
528 my ($i, $total) = (0, 0);
529 for $i (@_) {
530 $total += $i;
531 }
532 return $total;
533 }
534 4) You can assign values to several variables at once using the syntax:
536 ($x, $y, $z) = (1, 2, 3);
538 So, in the previous examples:
540 # This declares two local variables and initializes them to 0.
542 my ($i, $total) = (0, 0);
543 # This takes the first two elements of @_ and puts them in $x and $y.
545 my ($x, $y) = @_;
546 5) The "return" statement gives the return value of the function, if
548 any.
549
551 Data structures
552 To create complex data structures, Scilab uses "lists" and "structs".
553 Perl's arrays and hashes offer similar functionality. This section is
554 only a quick overview of what Perl has to offer. To learn more about
555 this, please go to <http://perldoc.perl.org/perldata.html> or run the
556 command "perldoc perldata".
557 Arrays
559 Perl arrays are similar to Scilab's lists. They are both a
560 sequential data structure that can contain any data type.
561 Scilab
563 ------
564 list( 1, 12, "hello", zeros(3,3) , list( 1, 2) );
565 PerlDL
567 ------
568 @array = ( 1, 12, "hello" , zeros(3,3), [ 1, 2 ] )
569 Notice that Perl array's start with the "@" prefix instead of the
571 "$" used by piddles.
572 To learn about Perl arrays, please go to
574 <http://perldoc.perl.org/perldata.html> or run the command
575 "perldoc perldata".
576 Hashes
578 Perl hashes are similar to Scilab's structure arrays:
579 Scilab
581 ------
582 --> drink = struct('type', 'coke', 'size', 'large', 'myarray', ones(3,3,3))
583 --> drink.type = 'sprite'
584 --> drink.price = 12 // Add new field to structure array.
585 PerlDL
587 ------
588 pdl> %drink = ( type => 'coke' , size => 'large', mypiddle => ones(3,3,3) )
589 pdl> $drink{type} = 'sprite'
590 pdl> $drink{price} = 12 # Add new field to hash.
591 Notice that Perl hashes start with the "%" prefix instead of the
593 "@" for arrays and "$" used by piddles.
594 To learn about Perl hashes, please go to
596 <http://perldoc.perl.org/perldata.html> or run the command
597 "perldoc perldata".
598 Performance
600 PDL has powerful performance features, some of which are not normally
601 available in numerical computation tools. The following pages will
602 guide you through these features:
603 PDL::Indexing
605 Level: Beginner
606 This beginner tutorial covers the standard "vectorization" feature
608 that you already know from Scilab. Use this page to learn how to
609 avoid for-loops to make your program more efficient.
610 PDL::Threading
612 Level: Intermediate
613 PDL's "vectorization" feature goes beyond what most numerical
615 software can do. In this tutorial you'll learn how to "thread"
616 over higher dimensions, allowing you to vectorize your program
617 further than is possible in Scilab.
618 Benchmarks
620 Level: Intermediate
621 Perl comes with an easy to use benchmarks module to help you find
623 how long it takes to execute different parts of your code. It is a
624 great tool to help you focus your optimization efforts. You can
625 read about it online (<http://perldoc.perl.org/Benchmark.html>) or
626 through the command "perldoc Benchmark".
627 PDL::PP
629 Level: Advanced
630 PDL's Pre-Processor is one of PDL's most powerful features. You
632 write a function definition in special markup and the pre-
633 processor generates real C code which can be compiled. With PDL:PP
634 you get the full speed of native C code without having to deal
635 with the full complexity of the C language.
636 Plotting
638 PDL has full-featured plotting abilities. Unlike Scilab, PDL relies
639 more on third-party libraries (pgplot and PLplot) for its 2D plotting
640 features. Its 3D plotting and graphics uses OpenGL for performance and
641 portability. PDL has three main plotting modules:
642 PDL::Graphics::PGPLOT
644 Best for: Plotting 2D functions and data sets.
645 This is an interface to the venerable PGPLOT library. PGPLOT has
647 been widely used in the academic and scientific communities for
648 many years. In part because of its age, PGPLOT has some
649 limitations compared to newer packages such as PLplot (e.g. no RGB
650 graphics). But it has many features that still make it popular in
651 the scientific community.
652 PDL::Graphics::PLplot
654 Best for: Plotting 2D functions as well as 2D and 3D data sets.
655 This is an interface to the PLplot plotting library. PLplot is a
657 modern, open source library for making scientific plots. It
658 supports plots of both 2D and 3D data sets. PLplot is best
659 supported for unix/linux/macosx platforms. It has an active
660 developers community and support for win32 platforms is improving.
661 PDL::Graphics::TriD
663 Best for: Plotting 3D functions.
664 The native PDL 3D graphics library using OpenGL as a backend for
666 3D plots and data visualization. With OpenGL, it is easy to
667 manipulate the resulting 3D objects with the mouse in real time.
668 Writing GUIs
670 Through Perl, PDL has access to all the major toolkits for creating a
671 cross platform graphical user interface. One popular option is wxPerl
672 (<http://wxperl.sourceforge.net>). These are the Perl bindings for
673 wxWidgets, a powerful GUI toolkit for writing cross-platform
674 applications.
675 wxWidgets is designed to make your application look and feel like a
677 native application in every platform. For example, the Perl IDE Padre
678 is written with wxPerl.
679 Xcos / Scicos
681 Xcos (formerly Scicos) is a graphical dynamical system modeler and
682 simulator. It is part of the standard Scilab distribution. PDL and Perl
683 do not have a direct equivalent to Scilab's Xcos. If this feature is
684 important to you, you should probably keep a copy of Scilab around for
685 that.
686
688 Copyright 2010 Daniel Carrera (dcarrera@gmail.com). You can distribute
689 and/or modify this document under the same terms as the current Perl
690 license.
691 See: http://dev.perl.org/licenses/
693perl v5.32.0 2020-09-17 SCILAB(1)