diff options
Diffstat (limited to 'Master/tlpkg/tlperl/lib/pods/perllol.pod')
-rw-r--r-- | Master/tlpkg/tlperl/lib/pods/perllol.pod | 388 |
1 files changed, 0 insertions, 388 deletions
diff --git a/Master/tlpkg/tlperl/lib/pods/perllol.pod b/Master/tlpkg/tlperl/lib/pods/perllol.pod deleted file mode 100644 index b35a0febb31..00000000000 --- a/Master/tlpkg/tlperl/lib/pods/perllol.pod +++ /dev/null @@ -1,388 +0,0 @@ -=head1 NAME - -perllol - Manipulating Arrays of Arrays in Perl - -=head1 DESCRIPTION - -=head2 Declaration and Access of Arrays of Arrays - -The simplest two-level data structure to build in Perl is an array of -arrays, sometimes casually called a list of lists. It's reasonably easy to -understand, and almost everything that applies here will also be applicable -later on with the fancier data structures. - -An array of an array is just a regular old array @AoA that you can -get at with two subscripts, like C<$AoA[3][2]>. Here's a declaration -of the array: - - use 5.010; # so we can use say() - - # assign to our array, an array of array references - @AoA = ( - [ "fred", "barney", "pebbles", "bambam", "dino", ], - [ "george", "jane", "elroy", "judy", ], - [ "homer", "bart", "marge", "maggie", ], - ); - say $AoA[2][1]; - bart - -Now you should be very careful that the outer bracket type -is a round one, that is, a parenthesis. That's because you're assigning to -an @array, so you need parentheses. If you wanted there I<not> to be an @AoA, -but rather just a reference to it, you could do something more like this: - - # assign a reference to array of array references - $ref_to_AoA = [ - [ "fred", "barney", "pebbles", "bambam", "dino", ], - [ "george", "jane", "elroy", "judy", ], - [ "homer", "bart", "marge", "maggie", ], - ]; - say $ref_to_AoA->[2][1]; - bart - -Notice that the outer bracket type has changed, and so our access syntax -has also changed. That's because unlike C, in perl you can't freely -interchange arrays and references thereto. $ref_to_AoA is a reference to an -array, whereas @AoA is an array proper. Likewise, C<$AoA[2]> is not an -array, but an array ref. So how come you can write these: - - $AoA[2][2] - $ref_to_AoA->[2][2] - -instead of having to write these: - - $AoA[2]->[2] - $ref_to_AoA->[2]->[2] - -Well, that's because the rule is that on adjacent brackets only (whether -square or curly), you are free to omit the pointer dereferencing arrow. -But you cannot do so for the very first one if it's a scalar containing -a reference, which means that $ref_to_AoA always needs it. - -=head2 Growing Your Own - -That's all well and good for declaration of a fixed data structure, -but what if you wanted to add new elements on the fly, or build -it up entirely from scratch? - -First, let's look at reading it in from a file. This is something like -adding a row at a time. We'll assume that there's a flat file in which -each line is a row and each word an element. If you're trying to develop an -@AoA array containing all these, here's the right way to do that: - - while (<>) { - @tmp = split; - push @AoA, [ @tmp ]; - } - -You might also have loaded that from a function: - - for $i ( 1 .. 10 ) { - $AoA[$i] = [ somefunc($i) ]; - } - -Or you might have had a temporary variable sitting around with the -array in it. - - for $i ( 1 .. 10 ) { - @tmp = somefunc($i); - $AoA[$i] = [ @tmp ]; - } - -It's important you make sure to use the C<[ ]> array reference -constructor. That's because this wouldn't work: - - $AoA[$i] = @tmp; # WRONG! - -The reason that doesn't do what you want is because assigning a -named array like that to a scalar is taking an array in scalar -context, which means just counts the number of elements in @tmp. - -If you are running under C<use strict> (and if you aren't, why in -the world aren't you?), you'll have to add some declarations to -make it happy: - - use strict; - my(@AoA, @tmp); - while (<>) { - @tmp = split; - push @AoA, [ @tmp ]; - } - -Of course, you don't need the temporary array to have a name at all: - - while (<>) { - push @AoA, [ split ]; - } - -You also don't have to use push(). You could just make a direct assignment -if you knew where you wanted to put it: - - my (@AoA, $i, $line); - for $i ( 0 .. 10 ) { - $line = <>; - $AoA[$i] = [ split " ", $line ]; - } - -or even just - - my (@AoA, $i); - for $i ( 0 .. 10 ) { - $AoA[$i] = [ split " ", <> ]; - } - -You should in general be leery of using functions that could -potentially return lists in scalar context without explicitly stating -such. This would be clearer to the casual reader: - - my (@AoA, $i); - for $i ( 0 .. 10 ) { - $AoA[$i] = [ split " ", scalar(<>) ]; - } - -If you wanted to have a $ref_to_AoA variable as a reference to an array, -you'd have to do something like this: - - while (<>) { - push @$ref_to_AoA, [ split ]; - } - -Now you can add new rows. What about adding new columns? If you're -dealing with just matrices, it's often easiest to use simple assignment: - - for $x (1 .. 10) { - for $y (1 .. 10) { - $AoA[$x][$y] = func($x, $y); - } - } - - for $x ( 3, 7, 9 ) { - $AoA[$x][20] += func2($x); - } - -It doesn't matter whether those elements are already -there or not: it'll gladly create them for you, setting -intervening elements to C<undef> as need be. - -If you wanted just to append to a row, you'd have -to do something a bit funnier looking: - - # add new columns to an existing row - push @{ $AoA[0] }, "wilma", "betty"; # explicit deref - -Prior to Perl 5.14, this wouldn't even compile: - - push $AoA[0], "wilma", "betty"; # implicit deref - -How come? Because once upon a time, the argument to push() had to be a -real array, not just a reference to one. That's no longer true. In fact, -the line marked "implicit deref" above works just fine--in this -instance--to do what the one that says explicit deref did. - -The reason I said "in this instance" is because that I<only> works -because C<$AoA[0]> already held an array reference. If you try that on an -undefined variable, you'll take an exception. That's because the implicit -derefererence will never autovivify an undefined variable the way C<@{ }> -always will: - - my $aref = undef; - push $aref, qw(some more values); # WRONG! - push @$aref, qw(a few more); # ok - -If you want to take advantage of this new implicit dereferencing behavior, -go right ahead: it makes code easier on the eye and wrist. Just understand -that older releases will choke on it during compilation. Whenever you make -use of something that works only in some given release of Perl and later, -but not earlier, you should place a prominent - - use v5.14; # needed for implicit deref of array refs by array ops - -directive at the top of the file that needs it. That way when somebody -tries to run the new code under an old perl, rather than getting an error like - - Type of arg 1 to push must be array (not array element) at /tmp/a line 8, near ""betty";" - Execution of /tmp/a aborted due to compilation errors. - -they'll be politely informed that - - Perl v5.14.0 required--this is only v5.12.3, stopped at /tmp/a line 1. - BEGIN failed--compilation aborted at /tmp/a line 1. - -=head2 Access and Printing - -Now it's time to print your data structure out. How -are you going to do that? Well, if you want only one -of the elements, it's trivial: - - print $AoA[0][0]; - -If you want to print the whole thing, though, you can't -say - - print @AoA; # WRONG - -because you'll get just references listed, and perl will never -automatically dereference things for you. Instead, you have to -roll yourself a loop or two. This prints the whole structure, -using the shell-style for() construct to loop across the outer -set of subscripts. - - for $aref ( @AoA ) { - say "\t [ @$aref ],"; - } - -If you wanted to keep track of subscripts, you might do this: - - for $i ( 0 .. $#AoA ) { - say "\t elt $i is [ @{$AoA[$i]} ],"; - } - -or maybe even this. Notice the inner loop. - - for $i ( 0 .. $#AoA ) { - for $j ( 0 .. $#{$AoA[$i]} ) { - say "elt $i $j is $AoA[$i][$j]"; - } - } - -As you can see, it's getting a bit complicated. That's why -sometimes is easier to take a temporary on your way through: - - for $i ( 0 .. $#AoA ) { - $aref = $AoA[$i]; - for $j ( 0 .. $#{$aref} ) { - say "elt $i $j is $AoA[$i][$j]"; - } - } - -Hmm... that's still a bit ugly. How about this: - - for $i ( 0 .. $#AoA ) { - $aref = $AoA[$i]; - $n = @$aref - 1; - for $j ( 0 .. $n ) { - say "elt $i $j is $AoA[$i][$j]"; - } - } - -When you get tired of writing a custom print for your data structures, -you might look at the standard L<Dumpvalue> or L<Data::Dumper> modules. -The former is what the Perl debugger uses, while the latter generates -parsable Perl code. For example: - - use v5.14; # using the + prototype, new to v5.14 - - sub show(+) { - require Dumpvalue; - state $prettily = new Dumpvalue:: - tick => q("), - compactDump => 1, # comment these two lines out - veryCompact => 1, # if you want a bigger dump - ; - dumpValue $prettily @_; - } - - # Assign a list of array references to an array. - my @AoA = ( - [ "fred", "barney" ], - [ "george", "jane", "elroy" ], - [ "homer", "marge", "bart" ], - ); - push $AoA[0], "wilma", "betty"; - show @AoA; - -will print out: - - 0 0..3 "fred" "barney" "wilma" "betty" - 1 0..2 "george" "jane" "elroy" - 2 0..2 "homer" "marge" "bart" - -Whereas if you comment out the two lines I said you might wish to, -then it shows it to you this way instead: - - 0 ARRAY(0x8031d0) - 0 "fred" - 1 "barney" - 2 "wilma" - 3 "betty" - 1 ARRAY(0x803d40) - 0 "george" - 1 "jane" - 2 "elroy" - 2 ARRAY(0x803e10) - 0 "homer" - 1 "marge" - 2 "bart" - -=head2 Slices - -If you want to get at a slice (part of a row) in a multidimensional -array, you're going to have to do some fancy subscripting. That's -because while we have a nice synonym for single elements via the -pointer arrow for dereferencing, no such convenience exists for slices. - -Here's how to do one operation using a loop. We'll assume an @AoA -variable as before. - - @part = (); - $x = 4; - for ($y = 7; $y < 13; $y++) { - push @part, $AoA[$x][$y]; - } - -That same loop could be replaced with a slice operation: - - @part = @{$AoA[4]}[7..12]; - -or spaced out a bit: - - @part = @{ $AoA[4] } [ 7..12 ]; - -But as you might well imagine, this can get pretty rough on the reader. - -Ah, but what if you wanted a I<two-dimensional slice>, such as having -$x run from 4..8 and $y run from 7 to 12? Hmm... here's the simple way: - - @newAoA = (); - for ($startx = $x = 4; $x <= 8; $x++) { - for ($starty = $y = 7; $y <= 12; $y++) { - $newAoA[$x - $startx][$y - $starty] = $AoA[$x][$y]; - } - } - -We can reduce some of the looping through slices - - for ($x = 4; $x <= 8; $x++) { - push @newAoA, [ @{ $AoA[$x] } [ 7..12 ] ]; - } - -If you were into Schwartzian Transforms, you would probably -have selected map for that - - @newAoA = map { [ @{ $AoA[$_] } [ 7..12 ] ] } 4 .. 8; - -Although if your manager accused you of seeking job security (or rapid -insecurity) through inscrutable code, it would be hard to argue. :-) -If I were you, I'd put that in a function: - - @newAoA = splice_2D( \@AoA, 4 => 8, 7 => 12 ); - sub splice_2D { - my $lrr = shift; # ref to array of array refs! - my ($x_lo, $x_hi, - $y_lo, $y_hi) = @_; - - return map { - [ @{ $lrr->[$_] } [ $y_lo .. $y_hi ] ] - } $x_lo .. $x_hi; - } - - -=head1 SEE ALSO - -L<perldata>, L<perlref>, L<perldsc> - -=head1 AUTHOR - -Tom Christiansen <F<tchrist@perl.com>> - -Last update: Tue Apr 26 18:30:55 MDT 2011 |