in reply to How to create a compact data structure?

Abstracting the hash helps play with different implementations. A pack/unpack and an array variant (commented out) are shown:

use warnings;
use strict;

my @large_list = (
    {key => 1, cond => 1},
    {key => 2, cond => 0},
    {key => 3, cond => 0},
    {key => 3, cond => 0},
    {key => 1, cond => 0},
    );

my $record = bless {};

for my $item (@large_list) {
    $record->add ($item);
}

for (sort keys %$record) {
    print "Item $_ count ", $record->getCount ($_), ', flag ', $record
+->getFlag ($_), "\n";
}


sub add {
    my ($self, $item) = @_;
    my $key = $item->{key};

    if (! exists $self->{$key}) {
        $self->{$key} = pack ('NN', 1, $item->{cond});
    } else {
        my ($count, $flag) = unpack ('NN', $self->{$key});
        $self->{$key} = pack ('NN', $count + 1, $flag || $item->{cond}
+);
    }
}


sub getFlag {
    return (unpack ('NN', $_[0]->{$_[1]}))[1];
}


sub getCount {
    return (unpack ('NN', $_[0]->{$_[1]}))[0];
}


#sub add {
#    my ($self, $item) = @_;
#    my $key = $item->{key};
#
#    if (! exists $self->{$key}) {
#        $self->{$key} = [1, $item->{cond}]
#    } else {
#        $self->{$key}[0]++;
#        $self->{$key}[1] ||= $item->{cond};
#    }
#}
#
#
#sub getFlag {
#    return $_[0]->{$_[1]}[1];
#}
#
#
#sub getCount {
#    return $_[0]->{$_[1]}[0];
#}

[download]

Prints:

Item 1 count 2, flag 1
Item 2 count 1, flag 0
Item 3 count 2, flag 0

[download]
DWIM is Perl's answer to Gödel

Replies are listed 'Best First'.
Re^2: How to create a compact data structure?
by GrandFather (Saint) on Dec 19, 2006 at 23:05 UTC

    Inspired by some of the other replies to the OP (especially samtregar's reply mentioning Devel::Size) here is a comparison of some of the techniques suggested:

    use warnings;
use strict;
use Devel::Size qw(total_size);

use warnings;
use strict;

my @large_list = (
    {key => 1, cond => 1},
    {key => 2, cond => 0},
    {key => 3, cond => 0},
    {key => 3, cond => 0},
    {key => 1, cond => 0},
    );

my $recordU = bless {};
my $recordA = bless {};
my $recordI = bless {};
my %record;

print "Empty sizes:\n";
print 'Packed: ', total_size ($recordU), "\n";
print 'Array:  ', total_size ($recordA), "\n";
print 'int:    ', total_size ($recordI), "\n";
print 'Hash:   ', total_size (\%record), "\n";

for my $item (@large_list) {
    $recordU->addU ($item);
    $recordA->addA ($item);
    $recordI->addI ($item);
    $record{$item->{key}}{count}++;
    $record{$item->{key}}{flag} ||= $item->{cond};
}

print "\nPopulated sizes:\n";
print 'Packed: ', total_size ($recordU), "\n";
print 'Array:  ', total_size ($recordA), "\n";
print 'int:    ', total_size ($recordI), "\n";
print 'Hash:   ', total_size (\%record), "\n";

for (sort keys %$recordU) {
    print "Item $_ count ", $recordU->getCountU ($_), ', flag ', $reco
+rdU->getFlagU ($_), "\n";
    print "Item $_ count ", $recordA->getCountA ($_), ', flag ', $reco
+rdA->getFlagA ($_), "\n";
    print "Item $_ count ", $recordI->getCountI ($_), ', flag ', $reco
+rdI->getFlagI ($_), "\n";
    print "Item $_ count ", $record{$_}{count}, ', flag ', $record{$_}
+{flag}, "\n";
}

    [download]
    Read more... methods (2 kB)

    Prints:

    Empty sizes:
Packed: 92
Array:  92
int:    92
Hash:   92

Populated sizes:
Packed: 260
Array:  497
int:    209
Hash:   682
Item 1 count 2, flag 1
Item 1 count 2, flag 1
Item 1 count 2, flag 1
Item 1 count 2, flag 1
Item 2 count 1, flag 0
Item 2 count 1, flag 0
Item 2 count 1, flag 0
Item 2 count 1, flag 0
Item 3 count 2, flag 0
Item 3 count 2, flag 0
Item 3 count 2, flag 0
Item 3 count 2, flag 0

    [download]
    DWIM is Perl's answer to Gödel
[reply]
[d/l]
[select]

In Section Seekers of Perl Wisdom