Your skill will accomplishwhat the force of many cannot PerlMonks

### Re^5: High Performance Game of Life

by marioroy (Priest)
 on Aug 12, 2017 at 22:09 UTC ( #1197321=note: print w/replies, xml ) Need Help??

in reply to Re^4: High Performance Game of Life
in thread High Performance Game of Life

Update: pack 'i2' is more efficient than pack 'ii'

Organism.pm optimized with pack/unpack 'i2' and inlining critical paths.

```package Organism;

use strict;
use warnings;
use feature 'state';

sub count {
return scalar keys %{ shift->{Cells} };
}

# Input a list of [ x, y ] coords
sub insert_cells {
my \$cells = shift->{Cells};
for my \$r (@_) { \$cells->{ pack 'i2', @{\$r} } = undef }
}

# Return sorted list of cells in the Organism.
# Used for verification and testing the state of the organism.
sub get_live_cells {
sort { \$a->[0] <=> \$b->[0] || \$a->[1] <=> \$b->[1] }
map { [ unpack 'i2', \$_ ] }
keys %{ shift->{Cells} };
}

# Return the list of dead cells surrounding a cell
my ( \$cells, \$x0, \$y0 ) = ( shift->{Cells}, @_ );
my ( \$x1, \$x2, \$y1, \$y2 ) = ( \$x0 - 1, \$x0 + 1, \$y0 - 1, \$y0 + 1 );

state ( \$k1, \$k2, \$k3, \$k4, \$k5, \$k6, \$k7, \$k8 );

( ( \$k1 = pack 'i2', \$x1, \$y1 ) x !( 0 + exists \$cells->{ \$k1 } ),
( \$k2 = pack 'i2', \$x1, \$y0 ) x !( 0 + exists \$cells->{ \$k2 } ),
( \$k3 = pack 'i2', \$x1, \$y2 ) x !( 0 + exists \$cells->{ \$k3 } ),
( \$k4 = pack 'i2', \$x0, \$y1 ) x !( 0 + exists \$cells->{ \$k4 } ),
( \$k5 = pack 'i2', \$x0, \$y2 ) x !( 0 + exists \$cells->{ \$k5 } ),
( \$k6 = pack 'i2', \$x2, \$y1 ) x !( 0 + exists \$cells->{ \$k6 } ),
( \$k7 = pack 'i2', \$x2, \$y0 ) x !( 0 + exists \$cells->{ \$k7 } ),
( \$k8 = pack 'i2', \$x2, \$y2 ) x !( 0 + exists \$cells->{ \$k8 } ) )
+;
}

sub tick {
my \$self  = shift;
my \$cells = \$self->{Cells};
my %new_cells;

for my \$c (keys %{ \$cells }) {
# Get the (up to 8) dead cells surrounding the cell
my @zcells = \$self->get_dead_cells( unpack 'i2', \$c );

# Check the live cell
# Note: next line equivalent to nlive == 2 || nlive == 3
@zcells == 5 || @zcells == 6 and \$new_cells{\$c} = undef;

for my \$z (@zcells) {
state ( \$x0, \$x1, \$x2, \$y0, \$y1, \$y2 );

( \$x0, \$y0 ) = unpack 'i2', \$z;
( \$x1, \$x2, \$y1, \$y2 ) = ( \$x0 - 1, \$x0 + 1, \$y0 - 1, \$y0 + 1
+ );

# Get num live
(   ( 0 + exists \$cells->{ pack 'i2', \$x1, \$y1 } )
+ ( 0 + exists \$cells->{ pack 'i2', \$x1, \$y0 } )
+ ( 0 + exists \$cells->{ pack 'i2', \$x1, \$y2 } )
+ ( 0 + exists \$cells->{ pack 'i2', \$x0, \$y1 } )
+ ( 0 + exists \$cells->{ pack 'i2', \$x0, \$y2 } )
+ ( 0 + exists \$cells->{ pack 'i2', \$x2, \$y1 } )
+ ( 0 + exists \$cells->{ pack 'i2', \$x2, \$y0 } )
+ ( 0 + exists \$cells->{ pack 'i2', \$x2, \$y2 } )
) == 3 and \$new_cells{\$z} = undef;
}
}

\$self->{Cells} = \%new_cells;
}

sub new {
my \$class = shift;
my %init_self = ( Cells => {} );
bless \%init_self, \$class;
}

1;

Regards, Mario

Replies are listed 'Best First'.
Re^6: High Performance Game of Life
by eyepopslikeamosquito (Chancellor) on Aug 13, 2017 at 05:46 UTC

Thanks Mario! Shaved a couple more seconds:

• Got rid of state (didn't seem to make it any faster)
• Switched off warnings (admittedly this didn't make much, if any, difference)
• Some other minor tweaks
See "Mario improvements" entries in "Benchmark Results" section of root node for speed comparison with original Organism.pm.

```package Organism;

use strict;

sub count { scalar keys %{ shift->{Cells} } }

# Input a list of [ x, y ] coords
sub insert_cells {
my \$cells = shift->{Cells};
for my \$r (@_) { \$cells->{ pack 'i2', @{\$r} } = undef }
}

# Return sorted list of cells in the Organism.
# Used for verification and testing the state of the organism.
sub get_live_cells {
sort { \$a->[0] <=> \$b->[0] || \$a->[1] <=> \$b->[1] }
map { [ unpack 'i2', \$_ ] } keys %{ shift->{Cells} };
}

sub tick {
my \$self  = shift;
my \$cells = \$self->{Cells};
my ( \$k1, \$k2, \$k3, \$k4, \$k5, \$k6, \$k7, \$k8,
\$x0, \$x1, \$x2, \$y0, \$y1, \$y2, %newcells );

for my \$c (keys %{ \$cells }) {
# Get the (up to 8) dead cells surrounding the cell
( \$x0, \$y0 ) = unpack 'i2', \$c;
( \$x1, \$x2, \$y1, \$y2 ) = ( \$x0 - 1, \$x0 + 1, \$y0 - 1, \$y0 + 1 );
my @zcells = (
(\$k1 = pack 'i2', \$x1, \$y1) x !exists(\$cells->{\$k1}),
(\$k2 = pack 'i2', \$x1, \$y0) x !exists(\$cells->{\$k2}),
(\$k3 = pack 'i2', \$x1, \$y2) x !exists(\$cells->{\$k3}),
(\$k4 = pack 'i2', \$x0, \$y1) x !exists(\$cells->{\$k4}),
(\$k5 = pack 'i2', \$x0, \$y2) x !exists(\$cells->{\$k5}),
(\$k6 = pack 'i2', \$x2, \$y1) x !exists(\$cells->{\$k6}),
(\$k7 = pack 'i2', \$x2, \$y0) x !exists(\$cells->{\$k7}),
(\$k8 = pack 'i2', \$x2, \$y2) x !exists(\$cells->{\$k8})  );

# Check the live cell (next line equivalent to nlive==2 || nlive
+==3)
@zcells == 5 || @zcells == 6 and \$newcells{\$c} = undef;

for my \$z (@zcells) {
( \$x0, \$y0 ) = unpack 'i2', \$z;
( \$x1, \$x2, \$y1, \$y2 ) = ( \$x0 - 1, \$x0 + 1, \$y0 - 1, \$y0 + 1
+ );
exists(\$cells->{pack 'i2', \$x1, \$y1})
+ exists(\$cells->{pack 'i2', \$x1, \$y0})
+ exists(\$cells->{pack 'i2', \$x1, \$y2})
+ exists(\$cells->{pack 'i2', \$x0, \$y1})
+ exists(\$cells->{pack 'i2', \$x0, \$y2})
+ exists(\$cells->{pack 'i2', \$x2, \$y1})
+ exists(\$cells->{pack 'i2', \$x2, \$y0})
+ exists(\$cells->{pack 'i2', \$x2, \$y2}) == 3 and \$newcells{\$z
+} = undef;
}
}
\$self->{Cells} = \%newcells;
}

sub new {
my \$class = shift;
my %init_self = ( Cells => {} );
bless \%init_self, \$class;
}

1;

Update: Minor stylistic edits were made to Organism.pm above. Note that changing the main loop above from:

```for my \$c (keys %{ \$cells }) {
to:
```while ( my (\$c) = each %{ \$cells } ) {
uses less memory - though I couldn't measure any difference in speed.

Update: This one is shorter, but a bit slower:

```sub tick {
my \$self  = shift;
my \$cells = \$self->{Cells};
my ( \$k1, \$k2, \$k3, \$k4, \$k5, \$k6, \$k7, \$k8,
\$x0, \$x1, \$x2, \$y0, \$y1, \$y2 );
%{\$cells} = map {
( \$x0, \$y0 ) = unpack 'i2', \$_;
( \$x1, \$x2, \$y1, \$y2 ) = ( \$x0 - 1, \$x0 + 1, \$y0 - 1, \$y0 + 1 );
my @zcells = (
(\$k1 = pack 'i2', \$x1, \$y1) x !exists(\$cells->{\$k1}),
(\$k2 = pack 'i2', \$x1, \$y0) x !exists(\$cells->{\$k2}),
(\$k3 = pack 'i2', \$x1, \$y2) x !exists(\$cells->{\$k3}),
(\$k4 = pack 'i2', \$x0, \$y1) x !exists(\$cells->{\$k4}),
(\$k5 = pack 'i2', \$x0, \$y2) x !exists(\$cells->{\$k5}),
(\$k6 = pack 'i2', \$x2, \$y1) x !exists(\$cells->{\$k6}),
(\$k7 = pack 'i2', \$x2, \$y0) x !exists(\$cells->{\$k7}),
(\$k8 = pack 'i2', \$x2, \$y2) x !exists(\$cells->{\$k8})  );
(\$_, undef) x (@zcells == 5 || @zcells == 6),
map { ( \$x0, \$y0 ) = unpack 'i2', \$_;
( \$x1, \$x2, \$y1, \$y2 ) = ( \$x0 - 1, \$x0 + 1, \$y0 - 1, \$y0 +
+1 );
(\$_, undef) x ( exists(\$cells->{pack 'i2', \$x1, \$y1})
+ exists(\$cells->{pack 'i2', \$x1, \$y0})
+ exists(\$cells->{pack 'i2', \$x1, \$y2})
+ exists(\$cells->{pack 'i2', \$x0, \$y1})
+ exists(\$cells->{pack 'i2', \$x0, \$y2})
+ exists(\$cells->{pack 'i2', \$x2, \$y1})
+ exists(\$cells->{pack 'i2', \$x2, \$y0})
+ exists(\$cells->{pack 'i2', \$x2, \$y2}) == 3 ) } @zcells
} keys %{\$cells};
}
as is this one:
```sub tick {
my \$self  = shift;
my \$cells = \$self->{Cells};
my ( \$k1, \$k2, \$k3, \$k4, \$k5, \$k6, \$k7, \$k8,
\$x0, \$x1, \$x2, \$y0, \$y1, \$y2 );
my %newcells;
@newcells{map {
( \$x0, \$y0 ) = unpack 'i2', \$_;
( \$x1, \$x2, \$y1, \$y2 ) = ( \$x0 - 1, \$x0 + 1, \$y0 - 1, \$y0 + 1 );
my @zcells = (
(\$k1 = pack 'i2', \$x1, \$y1) x !exists(\$cells->{\$k1}),
(\$k2 = pack 'i2', \$x1, \$y0) x !exists(\$cells->{\$k2}),
(\$k3 = pack 'i2', \$x1, \$y2) x !exists(\$cells->{\$k3}),
(\$k4 = pack 'i2', \$x0, \$y1) x !exists(\$cells->{\$k4}),
(\$k5 = pack 'i2', \$x0, \$y2) x !exists(\$cells->{\$k5}),
(\$k6 = pack 'i2', \$x2, \$y1) x !exists(\$cells->{\$k6}),
(\$k7 = pack 'i2', \$x2, \$y0) x !exists(\$cells->{\$k7}),
(\$k8 = pack 'i2', \$x2, \$y2) x !exists(\$cells->{\$k8})  );
(\$_) x (@zcells == 5 || @zcells == 6),
map { ( \$x0, \$y0 ) = unpack 'i2', \$_;
( \$x1, \$x2, \$y1, \$y2 ) = ( \$x0 - 1, \$x0 + 1, \$y0 - 1, \$y0 +
+1 );
(\$_) x ( exists(\$cells->{pack 'i2', \$x1, \$y1})
+ exists(\$cells->{pack 'i2', \$x1, \$y0})
+ exists(\$cells->{pack 'i2', \$x1, \$y2})
+ exists(\$cells->{pack 'i2', \$x0, \$y1})
+ exists(\$cells->{pack 'i2', \$x0, \$y2})
+ exists(\$cells->{pack 'i2', \$x2, \$y1})
+ exists(\$cells->{pack 'i2', \$x2, \$y0})
+ exists(\$cells->{pack 'i2', \$x2, \$y2}) == 3 ) } @zcells
} keys %{\$cells} } = undef;
\$self->{Cells} = \%newcells;
}
I'm guessing they are slower because the list of cells used in the hash slice contains many duplicate dead cells.

Update: Changing:

```my @zcells = (
(\$k1 = pack 'i2', \$x1, \$y1) x !exists(\$cells->{\$k1}),
(\$k2 = pack 'i2', \$x1, \$y0) x !exists(\$cells->{\$k2}),
(\$k3 = pack 'i2', \$x1, \$y2) x !exists(\$cells->{\$k3}),
(\$k4 = pack 'i2', \$x0, \$y1) x !exists(\$cells->{\$k4}),
(\$k5 = pack 'i2', \$x0, \$y2) x !exists(\$cells->{\$k5}),
(\$k6 = pack 'i2', \$x2, \$y1) x !exists(\$cells->{\$k6}),
(\$k7 = pack 'i2', \$x2, \$y0) x !exists(\$cells->{\$k7}),
(\$k8 = pack 'i2', \$x2, \$y2) x !exists(\$cells->{\$k8})  );
to:
```my @zcells = grep( !exists(\$cells->{\$_}),
pack('i2', \$x1, \$y1),
pack('i2', \$x1, \$y0),
pack('i2', \$x1, \$y2),
pack('i2', \$x0, \$y1),
pack('i2', \$x0, \$y2),
pack('i2', \$x2, \$y1),
pack('i2', \$x2, \$y0),
pack('i2', \$x2, \$y2) );
was slightly slower.

This one was also slower:

```sub tick {
my \$self  = shift;
my \$cells = \$self->{Cells};
my ( \$k1, \$k2, \$k3, \$k4, \$k5, \$k6, \$k7, \$k8,
\$x0, \$x1, \$x2, \$y0, \$y1, \$y2, \$z, %newcells );

for my \$c (keys %{ \$cells }) {
# Get the (up to 8) dead cells surrounding the cell
( \$x0, \$y0 ) = unpack 'i2', \$c;
( \$x1, \$x2, \$y1, \$y2 ) = ( \$x0 - 1, \$x0 + 1, \$y0 - 1, \$y0 + 1 );
my @zcells = (
(\$x1, \$y1, \$k1 = pack 'i2', \$x1, \$y1) x !exists(\$cells->{\$k1}
+),
(\$x1, \$y0, \$k2 = pack 'i2', \$x1, \$y0) x !exists(\$cells->{\$k2}
+),
(\$x1, \$y2, \$k3 = pack 'i2', \$x1, \$y2) x !exists(\$cells->{\$k3}
+),
(\$x0, \$y1, \$k4 = pack 'i2', \$x0, \$y1) x !exists(\$cells->{\$k4}
+),
(\$x0, \$y2, \$k5 = pack 'i2', \$x0, \$y2) x !exists(\$cells->{\$k5}
+),
(\$x2, \$y1, \$k6 = pack 'i2', \$x2, \$y1) x !exists(\$cells->{\$k6}
+),
(\$x2, \$y0, \$k7 = pack 'i2', \$x2, \$y0) x !exists(\$cells->{\$k7}
+),
(\$x2, \$y2, \$k8 = pack 'i2', \$x2, \$y2) x !exists(\$cells->{\$k8}
+)  );

# Check the live cell (next line equivalent to nlive==2 || nlive
+==3)
@zcells == 15 || @zcells == 18 and \$newcells{\$c} = undef;

while (@zcells) {
( \$x0, \$y0, \$z ) = splice @zcells, 0, 3;
( \$x1, \$x2, \$y1, \$y2 ) = ( \$x0 - 1, \$x0 + 1, \$y0 - 1, \$y0 + 1
+ );
exists(\$cells->{pack 'i2', \$x1, \$y1})
+ exists(\$cells->{pack 'i2', \$x1, \$y0})
+ exists(\$cells->{pack 'i2', \$x1, \$y2})
+ exists(\$cells->{pack 'i2', \$x0, \$y1})
+ exists(\$cells->{pack 'i2', \$x0, \$y2})
+ exists(\$cells->{pack 'i2', \$x2, \$y1})
+ exists(\$cells->{pack 'i2', \$x2, \$y0})
+ exists(\$cells->{pack 'i2', \$x2, \$y2}) == 3 and \$newcells{\$z
+} = undef;
}
}
\$self->{Cells} = \%newcells;
}

Try this. Notably faster on my machine that is horribly slower than yours.

```package Organism;

use strict;
# use warnings;

sub count {
return scalar keys %{ shift->{Cells} };
}

# Input a list of [ x, y ] coords
sub insert_cells {
my \$cells = shift->{Cells};
for my \$r (@_) { \$cells->{ pack 'i2', @{\$r} } = undef }
}

# Return sorted list of cells in the Organism.
# Used for verification and testing the state of the organism.
sub get_live_cells {
sort { \$a->[0] <=> \$b->[0] || \$a->[1] <=> \$b->[1] }
map { [ unpack 'i2', \$_ ] }
keys %{ shift->{Cells} };
}

sub tick {
my \$self  = shift;
my \$cells = \$self->{Cells};
my ( \$k1, \$k2, \$k3, \$k4, \$k5, \$k6, \$k7, \$k8,
\$x0, \$x1, \$x2, \$y0, \$y1, \$y2, %new_cells, %dead_cells );

for my \$c (keys %{ \$cells }) {
# Get the (up to 8) dead cells surrounding the cell
( \$x0, \$y0 ) = unpack 'i2', \$c;
( \$x1, \$x2, \$y1, \$y2 ) = ( \$x0 - 1, \$x0 + 1, \$y0 - 1, \$y0 + 1 );
\$dead_cells{\$_}++ for my @zcells = (
(\$k1 = pack 'i2', \$x1, \$y1) x !(exists \$cells->{\$k1}),
(\$k2 = pack 'i2', \$x1, \$y0) x !(exists \$cells->{\$k2}),
(\$k3 = pack 'i2', \$x1, \$y2) x !(exists \$cells->{\$k3}),
(\$k4 = pack 'i2', \$x0, \$y1) x !(exists \$cells->{\$k4}),
(\$k5 = pack 'i2', \$x0, \$y2) x !(exists \$cells->{\$k5}),
(\$k6 = pack 'i2', \$x2, \$y1) x !(exists \$cells->{\$k6}),
(\$k7 = pack 'i2', \$x2, \$y0) x !(exists \$cells->{\$k7}),
(\$k8 = pack 'i2', \$x2, \$y2) x !(exists \$cells->{\$k8}) );

# Check the live cell
# Note: next line equivalent to nlive == 2 || nlive == 3
@zcells == 5 || @zcells == 6 and \$new_cells{\$c} = undef;
}
+s;
\$self->{Cells} = \%new_cells;
}

sub new {
my \$class = shift;
my %init_self = ( Cells => {} );
bless \%init_self, \$class;
}

1;

Hi tybalt89. The optimization is awesome.

Update 1: Bit-manipulation will not work when \$y is negative. See this post. I assumed that \$y was always positive from testing using the initial test script.

Update 2: See this post for a version that maps two integers into one integer successfully.

I tried bit-manipulation by mapping \$x and \$y into \$n. 16-bits is enough to hold \$y.

```package Organism;

use strict;
# use warnings;

sub _pack {
my ( \$x, \$y ) = @_;
\$x < 0 ? -(abs(\$x) << 16 | \$y) : \$x << 16 | \$y;
}

sub _unpack {
my ( \$n ) = @_;
return \$n < 0
? ( -( abs(\$n) >> 16 ), abs(\$n) & 0xFFFF )
: (        \$n  >> 16  ,     \$n  & 0xFFFF );
}

sub count {
return scalar keys %{ shift->{Cells} };
}

# Input a list of [ x, y ] coords
sub insert_cells {
my \$cells = shift->{Cells};
for my \$r (@_) { \$cells->{ _pack @{\$r} } = undef }
}

# Return sorted list of cells in the Organism.
# Used for verification and testing the state of the organism.
sub get_live_cells {
sort { \$a->[0] <=> \$b->[0] || \$a->[1] <=> \$b->[1] }
map { [ _unpack \$_ ] }
keys %{ shift->{Cells} };
}

sub tick {
my \$self  = shift;
my \$cells = \$self->{Cells};
my ( \$k1, \$k2, \$k3, \$k4, \$k5, \$k6, \$k7, \$k8,
\$x0, \$x1, \$x2, \$y0, \$y1, \$y2, %new_cells, %dead_cells );

for my \$c (keys %{ \$cells }) {
# Get the (up to 8) dead cells surrounding the cell
( \$x0, \$y0 ) = \$c < 0
? ( -( abs(\$c) >> 16 ), abs(\$c) & 0xFFFF )
: (        \$c  >> 16  ,     \$c  & 0xFFFF );

( \$x1, \$x2, \$y1, \$y2 ) = ( \$x0 - 1, \$x0 + 1, \$y0 - 1, \$y0 + 1 );

\$dead_cells{\$_}++ for my @zcells = (
(\$k1 = \$x1 < 0 ? -(abs(\$x1) << 16 | \$y1) : \$x1 << 16 | \$y1) x
+ !(exists \$cells->{\$k1}),
(\$k2 = \$x1 < 0 ? -(abs(\$x1) << 16 | \$y0) : \$x1 << 16 | \$y0) x
+ !(exists \$cells->{\$k2}),
(\$k3 = \$x1 < 0 ? -(abs(\$x1) << 16 | \$y2) : \$x1 << 16 | \$y2) x
+ !(exists \$cells->{\$k3}),
(\$k4 = \$x0 < 0 ? -(abs(\$x0) << 16 | \$y1) : \$x0 << 16 | \$y1) x
+ !(exists \$cells->{\$k4}),
(\$k5 = \$x0 < 0 ? -(abs(\$x0) << 16 | \$y2) : \$x0 << 16 | \$y2) x
+ !(exists \$cells->{\$k5}),
(\$k6 = \$x2 < 0 ? -(abs(\$x2) << 16 | \$y1) : \$x2 << 16 | \$y1) x
+ !(exists \$cells->{\$k6}),
(\$k7 = \$x2 < 0 ? -(abs(\$x2) << 16 | \$y0) : \$x2 << 16 | \$y0) x
+ !(exists \$cells->{\$k7}),
(\$k8 = \$x2 < 0 ? -(abs(\$x2) << 16 | \$y2) : \$x2 << 16 | \$y2) x
+ !(exists \$cells->{\$k8}) );

# Check the live cell
# Note: next line equivalent to nlive == 2 || nlive == 3
@zcells == 5 || @zcells == 6 and \$new_cells{\$c} = undef;
}
+s;
\$self->{Cells} = \%new_cells;
}

sub new {
my \$class = shift;
my %init_self = ( Cells => {} );
bless \%init_self, \$class;
}

1;

Regards, Mario

Update 1: Bit-manipulation will not work when \$y is negative. See this post. I assumed that \$y was always positive from testing using the initial test script.

Update 2: See this post for a version that maps two integers into one integer successfully.

For a last attempt in reaching 10x, I tried combining two integers into one via bit-manipulation. Having to support (\$x) being negative made bit-manipulation more complicated. However, it runs as fast as pack('ii').

This was an exercise and nothing more. I thought why not try bit-shifting the two integers into one.

```package Organism;

use strict;
# use warnings;

sub _pack {
my ( \$x, \$y ) = @_;
\$x < 0 ? -(abs(\$x) << 32 | \$y) : \$x << 32 | \$y;
}

sub _unpack {
my ( \$n ) = @_;
return \$n < 0
? ( -( abs(\$n) >> 32 ), abs(\$n) & 0xFFFFFFFF )
: (        \$n  >> 32  ,     \$n  & 0xFFFFFFFF );
}

sub count {
return scalar keys %{ shift->{Cells} };
}

# Input a list of [ x, y ] coords
sub insert_cells {
my \$cells = shift->{Cells};
for my \$r (@_) { \$cells->{ _pack @{\$r} } = undef }
}

# Used for verification and testing the state of the organism.
sub get_live_cells {
sort { \$a->[0] <=> \$b->[0] || \$a->[1] <=> \$b->[1] }
map { [ _unpack \$_ ] }
keys %{ shift->{Cells} };
}

sub tick {
my \$self  = shift;
my \$cells = \$self->{Cells};
my ( \$k1, \$k2, \$k3, \$k4, \$k5, \$k6, \$k7, \$k8,
\$x0, \$x1, \$x2, \$y0, \$y1, \$y2, %new_cells );

for my \$c (keys %{ \$cells }) {
# Get the (up to 8) dead cells surrounding the cell
( \$x0, \$y0 ) = \$c < 0
? ( -( abs(\$c) >> 32 ), abs(\$c) & 0xFFFFFFFF )
: (        \$c  >> 32  ,     \$c  & 0xFFFFFFFF );

( \$x1, \$x2, \$y1, \$y2 ) = ( \$x0 - 1, \$x0 + 1, \$y0 - 1, \$y0 + 1 );

my @zcells = (
(\$k1 = \$x1 < 0 ? -(abs(\$x1) << 32 | \$y1) : \$x1 << 32 | \$y1) x
+ !(exists \$cells->{\$k1}),
(\$k2 = \$x1 < 0 ? -(abs(\$x1) << 32 | \$y0) : \$x1 << 32 | \$y0) x
+ !(exists \$cells->{\$k2}),
(\$k3 = \$x1 < 0 ? -(abs(\$x1) << 32 | \$y2) : \$x1 << 32 | \$y2) x
+ !(exists \$cells->{\$k3}),
(\$k4 = \$x0 < 0 ? -(abs(\$x0) << 32 | \$y1) : \$x0 << 32 | \$y1) x
+ !(exists \$cells->{\$k4}),
(\$k5 = \$x0 < 0 ? -(abs(\$x0) << 32 | \$y2) : \$x0 << 32 | \$y2) x
+ !(exists \$cells->{\$k5}),
(\$k6 = \$x2 < 0 ? -(abs(\$x2) << 32 | \$y1) : \$x2 << 32 | \$y1) x
+ !(exists \$cells->{\$k6}),
(\$k7 = \$x2 < 0 ? -(abs(\$x2) << 32 | \$y0) : \$x2 << 32 | \$y0) x
+ !(exists \$cells->{\$k7}),
(\$k8 = \$x2 < 0 ? -(abs(\$x2) << 32 | \$y2) : \$x2 << 32 | \$y2) x
+ !(exists \$cells->{\$k8}) );

# Check the live cell
# Note: next line equivalent to nlive == 2 || nlive == 3
@zcells == 5 || @zcells == 6 and \$new_cells{\$c} = undef;

for my \$z (@zcells) {
( \$x0, \$y0 ) = \$z < 0
? ( -( abs(\$z) >> 32 ), abs(\$z) & 0xFFFFFFFF )
: (        \$z  >> 32  ,     \$z  & 0xFFFFFFFF );

( \$x1, \$x2, \$y1, \$y2 ) = ( \$x0 - 1, \$x0 + 1, \$y0 - 1, \$y0 + 1
+ );

# Get num live
(   ( exists \$cells->{ \$x1 < 0 ? -(abs(\$x1) << 32 | \$y1) : \$x
+1 << 32 | \$y1 } )
+ ( exists \$cells->{ \$x1 < 0 ? -(abs(\$x1) << 32 | \$y0) : \$x
+1 << 32 | \$y0 } )
+ ( exists \$cells->{ \$x1 < 0 ? -(abs(\$x1) << 32 | \$y2) : \$x
+1 << 32 | \$y2 } )
+ ( exists \$cells->{ \$x0 < 0 ? -(abs(\$x0) << 32 | \$y1) : \$x
+0 << 32 | \$y1 } )
+ ( exists \$cells->{ \$x0 < 0 ? -(abs(\$x0) << 32 | \$y2) : \$x
+0 << 32 | \$y2 } )
+ ( exists \$cells->{ \$x2 < 0 ? -(abs(\$x2) << 32 | \$y1) : \$x
+2 << 32 | \$y1 } )
+ ( exists \$cells->{ \$x2 < 0 ? -(abs(\$x2) << 32 | \$y0) : \$x
+2 << 32 | \$y0 } )
+ ( exists \$cells->{ \$x2 < 0 ? -(abs(\$x2) << 32 | \$y2) : \$x
+2 << 32 | \$y2 } )
) == 3 and \$new_cells{\$z} = undef;
}
}

\$self->{Cells} = \%new_cells;
}

sub new {
my \$class = shift;
my %init_self = ( Cells => {} );
bless \%init_self, \$class;
}

1;

Regards, Mario

Create A New User
Node Status?
node history
Node Type: note [id://1197321]
help
Chatterbox?
and the web crawler heard nothing...

How do I use this? | Other CB clients
Other Users?
Others surveying the Monastery: (8)
As of 2018-11-16 09:34 GMT
Sections?
Information?
Find Nodes?
Leftovers?
Voting Booth?
My code is most likely broken because:

Results (193 votes). Check out past polls.

Notices?