Using the Math::Matrix package (or PDL, for that matter) would prevent zdog from the learning experience of doing it himself.

There are many valid reasons to reinvent the wheel: One reason is to understand how the wheel works.

And part of understanding how the wheel works is to make sure you are familiar with the existing art. We are trying to point out the similar solutions, so that the reinvention of the wheel can benefit all, not just make busy work for one person.

-- Randal L. Schwartz, Perl hacker

Suggestions subroutine by subroutine...

getmatrix: Pre-defining $input to 1 to prime the while, then checking for valid input at the bottom after you have read it is a little hard to understand. You could accomplish the same thing by making the read from <STDIN> as part of the while, with <while ($input = <STDIN>). That would allow you to eliminate the $input &&... at the end as well.

Going one step further, every use of $input at that point is in locations that default to $_, so you can eliminate it all together. I'd recommend, for clarity sake, also renaming @input to @matrix, since that's what it is.

sub getmatrix {
  my $what = shift;
  my @matrix;
  while (<STDIN>) {
    chop;
    if (/^0-9 ]/) die "Not a legal matrix row!\n"; }
    push @matrix, split / /;
  }
  return @matrix;
}
[download]

And I just noticed... ne is for string comparison, not numeric. Since you are dealing with numbers, use !=.

sub checkmatrix {
  my $rowlength = @$_[0];
  for (@_) {
    $rowlength == @$_ or die "Number of columns was not consistant!\n"
+;
  }
}
[download]

printmatrix: If that's how you want to format matrices, good enough for me. Not much to criticize here. (This included for completeness).

getdimen: This is really not clear what you are doing. Obviously, you wanted to get the number of rows and columns, but it seems a round-about way to get them. Especially the for loop with an unguarded last, meaning the loop will execute only once. Not clear at all. I'll do a total rewrite:

sub getdimen {
  my $rows = @_;      # get number of rows
  my $cols = @$_[0];  # get number of elems in first row
  return ($rows,$columns);
}
[download]

The other thing I'd do is make product responsible for validating it's arguments and extracting the info it needs directly, rather than expect it to be called in.

sub getproduct {
  my ($aref, $bref) = @_;
  my @a = @$aref; my @b = @$bref;
  my @product;
  checkmatrix(@a);
  checkmatrix(@b);
  my ($arow, $acol) = getdimen(@a);
  my ($brow, $bcol) = getdimen(@b);
  $acol == $brow or die "The matrices can't be multiplied!\n";

  for $i (0..$arow) {
    for $j (0..$bcol) {
      for $k (0..$acol) {
        $product[$i][$j] += $a[$i][$k] * $b[$k][$j];
      }
    }
  }
  return @product;
}
[download]

Perl is very good at having the features that DWIM when you need them to. Trying to go overboard with pushes, temp arrays, etc are not necessarily the way to go. As a general rule, I'd say that if you have to force it to do what you want, there might be an easier way...

Hope this helps...

You have the multiplication right. But one major comment. Checking that the matrixes look right is fairly time intensive. You really don't want that effort to be spent on every multiply. Likewise the dimensions. So this is a place where OO fits well. I won't provide that solution so zdog can have the experience of writing it.