#!perl -w
use strict;
my $fmt = "0b" . ("%06b" x 5);

sub b5ToInt { oct sprintf "0b%06b%06b%06b%06b%06b", @_ }

sub intToB5 {
 map { oct "0b$_" } unpack "(a6)5", sprintf "%030b", $_[0]
}

my $word = b5ToInt(1,2,3,4,5);
printf "word = %d = 0x%08x = 0b%030b\n", $word, $word, $word;

my @out = intToB5($word);
print "out = ", join(", ", @out), "\n";
[download]

word = 17314053 = 0x01083105 = 0b000001000010000011000100000101
out = 1, 2, 3, 4, 5
[download]

Okay, the C programmer in me rebelled against the inefficiency of my earlier reply. How about:

sub b5ToInt {
  use integer;
  return     ($_[4]||0)
          + (($_[3]||0)<<6)
          + (($_[2]||0)<<12)
          + (($_[1]||0)<<18)
          + (($_[0]||0)<<24);
}
sub intToB5 {
  use integer;
  my $in = int(shift);
  return map { $_ & 0b111111 } 
   (($in >> 24),
    ($in >> 18),
    ($in >> 12),
    ($in >>  6),
    $in);
}
[download]

The C programmer in you may rail against the inefficiency of your first solution, but this solution has you doing a pile of work that would be more efficiently handled by the computer. Get it to calculate those multiples of 6, it's better at that than you are. Factor that out, and your code will shrink.

And should the requirements ever change, you'll have much less code of your own to change. That's a much better form of effciency worth seeking.

• another intruder with the mooring in the heart of the Perl

0055 5555 4444 4433 3333 2222 2211 1111
[download]

# Get individual num:
$num = ($aggregate >> ($i*6)) & 0b111111;

# Set individual num:
$aggregate = ($aggregate & ~(0x3F << ($i*6))) | ($num << ($i*6));
[download]

Update: Added missing ~.
Update: Thelonius's newer post shows how to use this method to get/set all the nums at once.

I'd do it this way. Encapsulate and abstractulate as appropriate:

my $num = shift;
my $bits = 6;
my $mask = (1 << $bits) - 1;

my @out = map {
    ($num & $mask << $_ * $bits)
    >> $_ * $bits
} 0..$bits-1;
[download]

update: oops, the map 0 .. $bits-1 is just a fortunate accident of 5 == 6-1. The following is better:

my $num    = shift;
my $groups = 5;
my $bits   = 6;
my $mask   = (1 << $bits) - 1;

my @out = map {
    ($num & $mask << $_ * $bits)
    >> $_ * $bits
} 0..$groups-1;
[download]

2nd update: oh, and you want to go back the other way. That's even easier:

my @in  = (30, 14, 27, 2, 17);
my $width  = 6;

my $offset = 0;
my $out = 0;
$out |= ($_ << ($offset++ * $width)) for @in;
[download]

I'd use a 4 Byte String and vec.

How do you use vec to set 6-bits?

---

Examine what is said, not who speaks -- Silence betokens consent -- Love the truth but pardon error.

"Science is about questioning the status quo. Questioning authority".

In the absence of evidence, opinion is indistinguishable from prejudice.

"Too many [] have been sedated by an oppressive environment of political correctness and risk aversion."