Minimum bytes required to represent a signed hexadecimal value - perl

Question

Can anyone tell me is there any function in Perl which converts signed decimal to Hex with minimum number of bytes.
ex: -555(dec) => FFFFFDD5(hex) [ converted using $Hex = sprintf( "%X", -555 )]
I want the result to be FDD5 instead of FFFFFDD5.
2 bytes are enough to represent -555.But i am getting 4 bytes conversion.
Please help!

Answer 1

There are two problems with your approach.
It's unparsable.
For example, even if you only know you have two numbers,
Bytes 12 34 56 7816 could refer to 1216 and 34567816.
Bytes 12 34 56 7816 could refer to 123416 and 567816.
Bytes 12 34 56 7816 could refer to 12345616 and 7816.
You could use some external means of identifying the length of the encoded number, but that would nullify some or all of the savings.
It's ambiguous.
For example,
Bytes FD D516 could refer to 6498110 (Bytes 00 00 FD D516 as an int32).
Bytes FD D516 could refer to -55510 (Bytes FF FF FD D516 as an int32).
One solution is to use a length prefix (like UTF-8).
-2^13..2^13-1 2 bytes 00xx xxxx xxxx xxxx
-2^21..2^21-1 3 bytes 01xx xxxx xxxx xxxx xxxx xxxx
-2^29..2^29-1 4 bytes 10xx xxxx xxxx xxxx xxxx xxxx xxxx xxxx
-2^31..2^31-1 5 bytes 1100 0000 xxxx xxxx xxxx xxxx xxxx xxxx xxxx xxxx
The optimal scheme will depend on the distribution of your numbers.
The packing/encoding function for the above scheme could be written as follows:
sub pack_vint32 {
my $n = shift;
my $nn = $n >= 0 ? $n : ~$n;
return substr(pack('L>', ($n & 0x3FFF ) | 0x0000 ), -2) if !($nn & ~0x1FFF);
return substr(pack('L>', ($n & 0x3FFFFF ) | 0x400000 ), -3) if !($nn & ~0x1FFFFF);
return substr(pack('L>', ($n & 0x3FFFFFFF) | 0x80000000), -4) if !($nn & ~0x1FFFFFFF);
return "\xC0".pack('L>', $n);
}
And the unpacking/decoding function for the above scheme could be written as follows:
sub unpack_vint32 {
for (shift) {
if (/^[\x00-\x3F]/) {
return if length() < 2;
my $n = unpack('L>', "\x00\x00".substr($_, 0, 2, '')) & 0x3FFF;
$n -= 0x4000 if $n & 0x2000;
return $n;
}
elsif (/^[\x40-\x7F]/) {
return if length() < 3;
my $n = unpack('L>', "\x00".substr($_, 0, 3, '')) & 0x3FFFFF;
$n -= 0x400000 if $n & 0x200000;
return $n;
}
elsif (/^[\x80-\xBF]/) {
return if length() < 4;
my $n = unpack('L>', substr($_, 0, 4, '')) & 0x3FFFFFFF;
$n -= 0x40000000 if $n & 0x20000000;
return $n;
}
elsif (/^\xC0/) {
return if length() < 5;
return unpack('xl>', substr($_, 0, 5, ''));
}
elsif (length() == 0) {
return;
}
}
croak("Bad data");
}
Test:
my $s =
join '',
map { pack_vint32($_) }
map { $_, -$_ }
130, 555, 0x12, 0x345678, 0x12345678;
say length($s);
say sprintf("%v02X", $s);
while ( my ($n) = unpack_vint32($s) ) {
say $n;
}
croak("Bad data") if length($s);
Output:
28
00.82.3F.7E.02.2B.3D.D5.00.12.3F.EE.80.34.56.78.BF.CB.A9.88.92.34.56.78.AD.CB.A9.88
----- ----- ----- ----- ----- ----- ----------- ----------- ----------- -----------
130 | | | | | | | | |
-130 ---+ | | | | | | | |
555 ----------+ | | | | | | |
-555 ---------------+ | | | | | |
18 -----------------------+ | | | | |
-18 ----------------------------+ | | | |
3430008 ---------------------------------+ | | |
-3430008 --------------------------------------------+ | |
305419896 -------------------------------------------------------+ |
-305419896 ------------------------------------------------------------------+

Answer 2

I think the question wants the string (ASCII) representation in hexadecimal that takes the minimum number of bytes in two's complement. I agree with comments and another answer regarding this being ambiguous, but it may be fine for "human" consumption. In this case:
sub min_bytes {
my $n = shift;
my $s = 256; # Fits in one byte
my $i = 1; # Bytes counter
while( 1 ) {
if( $n < 0 && -$n <= $s / 2 ) {
return $i;
}
elsif( $n >= 0 && $n < ($s / 2) - 1 ) {
return $i;
}
$s *= 256;
$i++;
}
}
sub to_hex {
my $n = shift;
my $l = min_bytes($n);
my $h = $n > 0 ? $n : (256 ** $l) + $n;
my $s = '';
for( my $i = 0; $i < $l; $i++ ) {
$s = unpack('H2', pack('C', $n % 256)) . $s;
$n = $n >> 8;
}
return $s;
}
# Let's try a few numbers
my #numbers = (-10, -555, -100000, -100000000, -10000000000, -10000000000000);
for my $n (#numbers) {
my $l = min_bytes($n);
my $h = to_hex($n);
print $n, " takes ", $l, " byte(s) and looks like ", uc $h, "\n";
}
I have tried not to use anything complicated. The bit unpack('H2', pack('C', $n % 256)) converts a single byte decimal number into hex.
This prints:
-10 takes 1 byte(s) and looks like F6
-555 takes 2 byte(s) and looks like FDD5
-100000 takes 3 byte(s) and looks like FE7960
-100000000 takes 4 byte(s) and looks like FA0A1F00
-10000000000 takes 5 byte(s) and looks like FDABF41C00
-10000000000000 takes 6 byte(s) and looks like F6E7B18D6000
The code uses Perl arithmetic, which may give wrong results for bigger numbers than the internal representation's precision.