How about this? I'm not going into details, but basically if you represent your matrices as two-dimensional arrays (here I'm actually using array references), it's pretty straightforward to do the job.

I've coded standard deviation from memory so you might do well to check up the formula elsewhere - my memory is that you divide by (n - 1) rather than n (and here, "@matrices" evaluated in a scalar context will be n - the number of tables you're performing statistics over).

I'm loading the tables from the __DATA__ segment; should be obvious how to modify it to use stdin, a collection of files, or whatever. Have assumed that all of your tables will say 1..9 and 1..6 in their row/column labels.

There's loads of stuff to say on numerical accuracy when calculating means, but if you're using Perl to do the job I assume you don't care too much - the accuracy problems arise on pretty odd data sets anyway and aren't likely to be a problem.

To understand all of the [ foo ] and $x->[][] stuff, I recommend that you read the Perl documentation on references.

Hope this helps.

#!/usr/bin/perl -w

use strict;

# Convert your data format to a 2-d array
sub to_matrix($) {
  [ map [ split /,/ ], split /\n/, shift ]
}

# Convert a 2-d array to your data format
sub from_matrix($) {
  join("\n", map join(",", @$_), @{$_[0]}) . "\n";
}

# Read in matrices
$/ = "\n\n";
my @matrices = map to_matrix($_), <DATA>;

# Compute mean/std.dev
my $mean = [ [ "mean" ] ];
my $standard_deviation = [ [ "standard deviation" ] ];
$mean->[0][$_] = $standard_deviation->[0][$_] = $_ for 1 .. 6;
$mean->[$_][0] = $standard_deviation->[$_][0] = $_ for 1 .. 9;
for my $row (1 .. 9) {
  for my $column (1 .. 6) {
    my $sum = 0;
    my $sum_of_squares = 0;
    for(@matrices) {
      my $datum = $_->[$row][$column];
      $sum += $datum;
      $sum_of_squares += $datum * $datum;
    }
    $mean->[$row][$column] = $sum / @matrices;
    $standard_deviation->[$row][$column] = sqrt(($sum_of_squares -
        $sum * $sum / @matrices) / (@matrices - 1));
  }
}

print from_matrix($mean), "\n", from_matrix($standard_deviation);

__DATA__
units,1,2,3,4,5,6
1,5,0,0,0,0,0
2,0,0,0,0,0,0
3,0,0,1,1,0,0
4,0,4,0,0,0,0
5,0,3,0,0,0,0
6,0,0,0,0,0,0
7,0,0,0,0,0,0
8,0,0,0,0,0,0
9,1,0,0,0,0,0

blah,1,2,3,4,5,6
1,6,0,0,0,0,0
2,0,0,0,0,0,0
3,0,0,1,1,0,0
4,0,4,0,0,0,0
5,0,3,0,0,0,0
6,0,0,0,0,0,0
7,0,0,0,0,0,0
8,0,0,0,0,0,0
9,1,0,0,0,0,3

foo,1,2,3,4,5,6
1,7,0,0,0,0,0
2,0,0,0,0,0,0
3,0,0,1,1,0,0
4,0,4,0,0,0,0
5,0,3,0,0,0,0
6,0,0,0,0,0,0
7,0,0,0,0,0,0
8,0,0,0,0,0,0
9,1,0,0,0,0,2
[download]

That works very nicely, thanks!

Although I'm not a statistic expert, I think you should have a look a PDL module, that provide very useful Perl interface to vector and matrix operations.

HTH

There is also (now) PDL::Stats by the mighty Maggie X.

Anyways, I went to cpan, and searched for "statistics', and Statistics-Basic looks like a possibility for you. Matrices can be looked at like a collection of vectors, so you may be able to use this as an approach.

Anyways, your question is a big one, and I wouldn't expect a simple solution where you just drop in your matrices, and have correct answers pop out.

@tables = ('csv_1', 'csv_2', ..., 'csv_n');
# or a directorylist to get all csv files in your directory

$num_types = 6;
$num_lengths = 9;

for $table (0 .. $#tables) {

     #parse file into 2-d list
     open(FILE, $tables[$table]);
     while($line = <FILE>) {
          @line_parts = split(/delimiter/, $line);
          push @this_table, [ @line_parts ];
     }
     close(FILE);

     #keep a running total of counts for each position
     for $length (1 .. $num_lengths) {
          for $type (1 .. $num_types) {
               $totals[$length][$type] = $totals[$length][$type] + $th
+is_table[$length-1][$type-1];
               $totals_squared[$length][$type] = $totals_squared[$leng
+th][$type] + ($this_table[$length-1][$type-1]^2);
          }
     }
}

#you now have everything you need to calcluate mena and sd for every p
+osition
for $i (0 .. $#totals) {
     for $j (0 .. $#{$totals[$i]}) { #check syntax!
          $mean = $totals[$i][$j]/$#tables;
          $sd = sqrt( ($totals_squared[$i][$j] -($totals[$i][$j]^s/$#t
+ables))/ ($#tables-1) )
          #note that this considers the data as a 'sample'.  
          #If it is to be considered a 'population', then replace "$#t
+ables-1" with $#tables
     }
}
[download]

I see I type too slowly.....

Are you suggesting something like loading the first line of every table into an array, and performing a calculation upon that, then the next line, &c.? I might have a go at that.
Conrad's method seems to be working well enough for now. To determine accuracy I printed out a few select cells thus:

# @names is a list of file names, and I've created a matrix
# named after each file...
my $x = 3;
my $y = 3;
my @one;
print "one <- data.frame(a=c(";
foreach my $name (@names) {
  push (@one, @{$name}[$x]->[$y]);
}
print join(",", @one), "))\n";
[download]

This provides a data frame one can stick into R and run mean(one) or sd(one), which for the examples I tested showed that conrad's results were accurate enough for my purposes. I must also compare punch_card_don's when I get an opportunity.