Java的非标准位操作

Question

I have a program where I am currently using byte[] boolean arrays, ie each element is either 0 or 1 . I thought I should try to speed up the program by using bitwise operations.

One of the problems that I would need to solve goes as follows. For example , let

long a = 5 = "00101" (I don't write all uninteresting zeros at the beginning)
long b = 24 = "10100" . (I don't write all uninteresting zeros at the beginning)

I need an operation, O say, such that aOb takes at the positions where a is 1 , takes the corresponding values of b and concatenates them so that in this case we would be

2 = "00010" . (I don't write all uninteresting zeros at the beginning)

a 00101 
O   ↓ ↓ <- pick bits pointed by `1` in a
b 10100 
    ↓ ↓
    1 0 -> concatenate selected bits -> 10

EDIT: Attempt to clarify: Alright, so we go through a either from the left or from the right. If we encounter 0 , we no nothing. If we counter 1 , we take the value at the corresponding index of b . For example, going from the left, we do nothing for two 0 s, then we find 1 so we take the corresponding 1 from b , we find another 0 in a and do nothing and then we find another 1 in a and take the corresponding 0 from b .

EDIT: Another way to put it is like this: Shift a to the right and read out the value (is this possible?). If it's 1 , we shift b to the right, read the value, store it to a result variable r and shift r to the right. If it's 0 , we shift b to the right, forget the value and do nothing with r .

EDIT: I'll elaborate a bit on the purpose to try and clarify what I want to do. We have a set of boolean variables (say 5 to agree with our example). The variable b represents an array of their states according to some indexing. The 1 s in variable a represent the indices, namely 2 and 4 in our example, of the boolean variables in our system that matter to a certain boolean variable (say the 0th). The values of the 2nd and 4th boolean variables form one of the possible inputs to a truth table associated with the 0th variable.

Any suggestions?

EDIT: Right now, what I'm doing is this. Suppose we have a system with 5 boolean variables, indexed $0,1,2,3,4$. Suppose that the 0th variable is a function of the 2nd and 4th variables and has a the truth table of AND, ie

2 | 4 |Output for 0

0 | 0 | 0
0 | 1 | 0
1 | 0 | 0
1 | 1 | 1

I always keep the table sorted in this fashion, so I don't really need the left part of the table. The right part of the table is implemented as a byte[] array. To find the output, I simply take the integer representation of the input read as a binary number. Eg the input 10 is 2, so my output is the value at index 2 in my byte[] array. To find the input, I need the part of the current state of my system which corresponds to variable in question, namely the 0th. That is, I want the values of the 2nd and 4th variables, read in that order.

Thus:

byte[] c = new byte[]{1,0,1,0,0}; //Corresponds to b above
int[] ind = new int[]{2,4}; //Indices of c that we're interested in
byte[] table = new byte[]{0,0,0,1}; //The truth table
int j = 0; //Truth table index
for(int i = 0; i < ind.length; i++) {
     j += c[ind[i]]*(1 << (ind.length - 1 - i)) //Binary to integer
}
//Output is table[j] 

Answer 1

By the way, "10100" is 20 not 24

class Main
{
    public static void main (String[] args) throws java.lang.Exception
    {
        long a =  5; // "00101"
        long b = 20; // "10100"
        long c = 0;  // the result
        long pos = 1; // value of next position in result

        while (a > 0) {
            if ((a & 1) == 1) {
                c = c + (pos * (b & 1));
                pos = pos << 1;
            }
            a = a >> 1;
            b = b >> 1;
        }
        System.out.println("result=" + c);  //  2 ("10")
    }
}

You still end up with a loop, so this really only saves memory.

Answer 2

This is only pseudo code, so no guarantees for completeness nor correctness.

r = 0

for(int i=0; i<bits; i++) {
  condition = (a >> i) & 1;
  lookup    = (b >> i) & 1;
  if(condition == 1) {
    r = (r << 1) | lookup;
  }
}

Given these inputs ...

a = 00101
b = 10100
bits = 5

the algorithm behaves as follows. Initialize the result.

r = 0

Take the last bit, which is at i=0 . In order to do so shift to the position i in and kick rest of digits with an and operation like this: & 1 . Do this for both a and b . Then check if the filter condition is true, in this case it means when a has a 1 on the last bit.

i = 0
condition = (00101 >> 0) & 1 = 00101 & 1 = 00001 = 1
lookup    = (10100 >> 0) & 1 = 10100 & 1 = 00000 = 0
r         = (0 << 1) | 0 = 0 | 0 = 0 

i = 1
condition = (00101 >> 1) & 1 = 00010 & 1 = 00000 = 0
lookup    = (10100 >> 1) & 1 = 01010 & 1 = 00000 = 0
r         = 0 // no modification here

i = 2
condition = (00101 >> 2) & 1 = 00001 & 1 = 00001 = 1
lookup    = (10100 >> 2) & 1 = 00101 & 1 = 00001 = 1
r         = (1 << 1) | 1 = 2 | 1 = 3

The code can be cleaned up with two functions, like this:

lastAt(i, x)   := (x >> i) & 1;
concatTo(r, v) := (r << 1) | v;

r = 0
for(int i=0; i<bits; i++) {
  if(lastAt(i, a) == 1) {
    r = concatTo(r, lastAt(i, b));
  }
}

Answer 3

It's unlikely that these operations are going to be a bottleneck for your program. So my advice is just use an array of booleans -- don't bother with bit-by-bit operations, it's going to make your program harder to understand and modify.

If you are really worried about execution time spent on these operations, do some careful benchmarking or profiling before trying to optimize it. My guess is that will show there's nothing to gain by modifying that code.

Answer 4

Your description is vague, but it is emerging from the obscurity that this is not a bitwise operation at all. In which case my original suggestion that you provide a truth table holds good, and in fact that's how you should implement it as well: with a table lookup.