Provided by: pdl_2.085-1ubuntu1_amd64 
NAME
PDL::MATLAB - A guide for MATLAB users.
INTRODUCTION
If you are a MATLAB user, this page is for you. It explains the key differences between MATLAB 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 MATLAB and PDL.
Perl
The key differences between MATLAB and PDL are broadcasting, and Perl.
Broadcasting means you can get a reference to just a part of your data, and operate on it in a way that
makes sense for your application. Those operations will be reflected in the original data.
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 MATLAB 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: NDARRAY
MATLAB 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.
For more information, see "ndarrays vs Perl Arrays" later in this document.
COMMAND WINDOW AND IDE
Unlike MATLAB, 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 MATLAB, the
interactive shell is the best way to learn the language. To exit the shell, type "exit", just like
MATLAB.
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" 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.
use PDL::AutoLoader; # Import additional PDL module.
$y = pdl [2,3,4]; # Statements end in semicolon.
$A = pdl [ [1,2,3],[4,5,6] ]; # 2-dimensional matrix.
print $A x $y->transpose;
Save this file as "myprogram.pl" and run it with:
perl myprogram.pl
New: Flexible syntax
In current versions of PDL (version 2.4.7 or later) there is a flexible matrix syntax that can look
extremely similar to MATLAB:
1) Use spaces to separate elements:
$y = pdl q[ 2 3 4 ];
2) Use a ';' to delimit rows:
$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.
MODULES FOR MATLAB USERS
There are two modules that MATLAB users will want to use:
PDL::NiceSlice
Gives PDL a syntax for slices (sub-matrices) that is shorter and more familiar to MATLAB users.
% MATLAB
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.
PDL::AutoLoader
Provides a MATLAB-style autoloader for PDL. If an unknown function foo() is called, PDL looks for a
file called "foo.pdl". If it finds one, it reads it.
BASIC FEATURES
This section explains how PDL's syntax differs from MATLAB. Most MATLAB users will want to start here.
General "gotchas"
Indices
In PDL, indices start at '0' (like C and Java), not 1 (like MATLAB or FORTRAN). For example, if $y
is an array with 5 elements, the elements would be numbered from 0 to 4. This is different, but less
difficult as soon as you need to do calculations based on offsets.
Displaying an object
MATLAB normally displays object contents automatically. In the PDL shells you display objects
explicitly with the "print" command or the shortcut "p":
MATLAB:
>> a = 12
a = 12
>> b = 23; % Suppress output.
>>
PDL Shell (perldl or pdl2):
pdl> $x = 12 # No output.
pdl> print $x # Print object.
12
pdl> p $x # "p" is a shorthand for "print" in the shell.
12
pdl>
In pdl2 there is the "do_print" command that will toggle the "quiet" mode, which defaults to on. In
"print" mode, expressions you enter on the command line will have their values printed.
Creating ndarrays
Variables in PDL
Variables always start with the '$' sign.
MATLAB: value = 42
PerlDL: $value = 42
Basic syntax
Use the "pdl" constructor to create a new ndarray.
MATLAB: v = [1,2,3,4]
PerlDL: $v = pdl [1,2,3,4]
MATLAB: A = [ 1,2,3 ; 3,4,5 ]
PerlDL: $A = pdl [ [1,2,3] , [3,4,5] ]
Simple matrices
MATLAB PDL
------ ------
Matrix of ones ones(5) ones 5,5
Matrix of zeros zeros(5) zeros 5,5
Random matrix rand(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. Remember you may need to come back to your code, and parentheses make your
own (as well as others') comprehension easier.
Linearly spaced sequences
MATLAB: >> 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.
MATLAB 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. PDL and MATLAB have a similar
syntax for slicing, but there are two important differences:
1) PDL indices start at 0, as in C and Java. MATLAB starts indices at 1.
2) In MATLAB you think "rows and columns". In PDL, think "x and y".
MATLAB 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, if you want the "nice slice" syntax, you have to
include the PDL::NiceSlice module. See the previous section "MODULES FOR MATLAB USERS" for more
information.
use PDL; # Import main PDL module.
use PDL::NiceSlice; # Nice syntax for slicing.
use PDL::AutoLoader; # MATLAB-like autoloader.
$A = random 4,4;
print $A(0,1);
Matrix Operations
Matrix multiplication
MATLAB: A * B
PerlDL: $A x $B
Element-wise multiplication
MATLAB: A .* B
PerlDL: $A * $B
Transpose
MATLAB: A'
PerlDL: $A->transpose
Functions that aggregate data
Some functions (like "sum", "max" and "min") aggregate data for an N-dimensional data set. This is a
place where MATLAB and PDL take a different approach:
In MATLAB, these functions all work along one dimension.
>> A = [ 1,5,4 ; 4,2,1 ]
A = 1 5 4
4 2 1
>> max(A)
ans = 4 5 4
>> max(A')
ans = 5 4
If you want the maximum for the entire data set, you can use the special A(:) notation which
basically turns the entire data set into a single 1-dimensional vector.
>> max(A(:))
ans = 5
>> A = ones(2,2,2,2)
>> max(A(:))
ans = 1
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
pdl> p ones(2,2,2)->max
1
pdl> p ones(2,2,2,2)->max
1
Note Notice that PDL aggregates horizontally while MATLAB aggregates vertically. In other words:
MATLAB PerlDL
max(A) == $A->transpose->maximum
max(A') == $A->maximum
TIP: In MATLAB you think "rows and columns". In PDL, think "x and y".
Higher dimensional data sets
A related issue is how MATLAB and PDL understand data sets of higher dimension. MATLAB was designed for
1D vectors and 2D matrices. Higher dimensional objects ("N-D arrays") were added on top. In contrast, PDL
was designed for N-dimensional ndarrays from the start. This leads to a few surprises in MATLAB that
don't occur in PDL:
MATLAB sees a vector as a 2D matrix.
MATLAB PerlDL
------ ------
>> vector = [1,2,3,4]; pdl> $vector = pdl [1,2,3,4]
>> size(vector) pdl> p $vector->dims
ans = 1 4 4
MATLAB 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 MATLAB ignores the last dimension of a 4x1x1 matrix.
MATLAB 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 MATLAB treats a 4x1x1 matrix differently from a 1x1x4 matrix.
MATLAB 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
MATLAB 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 MATLAB, several features such as sparse matrix support 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.
Loop Structures
Perl has many loop structures, but we will only show the one that is most familiar to MATLAB users:
MATLAB PerlDL
------ ------
for i = 1:10 for $i (1..10) {
disp(i) print $i
endfor }
Note Never use for-loops for numerical work. Perl's for-loops are faster than MATLAB'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
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).
Conditionals
Perl has many conditionals, but we will only show the one that is most familiar to MATLAB users:
MATLAB 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":
MATLAB: 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 MATLAB's.
MATLAB 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. This helps you not accidentally use undeclared
variables, which is enforced if you "use strict". See strict for more.
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;
}
In more recent versions of Perl, you can "use signatures" for a different syntax for declaring function
parameters. See signatures for more.
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
ASCII File IO
To read data files containing whitespace separated columns of numbers (as would be read using the MATLAB
load command) one uses the PDL rcols in PDL::IO::Misc. For a general review of the IO functionality
available in PDL, see the documentation for PDL::IO, e.g., "help PDL::IO" in the pdl2 shell or " pdldoc
PDL::IO " from the shell command line.
Data structures
To create complex data structures, MATLAB uses "cell arrays" and "structure arrays". Perl's arrays and
hashes offer similar functionality but are more powerful and flexible. 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 MATLAB's cell arrays, but more flexible. For example, in MATLAB, a cell
array is still fundamentally a matrix. It is made of rows, and rows must have the same length.
MATLAB
------
array = {1, 12, 'hello'; rand(3, 2), ones(3), 'junk'}
=> OK
array = {1, 12, 'hello'; rand(3, 2), ones(3) }
=> ERROR
A Perl array is a general purpose, sequential data structure. It can contain any data type.
PerlDL
------
@array = ( [1, 12, 'hello'] , [ random(3,2), ones(3,3), 'junk' ] )
=> OK
@array = ( [1, 12, 'hello'] , [ random(3,2), ones(3,3) ] )
=> OK
@array = ( 5 , {'name' => 'Mike'} , [1, 12, 'hello'] )
=> OK
Notice that Perl array's start with the "@" prefix instead of the "$" used by ndarrays.
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 MATLAB's structure arrays:
MATLAB
------
>> drink = struct('type', 'coke', 'size', 'large', 'myarray', {1,2,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.
Notice that Perl hashes start with the "%" prefix instead of the "@" for arrays and "$" used by
ndarrays.
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
MATLAB. Use this page to learn how to avoid for-loops to make your program more efficient.
PDL::Broadcasting
Level: Intermediate
PDL's "vectorization" feature goes beyond what most numerical software can do. In this tutorial
you'll learn how to "broadcast" over higher dimensions, allowing you to vectorize your program
further than is possible in MATLAB.
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 MATLAB, 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.
Simulink
Simulink is a graphical dynamical system modeler and simulator. It can be purchased separately as an add-
on to MATLAB. PDL and Perl do not have a direct equivalent to MATLAB's Simulink. If this feature is
important to you, then take a look at Scilab:
<http://www.scilab.org>
Scilab is another numerical analysis software. Like PDL, it is free and open source. It doesn't have
PDL's unique features, but it is very similar to MATLAB. Scilab comes with Xcos (previously Scicos), a
graphical system modeler and simulator similar to Simulink.
COMPARISON: REPEATED COPY OF MATRIX
In MATLAB, the "repmat" function works like so:
> A = reshape(0:5, 3, 2)' # similar to PDL::sequence(3, 2)
ans =
0 1 2
3 4 5
> repmat(A, 2, 3) # double rows, triple columns
ans =
0 1 2 0 1 2 0 1 2
3 4 5 3 4 5 3 4 5
0 1 2 0 1 2 0 1 2
3 4 5 3 4 5 3 4 5
This works (at least in Octave) at least up to 3 dimensions.
The PDL analog:
sub repmat {
my $f=shift;
my @n=@_; #number of repetitions along dimension
my $sl = join ',', map ":,*$_", @n; # insert right-size dummy after each real
my $r = $f->slice($sl); #result
$r = $r->clump($_, $_+1) for 0..$#n;
$r;
}
> p $x = sequence(3,2)
[
[0 1 2]
[3 4 5]
]
> p repmat($x, 3, 2) # triple columns, double rows
[
[0 1 2 0 1 2 0 1 2]
[3 4 5 3 4 5 3 4 5]
[0 1 2 0 1 2 0 1 2]
[3 4 5 3 4 5 3 4 5]
]
COMPARISON: FLOYD-WARSHALL ALGORITHM
In graph theory <https://en.wikipedia.org/wiki/Graph_theory>, an apparently-simple but difficult problem
is the "shortest path" problem, of finding the shortest path between any two nodes. A famous solution to
this, albeit expensive (it is O(V^3) where "V" is the number of vertices) is the Floyd-Warshall
algorithm, which iterates through all the possible paths.
Both the MATLAB solution and the PDL solution use vectorisation, so hopefully this is a useful
comparison. The MATLAB version started with the code in code by Giorgos Dim
<https://uk.mathworks.com/matlabcentral/fileexchange/67503-floyd-warshall-vectorized>, but modified as
that code produces an incorrect path matrix.
Sample data (reflected on both the Wikipedia page, and the Rosetta Code website) for the weighted-edges
matrix is, in PDL format:
my $we = pdl q[
[Inf Inf -2 Inf]
[ 4 Inf 3 Inf]
[Inf Inf Inf 2]
[Inf -1 Inf Inf]
];
and in MATLAB format:
A = [0 Inf -2 Inf; 4 0 3 Inf; Inf Inf 0 2; Inf -1 Inf 0]
PDL version
To solve for only distances without capturing the shortest actual paths:
$we .= $we->hclip($we->mslice('X', $_) + $we->mslice($_, 'X'))
for 0..($we->dim(0)-1);
This loops over each possible intermediate point ("k" in the other literature), setting it to $_ (a Perl
idiom). It uses "hclip" in PDL::Primitive for vectorised calculation of the distance between the
intermediate point's predecessors and successors. Those are the two components of the addition
expression, using "slices" alluded to above. The ".=" is the PDL syntax for updating an ndarray.
To capture the shortest-path "next vertex" matrix as well:
use PDL::Lite;
my $d = $we->copy->inplace;
$d->diagonal(0, 1) .= 0;
my $suc = $we->copy->inplace;
my $adjacent_coords = PDL::whichND($we->isfinite);
$suc->indexND($adjacent_coords) .= $adjacent_coords->slice(0)->flat;
$suc->diagonal(0, 1) .= PDL::Basic::sequence($d->dim(0));
for (my $k = $d->dim(0)-1; $k >= 0; $k--) {
my $d_copy = $d->copy;
$d .= $d->hclip($d->mslice('X', $k) + $d->mslice($k, 'X'));
my $coords = PDL::whichND($d < $d_copy);
my $from_coords = $coords->copy->inplace;
$from_coords->slice(0) .= $k;
$suc->indexND($coords) .= $suc->indexND($from_coords);
}
The "diagonal" and "slice" expressions show how to update data via a query syntax.
MATLAB version
Path-lengths only:
function D = FloydWarshall(D)
for k = 1:length(D)
D = min(D,D(:,k) + D(k,:));
end
end
The path vertices-capturing as well:
function [D,P] = FloydWarshall(D)
P = D;
n = length(D);
coords = find(isfinite(P));
P(coords) = floor((coords-1) / n)+1; % the col in 1-based
for v = 1:n; P(v, v) = v; end
for k = 1:n
prevD = D;
D = min(D,D(:,k) + D(k,:));
coords = find(D<prevD);
from_coords = n * (k-1) + mod(coords-1, n) + 1; % change col to k in 1-based
P(coords) = P(from_coords);
end
end
By comparison, the lack of "broadcasting" means that to update the diagonal requires a for-loop, which in
the sphere of vectorised calculations is a bad thing. The calculations of coordinates are complicated by
the 1-based counting.
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/>
ACKNOWLEDGEMENTS
I'd like to thank David Mertens, Chris Marshall and Sigrid Carrera for their immense help reviewing
earlier drafts of this guide. Without their hours of work, this document would not be remotely as useful
to MATLAB users as it is today.
perl v5.38.2 2024-04-10 MATLAB(1p)