You'll want to read perldata, perllol and perldsc (and maybe perlref and perlreftut for good measure :)

What you'll want to do is make a reference to a list of a list (of a list of a list ... etc.) For example:

my $array_1 = [ 1, 2, 3 ];   # 1d
my $array_2 = [ [1, 2, 3], [1, 2, 3], [1, 2, 3] ]; #2d
my $array_3 = [
  [ [1, 2, 3], [1, 2, 3], [1, 2, 3] ],
  [ [1, 2, 3], [1, 2, 3], [1, 2, 3] ],
  [ [1, 2, 3], [1, 2, 3], [1, 2, 3] ],
];                                           # 3d
... etc.
[download]

which can be extended to however many dimensions you want. Using an array ref makes things easy because you can just pass $array_1, $array_2, $array_3 around as you would any ol' scalar. A specific cell in your n-dimensional array can be referenced as:

$array_1->[$x];
$array_2->[$x][$y];
$array_3->[$x][$y][$z];
... etc.
[download]

Or, by "fixed dimensions" do you mean that your n-dimensional array is of a pre-determined size? In that case you can always use the old trick of storing everything in a single array with a pre-declared length and calculating every element's position (see your favorite algorithms/data structures book for details.)

update: I forgot to mention, if your n-dimensional array is sparsely populated, you might look into using a hash and "multidimensional array emulation".

my %array = ();
$array{$x1,$y1,$z1} = something;
$array{$x2,$y2,$z2} = something else;
...
[download]

Obviously this is Terribly Bad if you need to loop around your array and, frankly, I've never had much use for this, but I thought I should bring it up in case it happens to work for you ...

You can't define a Perl array to have certain number of dimensions, or a certain number of elements. This is because of a (generally very useful) feature called autovivification. This means that you could just write code like:

my @arr;

$arr[0][1][2][3] = 4;
[download]

And suddenly you have a four dimensional array where the first dimension has one element, the second two and so on. The element that you haven't given values to will have the special value undef.

And as for passing multidimensional structures like this to a subroutine, you're better off doing it with references. See perlreftut, perllol and perldsc for more details.

"Perl makes the fun jobs fun
and the boring jobs bearable" - me

@TDArray = (["Flange", "Widget"],
            ["Gerbal","Twaddle]);

#Prints Flange
print $TDArray[0][0];
[download]

$count = @array;
or
$count = scalar @array;
[download]

#/usr/bin/perl
$nx=10;
$ny=5;

$initialisation = 0;

foreach $i (0..$nx) {
   foreach $j (0..$ny) {
      $a[$i][$j] = $initialisation;
   }
}

$a[1][1] = 2;

&subro($nx,\@a,$ny);

sub subro($nx,\@a,$ny) {

my $nx = shift;
my @a = @{shift}; #should be wrong...
my $ny = shift;

print "$a[1][1]\n";
print "$nx\n";
print "$ny\n";

}
[download]

@{shift} may means @{'shift'} or @shift : it's ambiguous.

be more sharp by adding "()" after shift.


...
my $nx = shift;
my @a = @{shift()}; # This should resolve your problem
my $ny = shift;
...
[download]

________________________
Hope this helps

Thanks, Now it works.
It would be nice for me to have a general subroutine


sub initialise(\@dimensions,$initialisation_value,\@matrix)
[download]

that gives back an initalised matrix of n-dimensions. I'll try as learning exercise, if it is not straightforward for someone to write it down here. There's a lot to learn from a snippet of code..:)
rob