I suspect that your version of
reduce() is compiled first, and then the
loadMacros() runs, running the contents of the macro files dynamically, so they are compiled second, overriding your version. But I haven't experimented to see if that is true.
As for passing the matrix, I don't think this is the way you want to do it. Here are some issues to think about. Suppose you have an array
@C = (1,2,3);
and then pass that to a function
sub Example {
my @M = @_;
...
}
Example(@C);
this means that you are actually passing the array by value, not by reference. That means the contents of the array
@C are passed as three parameters to the function, just as though you had entered
Example(1,2,3);
and
@M will get a copy of the original array. So if you change
@M in the subroutine, that doesn't change
@C. (Although you could return the array
@M and use
@C = Example(@C);
though that is not the most efficient approach.)
When you make your matrix as
@C = ([1,2],[3,4]);
this means that
@C is an array of references to arrays, so when you pass this to the subroutine
Example(@C);
you are passing the array by value, but the values passed are the references to the row arrays, so those references are copied, they still refer to the same rows. That means that if you did
$M[0][1] = 100;
that would change the 2 to a 100 in the
@C matrix. But if you did
($M[0],$M[1]) = ($M[1],$M[0]);
in the subroutine, that would
not exchange the rows in
@C
An alternative approach would be to use an array reference rather than an array, as in
$C = [[1,2],[3,4]];
Example($C);
In this case, you would use
$C->[0][1] rather than
$C[0][1] to get access to the 2 in the matrix. If you use
sub Example {
my $M = shift;
...
}
then you can use
$M->[$i][$j] within the subroutine, and if you do
($M->[0],$M->[1]) = ($M->[1],$M->[0]);
this
will change
$C as well, because you have passed a
reference to the array of references (rather than passing all the row references by value).
It is also possible to pass a reference to @C. In Perl, you would use
Example(\@C);
but in PG, all backslashes are doubled, so that doesn't work. Instead, PG uses
~~ to get a single backslash (awkward, but that's how it works). So you could use
sub Example {
my $M = shift;
...
}
@C = ([1,2],[3,4]);
Example(\@C);
to pass the reference to
@C.
Hope that answers your question.
Davide
.