PDL::Scilab(3pm)

📦

version 2.100 · 4 versions

2.100 · debian trixie, ubuntu questing (latest)
2.100.0 · fedora 43
2.100.0 · fedora 44
2.100 · ubuntu resolute

💅 NAME 💅

PDL::Scilab — A guide for Scilab users. This is the PDL::Scilab(3pm) page from User Contributed Perl Documentation, bestie, and it's here to help you settle into PDL without spiraling. 🫶

✨ INTRODUCTION ✨

Okay so if you're a Scilab user, this page is literally for you. It explains the key differences between Scilab and PDL so you can get going as quickly as possible. No cap.

This document is not a tutorial. For that, go to PDL::QuickStart. This document complements the Quick Start guide by highlighting the key differences between Scilab and PDL. It's giving "cheat sheet with main character energy." 💖

🐚 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 at http://perldoc.perl.org or through the command perldoc perl. There is also a beginner's portal at http://perl-begin.org. Slay. ✨

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: NDARRAY 🌸

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 "ndarray" to give a name to their data type.

An ndarray consists of a series of numbers organized as an N-dimensional data set. ndarrays provide efficient storage and fast computation of large N-dimensional matrices. They are highly optimized for numerical work. Iconic, honestly. 👑

For more information, see "ndarrays 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. 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 shell) 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.

$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 is a flexible matrix syntax that can look extremely similar to Scilab:

Use a ';' to delimit rows:

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

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 a syntax that is more comfortable for you. Obsessed with the flexibility, fr fr. 🧚

👑 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
$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). For example, if $y is an array with 5 elements, the elements would be numbered from 0 to 4. Lowkey important. Don't forget 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 🍓

                             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. Periodt. 💅

🧚 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:

PDL indices start at 0, as in C and Java. Scilab starts indices at 1.
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.

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 🦋

Okay so here's another lowkey huge thing: how Scilab and PDL actually see higher-dimensional data sets. Scilab was designed for 1D vectors and 2D matrices, with higher-dimensional objects kinda bolted on top later. PDL? Designed for N-dimensional ndarrays from the very start. So Scilab has a few surprises that just don't 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 sees [1,2,3,4] as a 2D matrix (a 1x4 matrix). PDL sees it as a 1D vector: a single dimension of size 4. Different vibes entirely. 💅

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 ndarrays is equally supported by N-dimensional ndarrays. 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 so many loop structures, but bestie, we're only gonna show the one that feels 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::Broadcasting, and PDL::PP.

Also: 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 🎀

It is important to note 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 allow you to create 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). tiny glow-up, huge readability win. ✨

💜 Conditionals 💜

Perl has many conditionals, but we're only showing 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                             }

Here's a "gotcha": Scilab: elseif PerlDL: elsif If your conditional gives a syntax error, check that you wrote your "elsif"s correctly. iykyk 😭

👑 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. iconic behavior honestly 🌈

🌸 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 of a function declaration in PDL:

"sub" stands for "subroutine".
"my" declares variables to be local to the function.
"@_" 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;
}

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) = @_;

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

💖 ADDITIONAL FEATURES 💖

Okay bestie, this is the good part — the stuff PDL can do that's gonna make you feel some type of way. Buckle up. 🎀

🌸 Data structures

So when you wanna build complex data structures in Scilab, you reach for lists and structs. And guess what — Perl's arrays and hashes do basically the same job. This section is literally just a lil appetizer of what Perl's got going on. If you want the full meal, go to http://perldoc.perl.org/perldata.html or just run the command perldoc perldata. iykyk 💅

✨ Arrays

Perl arrays are giving Scilab lists energy. Both of them are a sequential data structure that can hold any data type. Versatile queens 👑

Scilab:

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

PerlDL:

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

Quick vibe check: Perl arrays start with the @ prefix, not the $ that ndarrays use. Different sigil, different personality, no cap.

Wanna learn about Perl arrays? Go to http://perldoc.perl.org/perldata.html or run the command perldoc perldata. 🦋

✨ Hashes

Perl hashes are basically 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 %, which is not the @ used for arrays and definitely not the $ used by ndarrays. Three different little symbols living their best lives. 💀

Wanna learn about Perl hashes? You already know the drill: http://perldoc.perl.org/perldata.html or run perldoc perldata. 🫶

🔥 Performance

Okay so PDL has powerful performance features, and some of them are genuinely not the kind of thing you'd normally even find in numerical computation tools. The pages below are gonna walk you through all of it, bestie. Let's go.

👑 PDL::Indexing

Level: Beginner

This beginner tutorial covers the standard "vectorization" feature that you already know and love from Scilab. Read this one to learn how to dodge for-loops and make your program more efficient. Avoiding for-loops is literally self care. ✨

👑 PDL::Broadcasting

Level: Intermediate

PDL's "vectorization" feature goes beyond what most numerical software can do — like, it's not even close. In this tutorial you'll learn how to "broadcast" over higher dimensions, which means you can vectorize your program way further than is even possible in Scilab. Main character energy, honestly. 🔥

👑 Benchmarks

Level: Intermediate

Perl ships with an easy-to-use benchmarks module that helps you figure out how long it takes to execute different parts of your code. It's a great tool for focusing your optimization efforts (so you stop optimizing the thing that was already fast, we've all been there 🙈). You can read about it online at 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. Periodt. You write a function definition in special markup, and the pre-processor generates real C code which can then be compiled. So with PDL:PP you get the full speed of native C code without having to deal with the full complexity of the C language. That's the dream combo, honestly. 💜

🎨 Plotting

PDL has full-featured plotting abilities. The one thing that's different from Scilab: PDL leans more on third-party libraries (pgplot and PLplot) for its 2D plotting features. Its 3D plotting and graphics use OpenGL for performance and portability. And PDL has three main plotting modules:

🌈 PDL::Graphics::Simple

Best for: Plotting 2D functions and data sets.

Provides a simple library for line graphics and image display, giving you a uniform plotting interface to PGPLOT, PLplot, Gnuplot, and Prima. Uniform interface means you don't gotta relearn everything each time — we love convenience. 🎀

🌈 PDL::Graphics::PLplot

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

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

🌈 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. And with OpenGL, it's genuinely easy to manipulate the resulting 3D objects with the mouse in real time. Spin that thing, bestie. 🌀

🧚 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 on every platform. For example, the Perl IDE Padre is written with wxPerl. So like… it's proven, okay? 👑

💀 Xcos / Scicos

Xcos (formerly Scicos) is a graphical dynamical system modeler and simulator, and it's part of the standard Scilab distribution. Here's the tea: 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 drama — sometimes you just need both. 💖

📜 COPYRIGHT

See: http://dev.perl.org/licenses/

Aaaand that's the whole page, bestie! 🎉 This one came from PDL::Scilab(3pm), source/version perl v5.40.1, dated 2025-03-27. Go forth and vectorize responsibly. 💅✨

📦 where this page comes from

debian trixie: pdl 1:2.100-1 · Artistic-1.0-Perl OR GPL-1.0-or-later
ubuntu questing: pdl 1:2.100-1
💖 girlified by deepseek-ai/DeepSeek-V4.1-Flash-1017 on 2026-11-06: a language model's rewrite of the original, under its terms