SCILAB(1p)

💖 NAME 💖

PDL::Scilab — a guide for Scilab users. (yes bestie, this is from SCILAB(1p), User Contributed Perl Documentation, and it's your whole personality now 🫶)

---

🌸 INTRODUCTION 🌸

Scilab girlie?? This page is for you. It walks you through the big key differences between Scilab and PDL so you can get going as fast as humanly possible. No cap. 💅

Heads up: this is not a tutorial. If you want the tutorial, go to PDL::QuickStart. This doc is the complement — it's the highlight reel of "wait, why is it like that" between Scilab and PDL. 🎀

Perl 🐪

Okay so the biggest plot twist: the key difference between Scilab and PDL is Perl.

Perl is a general purpose programming language with thousands of modules just chilling on the web for free. PDL is an extension of Perl. Which means PDL programs get access to more features than most numerical tools can even dream of. ✨ And yeah — most of the syntax differences between Scilab and PDL are literally just because of that Perl foundation. It's giving "raised by Perl".

The good news: you do not have to learn much Perl to be effective with PDL. Like, barely any. But if you do want to learn Perl, there's excellent documentation online (<http://perldoc.perl.org>) or you can run perldoc perl. There's 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 info. 💜

---

🦋 TERMINOLOGY: NDARRAY 🦋

Scilab typically says vectors, matrices, and arrays. But plot twist: Perl already has arrays, and "vector"/"matrix" usually mean one- and two-dimensional collections of data. So the PDL devs were like "we need a name" and they coined ndarray. That's the data type's whole name now. 👑

An ndarray is a series of numbers organized as an N-dimensional data set. ndarrays give you efficient storage and fast computation of large N-dimensional matrices. They are highly optimized for numerical work. Lowkey iconic.

Want more? See "ndarrays vs Perl Arrays" later in this document. 📖

---

💅 COMMAND WINDOW AND IDE 💅

PDL does not come with a dedicated IDE. Not a vibe, I know. But it does come with an interactive shell, and you can totally use a Perl IDE to develop PDL programs.

PDL interactive shell 🐚

To start the interactive shell, open a terminal and run perldl or pdl2. Just like in Scilab, the interactive shell is the best way to learn the language — fr fr. To exit the shell, type exit, same as Scilab. 🚪

Writing PDL programs 📝

One popular IDE for Perl is called Padre (<http://padre.perlide.org>). It's cross platform and easy to use. Slay.

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's a sample PDL program:

use PDL;             # Import main PDL module.
use PDL::NiceSlice;  # Import additional PDL module.

$y = pdl [2,3,4];              # Statements end in semicolon.
$A = pdl [ [1,2,3],[4,5,6] ];  # 2-dimensional ndarray.

print $A x $y->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's a flexible matrix syntax that can look extremely similar to Scilab. Bestie, the glow up:

1. Use a ';' to delimit rows:

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

2. Use spaces to separate elements:

$y = 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 whatever syntax is most comfortable for you. No gatekeeping here. 💖

---

🎀 A MODULE FOR SCILAB USERS 🎀

Here's 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
$y->slice("0:4")  -->  Selects the first 5 elements from $y.

# PDL with NiceSlice
$y(0:4)           -->  Selects the first 5 elements from $y.

---

🔥 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). So if $y is an array with 5 elements, the elements would be numbered from 0 to 4. Yes, it's a whole thing. Get used to it. 💀

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> $x = 12    # No output.
pdl> print $x   # Print object.
12
pdl> p $x       # "p" is a shorthand for "print" in the shell.
12

Creating ndarrays 🧚

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 ndarray.

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

• Matrix of ones — Scilab: ones(5,5), PDL: ones 5,5
• Matrix of zeros — Scilab: zeros(5,5), PDL: zeros 5,5
• Random matrix — Scilab: rand(5,5), PDL: random 5,5
• Linear vector — Scilab: 1:5, PDL: 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. Trust. 🫶

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 ndarray 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 ndarray. 🌟

okay bestie watch this, this is the moment where the comparison really starts to hit different:

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 🌈

So here's the tea: Scilab and PDL do not see high-dimensional data the same way, and it's giving culture clash. Scilab was built for 1D vectors and 2D matrices, and then higher-dimensional objects got bolted on top like an afterthought. PDL was designed for N-dimensional ndarrays from day one, periodt. So Scilab throws a few surprises at you that literally never happen 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 reads "[1,2,3,4]" as a 2D matrix (a 1x4 matrix, bestie). PDL reads it as a 1D vector: one single dimension of size 4. iconic behaviour honestly.

• 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, a bunch of features are just not available for N-D arrays. In PDL? Basically every feature that works on 1D and 2D ndarrays works equally on N-dimensional ndarrays. There's usually no distinction at all:

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

---

🔁 Loop Structures 🔁

Perl has so many loop structures, but we're only gonna show you the one that feels most like home to a Scilab user:

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::Broadcasting, 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 ndarrays instead. To learn more, see the next section.

---

💅 ndarrays vs Perl Arrays 💅

Okay this one matters so much. You have to know the difference between an ndarray 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 let you build powerful data structures (see Data structures below), but they are not designed for numerical work. For that, use ndarrays:

$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). we love readability in this house 🫶

---

🤔 Conditionals 🤔

Perl has many conditionals, but again, we're only showing the one most familiar to Scilab girlies:

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. (yes this gets everyone, you're not alone 😭)

---

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

One of the most interesting differences between PDL and other tools is how expressive the Perl language is. TIMTOWDI, aka "There Is More Than One Way To Do It", is Perl's motto, and honestly? it's giving main character energy.

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. no cap.

---

🧚 Functions 🧚

PDL's syntax for declaring functions differs significantly from Scilab's, bestie. brace yourself:

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's 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:

($x, $y, $z) = (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

So to build those big fancy complex data structures, Scilab uses "lists" and "structs". Perl's arrays and hashes do basically the same job 💖. Heads up though — this is only a lil quick overview of what Perl brings to the table. Wanna go deeper? Hit up <http://perldoc.perl.org/perldata.html> or just run the command perldoc perldata and let the docs parent you. 🫶

Arrays

Perl arrays are lowkey the same vibe as Scilab's lists — both are a sequential data structure that can hold literally any data type. ✨

Scilab

list( 1, 12, "hello", zeros(3,3) , list( 1, 2) );

PerlDL

@array = ( 1, 12, "hello" , zeros(3,3), [ 1, 2 ] )

Okay so notice this: Perl arrays start with the @ prefix, not the $ that ndarrays use. Different sigil, different energy, iykyk. 💅

Wanna actually learn Perl arrays? Go to <http://perldoc.perl.org/perldata.html> or run the command perldoc perldata. 📚

Hashes

Perl hashes? They're giving Scilab's structure arrays, fr fr:

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', myndarray => ones(3,3,3) )
pdl> $drink{type} = 'sprite'
pdl> $drink{price} = 12   # Add new field to hash.

And the sigil lore continues 🎀: Perl hashes start with the % prefix, instead of the @ for arrays and the $ that ndarrays use. Three sigils, three whole personalities.

Wanna learn Perl hashes? Same deal — <http://perldoc.perl.org/perldata.html> or the command perldoc perldata. 🌸

---

Performance

PDL has powerful performance features, and some of them literally aren't even a thing in normal numerical computation tools. The following pages will walk you through them bestie, one by one: 👑

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 and make your program more efficient. No more waiting around for loops, we're speeding this up. 🔥

PDL::Broadcasting

Level: Intermediate

PDL's "vectorization" feature goes beyond what most numerical software can even do. In this tutorial you'll learn how to "broadcast" over higher dimensions, which lets you vectorize your program further than is possible in Scilab. It's giving main character energy, honestly. ✨

Benchmarks

Level: Intermediate

Perl comes with an easy to use benchmarks module that helps you find out how long it takes to execute different parts of your code. It is a great tool to help you focus your optimization efforts where they actually matter. 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. Ate and left no crumbs. 💅

---

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. Old but iconic, basically. 🧚

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. Glow up in progress. 🌈

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. Spin it, rotate it, live your truth. 🦋

---

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. Cute and functional, the dream. 🎀

---

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. So if this feature is important to you, you should probably keep a copy of Scilab around for that. No shame in keeping both, bestie. 💜

Real talk: this is one of those "just keep Scilab installed" situations. PDL's not gonna fake it for you.

---

💖 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/

---

And that's a wrap on the whole page, bestie 🫶 this was SCILAB(1p), shipped with perl v5.38.2 and dated 2024-04-10 — go forth and vectorize, you absolute icon 💅✨