Whilst Math::BigInt and similar arbitrary precision modules work for this, they leave a lot to be desired when it comes to performing fixed-precision math. As well as being dog slow, they don't round or truncate as fixed-precision does, and that can lead to the need for lots of extra work to 'fix' intermediate values in calculations.

If you have a lot of 128-bit integers (16-bytes/32-hex bytes) to manipulate, and need fixed precision semantics, then look at salva's Math::Int128 it is efficient and stable and provides the correct semantics for bitwise manipulations of 128-bit digests, hashes and similar.

It seems that really you are just dealing with big integers. The hex representation is only a detail. Math::BigInt handles the details of representation for you, provides a bitwise 'and' operation, named band:

use Math::BigInt;

my $operand = '0x123456789abcdef0123456789abcdef0';
my $mask    = '0x100000000f00000000000000000000f0';

print Math::BigInt->new($mask)->band($operand)->as_hex(), "\n";
[download]

Math::BigInt also overloads the '&' operator, so you can do things like this:

my $anded = Math::BigInt->new($mask) & $operand;
print $anded->as_hex(), "\n";
[download]

You can do bitwise AND with strings, too (in which case there's no size limitation).

So, convert your hex string and your number to binary strings using pack (e.g. pack "H*", $hexstring for the hex string), pad the shorter one to the length of the longer one (with \0 or \xff, depending on the desired semantics), AND (&) both strings, and convert the result back to whatever you like (e.g. hex string).

The details somewhat depend on what exactly you need, so if you provide sample inputs and desired result, someone will surely come up with actual code...

Otherwise, if you want to stick with Math::Big*, there is from_hex().

Hi,

Thank you for your quick reactions ;-)
Using Math::BigInt or pack I unfortunately still get an integer overflow. I'm probably doing something wrong but don't see what. Sorry if this is to much of a newbie question.

A little more context: The hexstring comes from a switch. I want to use the hexstring to determine if a switchport is member of a specific VLAN. The code I have so far is:

my $switchPortNumber = 2;
# 32 Character hex string from switch
my $hexstring = hex '40000000000000000000000000000000'; 
my $mask = (0x80000000000000000000000000000000 >> $switchPortNumber);
my $result = ($hexstring & $mask) > 0;
[download]

In this case only the first port is a member and the second port is NOT a member. Therefore the $result should be 0

If possible I would like to stick to the default Perl modules.
Thanks again for all the help so far.

This works fine for me:

use Math::BigInt;

my $switchPortNumber = 2;
# 32 Character hex string from switch
my $hexstring = Math::BigInt->new('0x40000000000000000000000000000000'
+); 
my $mask = (Math::BigInt->new('0x80000000000000000000000000000000') >>
+ $switchPortNumber);
my $result = ($hexstring & $mask) > 0;
[download]

Another approach would be to turn it into an ASCII bitstring, in which case you can use a simple substr() instead of the AND masking

my $bitstring = unpack('B*', pack('H*', '40000000000000000000000000000
+000'));
my $result = substr($bitstring, $switchPortNumber, 1) eq '1';
[download]

hex(substr($hex,  -8)) & $integer;   # Perl with 32-bit integers
hex(substr($hex, -16)) & $integer;   # Perl with 64-bit integers
[download]