By accumulating your float values as strings of packed values rather than arrays, 100,000 doubles requires only 800 kb instead of ~ 2.5 MB. Multiply that by the 36 vectors in your sample dataset and you reduce the memory requirement for processing 100,000 lines (35MB) from 350 MB to 50 MB with no loss of performance. It should now run on your 128 MB machine easily without swapping.

Original (tweaked) + results

Modified + results

Thus, when you parse your "Year" line, you know what variables you want the stats for - create one Statistics.. object for each, and from there on just add datapoints from each split.. also, I'd rather use an array - something like

#!/usr/bin/perl -lw
use strict;
use Statistics::Descriptive;

my $filename='224_APID003_report.csv';
open (READ_IN,"<$filename") or die "I can't open $filename to read.\n"
+;

my @idxs;
my %vars;
my @names;
while (<READ_IN>) {
    chomp;
    /^Year/ && do {
        @names = split /,/;
        @idxs = grep {$names[$_] !~ /TIME|YEAR/i } (0..@names-1);
        $vars{$_} = Statistics::Descriptive::Sparse->new() for @names[
+@idxs];
    };
    /^\d{4}/ && do {
        my @values = split /,/;
        $vars{$names[$_]}->add_data($values[$_]) for @idxs;
    };
}
close READ_IN or die $!;

foreach (keys %vars) {
    printf "%20s: mean = %10.4f, var = %10.4f\n",$_, $vars{$_}->mean()
+, $vars{$_}->variance();
}
[download]

btw, this is not tested, I might be writing rubbish...

update2: I am aware that the excessive use of $_ throughout this piece of code makes it more difficult to read than expanding all the loops. On the other hand, I think I'm way too attached to grep, map and inverse for, with their terseness... I might eventually write a meditation about Perl and Bulgarian language ..

Use meaningful names for your vars and subroutines. %HoA, %hash_keys, $pointer, parse_hash or create_hash are very bad names because they don't say anything about the data inside or what they do.

Don't use global variables (%hash_keys, %AoH) to pass or get data from subroutines.

Try to simplify your structures, deep object trees lead to difficult to understand code. Also thing about the proper type to use in every case. For instance, it makes no sense to use a hash to store a list of ordered values.

And finally, modules are good only when they simplify your problem, to calculate the mean and deviation you don't really need a module!

use strict;
use warnings;
no warnings 'uninitialized';

my (%count, %sum, %sum2, %min, %max, @key);

while(<>) {
  my (@val) = split /,/;
  if ($val[0]=~/^Year/) {
    @key = @val;
  }
  else {
    @key == @val
      or die "number of values and keys don't match"
    for my $i (0..$#key) {
      my $key = $key[$i];
      next if $key =~/Year|Time/;
      my $val = $val[$i];
      $count{$key} ++;
      $sum{$key} += $val;
      $sum2{$key} += $val*$val;
      $min{$key} = $val
        if (not defined $min{$key} or $val < $min{$key});
      $max{$key} = $val
        if (not defined $max{$key} or $val > $max{$key});
    }
  }
}

for my $key (sort keys %count) {
  my $count = $count{$key}
  my $sum = $sum{$key};
  my $mean = $sum/$count;
  my $deviation = sqrt($sum2{$key}/$count - $mean*$mean);
  printf("key: %s, mean: %f, deviation: %f, min: %f, max: %f",
         $key, $mean, $deviation,
         $min{$key}, $max{$key});
}
[download]

oh, and consider using Text::xSV or Text::CSV_XS for parsing CSV files.

ummm... so he shouldn't use modules to calculate various statistics of data vectors, because that's simple, but he should use a module to split on a comma for him.. that doesn't make sense to me..

Sorry, I don't mean to be bickering - in my opinion modules are useful whenever they make even a simple but repetitive task nice and short - more so, because they reduce the chance of an error...and occasionally I do get tired of writing the same code to get mean, variance, min, etc...

but he should use a module to split on a comma for him..

Parsing CSV files is not so simple as splitting on a comma, they can contain quoted data with commas inside or multiline records.

The code below doesn't add much to ivancho's very nice implementation++, except that I roll my own class to take care of the as-you-go computation of the desired statistics. (Good thing you didn't want the median!)

I thought it was a rare example of an OOP application that is both simple enough to be used as, say, a classroom illustration or a tutorial, and entirely useful "as is". Plus, it illustrates techniques that are being discussed in another thread.