2. As originally posted, your code is first looping over the "foo" keys (in whatever random order perl is using to return that set of hash keys, which differs from one run to the next), and then only the "ba" keys are being sorted according to the values tied to each key.

Other monks can probably provide a more elegant solution, but here's the first thing that comes to mind, sticking as close as possible to the OP code:

#!/usr/bin/perl -w
use strict;

my %hoh_test;

$hoh_test{foo1}{bar} = -0.12697;
$hoh_test{foo1}{baz} = -0.000398154;
$hoh_test{foo2}{bar} = -4.0183e-05;
$hoh_test{foo2}{baz} = 0;
$hoh_test{foo3}{bar} = 9.966003977e-06;
$hoh_test{foo3}{baz} = 0.0001939;

# sort descending by value
my %sorter;
foreach my $foo (keys(%hoh_test))
{
    foreach my $ba (sort {$hoh_test{$foo}{$b} <=> $hoh_test{$foo}{$a}}
+ keys(%{$hoh_test{$foo}}))
    {
        push @{$sorter{$hoh_test{$foo}{$ba}}}, [ $foo, $ba ];
    }
}

foreach my $val (sort {$a<=>$b} keys %sorter)
{
    foreach my $keys ( @{$sorter{$val}} ) {
        print "foo: $$keys[0], ba: $$keys[1], value: $hoh_test{$$keys[
+0]}{$$keys[1]}\n";
    }
}
[download]

foo: foo1, ba: bar, value: -0.12697
foo: foo1, ba: baz, value: -0.000398154
foo: foo2, ba: bar, value: -4.0183e-05
foo: foo2, ba: baz, value: 0
foo: foo3, ba: bar, value: 9.966003977e-06
foo: foo3, ba: baz, value: 0.0001939
[download]

ANOTHER UPDATE: (Silly me...) I realized that I was sticking too close to the OP code... no sorting is required in the first (nested) for loop -- here's the code again, without the unnecessary sort, and with sort direction corrected:

#!/usr/bin/perl -w
use strict;

my %hoh_test;

$hoh_test{foo1}{bar} = -0.12697;
$hoh_test{foo1}{baz} = -0.000398154;
$hoh_test{foo2}{bar} = -4.0183e-05;
$hoh_test{foo2}{baz} = 0;
$hoh_test{foo3}{bar} = 9.966003977e-06;
$hoh_test{foo3}{baz} = 0.0001939;

# sort descending by value
my %sorter;
foreach my $foo (keys(%hoh_test))
{
    foreach my $ba (keys(%{$hoh_test{$foo}}))
    {
        push @{$sorter{$hoh_test{$foo}{$ba}}}, [ $foo, $ba ];
    }
}

foreach my $val (sort {$b<=>$a} keys %sorter)
{
    foreach my $keys ( @{$sorter{$val}} ) {
        print "foo: $$keys[0], ba: $$keys[1], value: $hoh_test{$$keys[
+0]}{$$keys[1]}\n";
    }
}
[download]

G'day Special_K,

Your basic problem is not taking into account the fact that hashes are unordered. You'll get foo1, foo2 & foo3 returned in a random order when you call keys %hoh_test; and, for each of those, you'll get bar & baz returned in a random order when you call keys %{$hoh_test{$foo}}.

Here's my take on a solution:

#!/usr/bin/env perl

use strict;
use warnings;

my %hoh_test = (
    foo1 => { bar => -0.12697, baz => -0.000398154 },
    foo2 => { bar => -4.0183e-05, baz => 0 },
    foo3 => { bar => 9.966003977e-06, baz => 0.0001939 },
);

my @hoh_data;

for my $k0 (keys %hoh_test) {
    for my $k1 (keys %{$hoh_test{$k0}}) {
        push @hoh_data, [$k0, $k1, $hoh_test{$k0}{$k1}];
    }
}

my $fmt = "foo: %s, ba: %s, value: %s\n";
printf $fmt, @$_ for sort { $b->[2] <=> $a->[2] } @hoh_data;
[download]

This produces the same output on each run:

foo: foo3, ba: baz, value: 0.0001939
foo: foo3, ba: bar, value: 9.966003977e-06
foo: foo2, ba: baz, value: 0
foo: foo2, ba: bar, value: -4.0183e-05
foo: foo1, ba: baz, value: -0.000398154
foo: foo1, ba: bar, value: -0.12697
[download]

Just to exemplify the unordered nature of hashes, here's what @hoh_data looked like, on two separate runs, before passing to sort { $b->[2] <=> $a->[2] }:

(
  ["foo1", "bar", -0.12697],
  ["foo1", "baz", -0.000398154],
  ["foo2", "baz", 0],
  ["foo2", "bar", -4.0183e-05],
  ["foo3", "baz", 0.0001939],
  ["foo3", "bar", 9.966003977e-06],
)
[download]

(
  ["foo1", "baz", -0.000398154],
  ["foo1", "bar", -0.12697],
  ["foo3", "baz", 0.0001939],
  ["foo3", "bar", 9.966003977e-06],
  ["foo2", "bar", -4.0183e-05],
  ["foo2", "baz", 0],

)
[download]

Update: Well, I made a real mess of keys %{hoh_test($foo}}. Now fixed: keys %{$hoh_test{$foo}}.

If your amount of data is sort of limited and fits into RAM, the answer by by graff is the way to go. If the data gets bigger, or more complex, or you also start needing more complex sorting/filtering, or you start running into performance problems, you might want to look at using a proper SQL database. For example, PostgreSQL is free, and Perl has excellent support through DBI/DBD::Pg.

Modern databases are super optimized to deal with exactly those kinds of problems. Plus, with PostgreSQL you get the benefit that you can implement server side smarts in Perl (among other programming languages).

If I read your code correctly, only the inner loop on $ba is sorting on values. Hash keys are not returned in a specific order, so your $foo keys may be all over the place. But your expected output really looks to be sorting on key $foo, then on $ba, so I'm not sure "sorting on values" is you are asking. If it is, I would expect the following code snippet to generate your expected output:

use strict;
use warnings;
my %hoh_test = (
    foo1 => { bar => -0.12697, baz => -0.000398154, },
    foo2 => { bar => -4.0183e-05, baz => 0, },
    foo3 => { bar => 9.966003977e-06, baz => 0.0001939, },
);
# Sort on $foo decending
foreach my $foo ( sort { $b cmp $a } keys %hoh_test ) {
    # Sort on values decending
    foreach my $ba ( 
            sort { $hoh_test{$foo}{$b} <=> $hoh_test{$foo}{$a} } 
            keys %{$hoh_test{$foo}} 
    ) {
        printf "foo: %s, ba: %s, value: %s\n", 
               $foo, 
               $ba, 
               $hoh_test{$foo}{$ba};
    }
}
[download]

The output matches your expected output:

If instead you are sorting on $foo decending then on $ba decending, the code would instead be:

use strict;
use warnings;
my %hoh_test = (
    foo1 => { bar => -0.12697, baz => -0.000398154, },
    foo2 => { bar => -4.0183e-05, baz => 0, },
    foo3 => { bar => 9.966003977e-06, baz => 0.0001939, },
);
# Sort on $foo decending
foreach my $foo ( sort { $b cmp $a } keys %hoh_test ) {
    # Sort on $ba decending
    foreach my $ba ( sort { $b cmp $a } keys %{$hoh_test{$foo}} ) {
        printf "foo: %s, ba: %s, value: %s\n", 
               $foo, 
               $ba, 
               $hoh_test{$foo}{$ba};
    }
}
[download]

This output also matches your expected output:

If you really want your hash output sorted by values, there may be other ways but the simplest that comes to my mind is to push the order into a temporary structure you can actually sort:

use strict;
use warnings;
use utf8;

my %hoh_test = (
    foo1 => { bar => -0.12697,        baz => -0.000398154, },
    foo2 => { bar => -4.0183e-05,     baz => 0, },
    foo3 => { bar => 9.966003977e-06, baz => 0.0001939, },
);

# Sort on values by pushing into an intermediary structure
my @ordering;
foreach my $foo ( keys %hoh_test ) {
    foreach my $ba ( keys %{ $hoh_test{$foo} } ) {
        push @ordering, { foo => $foo, ba => $ba, v => $hoh_test{$foo}
+{$ba}, };
    }
}
# Sort intermediary structure on value (v) from above.
foreach my $i ( sort { $ordering[$b]{v} <=> $ordering[$a]{v} } 0 .. $#
+ordering ) {
    printf "foo: %s, ba: %s, value: %s\n", 
            $ordering[$i]{foo}, 
            $ordering[$i]{ba}, 
            $ordering[$i]{v};
}
[download]

This also creates your expected output:

Hope that helps.

I first approached this by forming a "flattened" intermediate hash where the first and second level keys were joined with a NUL character. The keys of the new hash could then be sorted by the associated descending numeric values then used for the printf statement. This code

use strict;
use warnings;

my %hoh_test = (
   foo1 => { bar => -0.12697,        baz => -0.000398154, },
   foo2 => { bar => -4.0183e-05,     baz => 0, },
   foo3 => { bar => 9.966003977e-06, baz => 0.0001939, },
   );

my %flatter =
   map {
       my $k1 = $_;
       map {
           join( qq{\0}, $k1, $_ ), $hoh_test{ $k1 }->{ $_ }
       }
       keys %{ $hoh_test{ $k1 } };
   }
   keys %hoh_test;

my @sortedKeys =
   sort { $flatter{ $b } <=> $flatter{ $a } }
   keys %flatter;

printf qq{foo: %s, ba: %s, value: %s\n},
   split( m{\0}, $_ ), $flatter{ $_ }
   for @sortedKeys;
[download]

produces

foo: foo3, ba: baz, value: 0.0001939
foo: foo3, ba: bar, value: 9.966003977e-06
foo: foo2, ba: baz, value: 0
foo: foo2, ba: bar, value: -4.0183e-05
foo: foo1, ba: baz, value: -0.000398154
foo: foo1, ba: bar, value: -0.12697
[download]

This seemed a bit long-winded so I thought it might be possible to still use combined keys but mapping out array refs to perform an ST all in one fell swoop. This code

use strict;
use warnings;

my %hoh_test = (
   foo1 => { bar => -0.12697,        baz => -0.000398154, },
   foo2 => { bar => -4.0183e-05,     baz => 0, },
   foo3 => { bar => 9.966003977e-06, baz => 0.0001939, },
   );

printf qq{foo: %s, ba: %s, value: %s\n}, @{ $_ } for
   map  { [ split( m{\0}, $_->[ 0 ] ), $_->[ 1 ] ] }
   sort { $b->[ 1 ] <=> $a->[ 1 ] }
   map  {
        my $k1 = $_;
        map {
            [ join( qq{\0}, $k1, $_ ), $hoh_test{ $k1 }->{ $_ } ]
        }
        keys %{ $hoh_test{ $k1 } };
   }
   keys %hoh_test;
[download]

produces identical output. I hope this is of interest.

Update: Corrected typo, s/tha/the/