Don't care symbol in Perl

Question

I am wondering whether it is a Don't care symbol (X) in Perl.

I have a 50-bit binary input (actually, I used BigInt). If the input is matched with data in database, I would return a pre-defined value.

Let's say the data in the database is 11001100100010110111110110101001000010110101111101 .

If the input is X1001100100010110111110110101001000010110101111101, I would like to treat that it is a matched case because X can be 1 or 0. I know a way to split 50 bits in 50 1-bit and make an exception, but I would prefer to handle 50-bit together.

test.pl (main code, looks messy but the operation is simple, read database and input file and return an output file including a pre-defined value for the matched case. run by test.pl ) :

#!/usr/bin/perl 

use strict;
#use warnings;
use Math::BigInt;
#use Math::Gauss ':all';
#use Math::Gauss;
use 5.010;
use List::Util qw(sum);

my $Astrip="cmp_top.iop.sparc0.exu.rml.";
my $Aj=0;
my @Aoutput;
my $At=0;
my $Agen;
my @Aitems; my @Aweights;
my @Aitems_p; my @Aweights_p;
my $Ap=0;
my $Aselected_p = 0;
my $Atotal_p; my $Arand_p; my $Alimit_p;
my $Ai=0; my $Am=0; my $Ak=0;
my $Atotal; my $Arand; my $Alimit;
my $Aselected =0; my $Attemp=0; my $Ane=0; my $Asum=0;
my $Al=0; my $Attest=0;

#### change edb workload - matmul
open(CSV,'database.db')||die("Cannot open edb file $!");
my @Aedb;

while(<CSV>){
    my @Arow=split(/\t/,$_);
    push(@Aedb,\@Arow);
}
close CSV || die $!;
#       if ($At == 0) { goto ASTART;        }
my @Ainput=do{
    open my $Afh,"<","test.input" or die("Cannot open an input file $!");
    <$Afh>;
};
for (my $An=0; $An < (scalar @Ainput); $An +=3) {
### First loop
$Attest = 0;
for ($Ai=0; $Ai < (scalar @Aedb); $Ai +=2) {
    $a = Math::BigInt->new("$Aedb[$Ai][1]");
    $b = Math::BigInt->new("$Ainput[$An]"); 
    if ( $a == $b ) {

    $a = Math::BigInt->new("$Aedb[$Ai+1][1]");
    $b = Math::BigInt->new("$Ainput[$An+1]");
    if ( $a == $b ) {       $Attemp=0;
        $Attest++; 
        $Agen=$Ainput[$An+2];
        if (not defined $Agen) { $Arand_p = rand();}
        else { $Arand_p =  $Agen;   }
        #$Attemp=0;
        for ($Aj=2; $Aj < scalar @{ $Aedb[$Ai+1] }; $Aj++) {
            if ( $Aedb[$Ai+1][$Aj]/$Aedb[$Ai+1][2] > $Arand_p ) {
                $At++;
                    $Aedb[$Ai][$Aj] =~ s/\n//g;
                $Aoutput[$At+$An/3]= $Astrip.$Aedb[$Ai][$Aj];
                $Attemp++;
            }
        }
    #$Aoutput[$An/3+$At-$Attemp]= $Attemp;
    }
    }
}

}
open(my $Afh2, '>', 'test.output');
print $Afh2 join("\n", @Aoutput);
close $Afh2;

database.db (database file):

0.1 11001100100010110111110110101001000010110101111101  rml_irf_old_e_cwp_e[1]  rml_irf_new_e_cwp_e[1]  rml_irf_swap_even_e rml_irf_old_e_cwp_e[0]  rml_irf_new_e_cwp_e[0]  rml_irf_swap_odd_e
0.1 11101100110010011011001101100111001001100000010011  3.923510310023e-06  3.19470818154393e-08    7.05437377900141e-10    7.05437377900141e-10    4.89200539851702e-17    5.01433479478681e-19
0.1 10000110001111010010111101110011001001011110000100  rml_irf_new_e_cwp_e[1]  rml_irf_new_e_cwp_e[0]
0.1 01110111010010000000101001000001100011011100011111  0.052908822741908   2.7185508579738e-05
0.1 01001100100100001011101000011111100101111011000111  rml_irf_new_e_cwp_e[1]
0.1 00111101000100001101010111010100000111100100100101  1.09213787524617e-25
0.1 00001000011110000101010110111000000111011110011001  rml_irf_new_e_cwp_e[1]  rml_irf_new_lo_cwp_e[1] rml_irf_new_lo_cwp_e[2]
0.1 01101001011110101011111011011011101100110100000101  2.28019753307221e-06    2.89026436307201e-14    2.89026436307201e-14

test.input :

11001100100010110111110110101001000010110101111101
11101100110010011011001101100111001001100000010011

test.output (a pre-defined value for the input and nothing for the unmatched case. I would like to have the same output with X10011...) :

cmp_top.iop.sparc0.exu.rml.rml_irf_old_e_cwp_e[1]

Any help is appreciated.

1) You don't need BigInt for 50 bits; 2) You could just replace X with . and check a pattern match. — Sinan Ünür, Jan 13 at 22:20
@Sinan Ünür, I'm pretty sure it won't work without BigInt if you want to use bitwise-AND numbers and your IV size is 32 bits. (Bitwise-AND is way more efficient than a regex match.) — ikegami, Jan 14 at 0:04
@ikegami If that is the case, two 32-bit integers is still going to be faster than BigInt. I did not go into all the ways one can do this without using BigInt. — Sinan Ünür, Jan 14 at 11:54

ikegami · Answer 1 · 2017-01-17 14:52:28Z

Using Math::BigInt: (Comes with Perl)

use Math::BigInt qw( );

my $pattern = 'X1001100100010110111110110101001000010110101111101';
my $mask = Math::BigInt->from_bin( $pattern =~ tr/X01/011/r );
my $targ = Math::BigInt->from_bin( $pattern =~ tr/X/0/r );

for my $num_bin (qw(
   11001100100010110111110110101001000010110101111101
   11101100110010011011001101100111001001100000010011
)) {
   my $num = Math::BigInt->from_bin($num);
   if (($num & $mask) == $targ) {
      say "$num_bin matches";
   } else {
      say "$num_bin doesn't match";
   }
}

Using Math::UInt64: (Faster than BigInt)

use Math::UInt64 qw( net_to_uint64 );

sub bin_to_uint64 { net_to_uint64 pack 'B*', substr( ( "0" x 64 ) . $_[0], -64 ) }

my $pattern = 'X1001100100010110111110110101001000010110101111101';
my $mask = bin_to_uint64( $pattern =~ tr/X01/011/r );
my $targ = bin_to_uint64( $pattern =~ tr/X/0/r );

for my $num_bin (qw(
   11001100100010110111110110101001000010110101111101
   11101100110010011011001101100111001001100000010011
)) {
   my $num = bin_to_uint64($num);
   if (($num & $mask) == $targ) {
      say "$num_bin matches";
   } else {
      say "$num_bin doesn't match";
   }
}

Using native integers: (Fastest yet if supported)

use Config qw( %Config );

sub bin_to_uint64 { unpack 'Q>', pack 'B*', substr( ( '0' x 64 ) . $_[0], -64 ) }

die("64-ints required\n") if $Config{ivsize} < 8;

my $pattern = 'X1001100100010110111110110101001000010110101111101';
my $mask = bin_to_uint64( $pattern =~ tr/X01/011/r );
my $targ = bin_to_uint64( $pattern =~ tr/X/0/r );

for my $num_bin (qw(
   11001100100010110111110110101001000010110101111101
   11101100110010011011001101100111001001100000010011
)) {
   my $num = bin_to_uint64($num);
   if (($num & $mask) == $targ) {
      say "$num_bin matches";
   } else {
      say "$num_bin doesn't match";
   }
}

Using packed ints: (Fastest yet. As written, assumes pattern and num_bin are the same length.)

sub bin_to_packed { pack 'B*', $_[0] }

my $pattern = 'X1001100100010110111110110101001000010110101111101';
my $mask = bin_to_packed( $pattern =~ tr/X01/011/r );
my $targ = bin_to_packed( $pattern =~ tr/X/0/r );

for my $num_bin (qw(
   11001100100010110111110110101001000010110101111101
   11101100110010011011001101100111001001100000010011
)) {
   my $num = bin_to_packed($num);
   if (($num & $mask) eq $targ) {
      say "$num_bin matches";
   } else {
      say "$num_bin doesn't match";
   }
}

Using strings: (Fastest because nothing needs to be done in the loop but the actual check. Assumes pattern and num_bin are the same length.)

my $pattern = 'X1001100100010110111110110101001000010110101111101';
my $mask = $pattern =~ tr/X01/\x00\xFF\xFF/r;
my $targ = $pattern =~ tr/X/\x00/r;

for my $num_bin (qw(
   11001100100010110111110110101001000010110101111101
   11101100110010011011001101100111001001100000010011
)) {
   if (($num_bin & $mask) eq $targ) {
      say "$num_bin matches";
   } else {
      say "$num_bin doesn't match";
   }
}

Same as above, but works without 5.14+

my $pattern = 'X1001100100010110111110110101001000010110101111101';
( my $mask = $pattern ) =~ tr/X01/\x00\xFF\xFF/;
( my $targ = $pattern ) =~ tr/X/\x00/;

for my $num_bin (qw(
   11001100100010110111110110101001000010110101111101
   11101100110010011011001101100111001001100000010011
)) {
   if (($num_bin & $mask) eq $targ) {
      say "$num_bin matches";
   } else {
      say "$num_bin doesn't match";
   }
}

Output:

11001100100010110111110110101001000010110101111101 matches
11101100110010011011001101100111001001100000010011 doesn't match

Sinan Ünür · Answer 2 · 2017-01-13 22:27:17Z

#!/usr/bin/env perl

use strict;
use warnings;

my $search_for = 'X1001100100010110111110110101001000010110101111101';
(my $pat = $search_for) =~ s/X/./g;

while (my $line = <DATA>) {
    next unless $line =~ /\S/;
    my $key = (split ' ', $line, 3)[1];
    if ($key =~ /^$pat\z/) {
        print $line;
    }
}

__DATA__
0.1 11001100100010110111110110101001000010110101111101  rml_irf_old_e_cwp_e[1]  rml_irf_new_e_cwp_e[1]  rml_irf_swap_even_e rml_irf_old_e_cwp_e[0]  rml_irf_new_e_cwp_e[0]  rml_irf_swap_odd_e
0.1 11101100110010011011001101100111001001100000010011  3.923510310023e-06  3.19470818154393e-08    7.05437377900141e-10    7.05437377900141e-10    4.89200539851702e-17    5.01433479478681e-19
0.1 10000110001111010010111101110011001001011110000100  rml_irf_new_e_cwp_e[1]  rml_irf_new_e_cwp_e[0]
0.1 01110111010010000000101001000001100011011100011111  0.052908822741908   2.7185508579738e-05
0.1 01001100100100001011101000011111100101111011000111  rml_irf_new_e_cwp_e[1]
0.1 00111101000100001101010111010100000111100100100101  1.09213787524617e-25
0.1 00001000011110000101010110111000000111011110011001  rml_irf_new_e_cwp_e[1]  rml_irf_new_lo_cwp_e[1] rml_irf_new_lo_cwp_e[2]
0.1 01101001011110101011111011011011101100110100000101  2.28019753307221e-06    2.89026436307201e-

In addition, you really ought to take a critical look at your variables. You have too many of them, and they are not named usefully. Also, if they all begin with A, the A conveys no information.

zdim · Answer 3 · 2017-01-17 11:10:22Z

If I understand it right, you need the first (least significant) 49 bits to be the same.

For instance, set bit 50 for both then compare

if ( ($v1 | (1<<49)) == ($v2 | (1<<49)) ) { say "Match" }

where $v1 and $v2 are integers that may only differ in the 50-th bit.

The rest is about choosing how to form those integers from binary strings.

Using Math::BigInt as in the question (with ikegami's comparison numbers)

use warnings;
use strict;
use Math::BigInt;

my $input_bin = '01001100100010110111110110101001000010110101111101';
my $input  = Math::BigInt->from_bin($input_bin);    
print "$input_bin  input\n";

# First number in @nums differs from input only in the left-most bit
my @nums = (
   '11001100100010110111110110101001000010110101111101',
   '11101100110010011011001101100111001001100000010011'
);

my $bits = 49;
foreach my $num_bin (@nums) 
{
   my $num = Math::BigInt->from_bin($num_bin);

   if ( ($input | (1<<$bits)) == ($num | (1<<$bits)) ) 
   { 
       print "$num_bin  matches\n"; 
   } 
   else { 
       print "$num_bin  does not match\n" 
   }
}

Prints

01001100100010110111110110101001000010110101111101  input
11001100100010110111110110101001000010110101111101  matches
11101100110010011011001101100111001001100000010011  does not match

There are other modules for this, firstly Math::Int64.

If you have no other use of Math::BigInt you can get your integers in other ways, provided your system has 64 bit support and Perl was compiled with it.

Using pack, where the string first need be padded to 64

my $input = unpack("Q>", pack("B*", substr("0" x 64 . $input_bin, -64)));

where Q is

q  A signed quad (64-bit) value.
    Q  An unsigned quad value.
     (Quads are available only if your system supports 64-bit
      integer values _and_ if Perl has been compiled to support
      those.  Raises an exception otherwise.)

and > is the big-endian modifier, needed for agreement with B template in pack.

Using oct is far simpler, if you don't mind turning off 'portable' warnings

no warnings 'portable';

my $input = oct '0b' . $input_bin;

my $bits = 49;
foreach my $num_bin (@nums) 
{
   my $num = oct '0b' . $num_bin;

   if ( ($input | (1<<$bits)) == ($num | (1<<$bits)) ) { 
       print "$num_bin  matches\n"; 
   } else { 
       print "$num_bin  does not match\n" 
   }
}

The warning would be about this code not being portable between 32 and 64 bit Perls. This should be considerably faster than pack.

Jaeyoung Park · Answer 4 · 2017-01-15 00:33:34Z

Thank you for all your answers. I would appreciate all the help. I think what I wanted to know is Shinan's answer. I think the Don't care symbol is "." so I would use "." instead of using "X".

Also, I think my first explanation was not sufficient so I would explain the details.

1) Any bit of the input can be the don't care even if I used it only for the first bit in my example.

2) BigInt - Even if the example is 50-bit, I will use more bit later so native integer is not enough. However, Math::Uint64 is much faster as ikegami suggested and I will use it.

I will test all your suggestion tonight and post my answer soon. Thank you again.

asked	11 days ago
viewed	136 times
active	7 days ago

current community

your communities

more stack exchange communities

Don't care symbol in Perl

4 Answers 4

Your Answer

Not the answer you're looking for? Browse other questions tagged perl match condition or ask your own question.

Hot Network Questions

current community

your communities

more stack exchange communities

Don't care symbol in Perl

4 Answers 4

Your Answer

Sign up or log in

Post as a guest

Not the answer you're looking for? Browse other questions tagged perl match condition or ask your own question.

Related

Hot Network Questions