by Ron Gutman
Listing One
public class BitLinear { public static long reverse (long bits) { long rl = 0; for (int i = 0; i < 64; i++) { rl = (rl << 1) + (bits & 1); bits = bits >>> 1; } return rl; } public static int count (long bits) { int cnt = 0; while (bits != 0) { cnt += bits & 1; bits = bits >>> 1; } return cnt; } } Listing Two public class BitRecursive { // reverse leftmost n bits of V static long reversen (long V, int n) { if (n <= 1) return V; int n2 = n/2; // reverse rightmost n/2 bits long right = reversen( V & ((1L<<n2)-1), n2); // reverse lefttmost n/2 bits long left = reversen( V >>> n2, n2); // combine in reverse order return (right << n2) | left; } public static long reverse (long bits) { return reversen (bits, 64); } } Listing Three public class BitLogN { public static long reverse (long bits) { // >>> fills bits on the left with 0 (no sign extension) bits = ((bits&0x00000000ffffffffL) << 32) | ((bits&0xffffffff00000000L) >>> 32); bits = ((bits&0x0000ffff0000ffffL) << 16) | ((bits&0xffff0000ffff0000L) >>> 16); bits = ((bits&0x00ff00ff00ff00ffL) << 8) | ((bits&0xff00ff00ff00ff00L) >>> 8); bits = ((bits&0x0f0f0f0f0f0f0f0fL) << 4) | ((bits&0xf0f0f0f0f0f0f0f0L) >>> 4); bits = ((bits&0x3333333333333333L) << 2) | ((bits&0xccccccccccccccccL) >>> 2); bits = ((bits&0x5555555555555555L) << 1) | ((bits&0xaaaaaaaaaaaaaaaaL) >>> 1); return bits; } public static int count (long bits) { bits = (bits&0x5555555555555555L) + ((bits&0xaaaaaaaaaaaaaaaaL) >>> 1); bits = (bits&0x3333333333333333L) + ((bits&0xccccccccccccccccL) >>> 2); bits = (bits&0x0f0f0f0f0f0f0f0fL) + ((bits&0xf0f0f0f0f0f0f0f0L) >>> 4); bits = (bits&0x00ff00ff00ff00ffL) + ((bits&0xff00ff00ff00ff00L) >>> 8); bits = (bits&0x0000ffff0000ffffL) + ((bits&0xffff0000ffff0000L) >>> 16); bits = (bits&0x00000000ffffffffL) + ((bits&0xffffffff00000000L) >>> 32); return (int) bits; } public static long mortonKey (int x, int y) { /* In C++, the calls to spreadBits could be made in-line */ /* to avoid function call overhead. */ /* In C, make the function a macro (admittedly an ugly one) */ return (spreadBits(x) << 1) | spreadBits(y); } // For j = 1 to 31, shift bit j j positions to the left static long spreadBits (int i) { long bits = i; // shift bits 16 to 31 16 bits bits = (bits & 0x000000000000ffffL) | ((bits & 0x00000000ffff0000L) << 16); // shift originally odd-numbered bytes 8 bits bits = (bits & 0x000000ff000000ffL) | ((bits & 0x0000ff000000ff00L) << 8); // shift originally odd-numbered nibbles 4 bits bits = (bits & 0x000f000f000f000fL) | ((bits & 0x00f000f000f000f0L) << 4); // shift originally odd-numbered bit pairs 2 bits bits = (bits & 0x0303030303030303L) | ((bits & 0x0c0c0c0c0c0c0c0cL) << 2); // shift originally odd-numbered bit pairs 1 bits bits = (bits & 0x1111111111111111L) | ((bits & 0x2222222222222222L) << 1); return bits; } } Listing Four public class BitTable { short[] table = new short[256]; public BitTable() { BitLinear lin = new BitLinear(); for (int i = 0; i < 256; i++) { table[i] = (short) (lin.reverse(i) >>> 56); } } public long reverse (long bits) { long rl = 0; rl = table[(int)(bits & 255)]; bits = bits >>> 8; rl = (rl << 8) | table[(int)(bits & 255)]; bits = bits >>> 8; rl = (rl << 8) | table[(int)(bits & 255)]; bits = bits >>> 8; rl = (rl << 8) | table[(int)(bits & 255)]; bits = bits >>> 8; rl = (rl << 8) | table[(int)(bits & 255)]; bits = bits >>> 8; rl = (rl << 8) | table[(int)(bits & 255)]; bits = bits >>> 8; rl = (rl << 8) | table[(int)(bits & 255)]; bits = bits >>> 8; rl = (rl << 8) | table[(int)(bits & 255)]; return rl; } }
Example 1:
if n equals 1, return V set R = right most n/2 bits of V set L = left most n/2 bits of V R = reversen(R,n/2) L = reversen(L,n/2) set RL = n bit value whose left most n/2 bits equals R and whose right most n/2 bits equals L return RL
Example 2:
if n equals 1, return V set R = right most n/2 bits of V set L = left most n/2 bits of V return countn(L,n/2) + countn(R,n/2)
See also:
file: /Techref/method/aa0900.htm, 5KB, , updated: 2006/8/11 07:47, local time: 2024/11/8 13:55,
owner: JMN-EFP-786,
3.138.61.232:LOG IN ©2024 PLEASE DON'T RIP! THIS SITE CLOSES OCT 28, 2024 SO LONG AND THANKS FOR ALL THE FISH!
|
©2024 These pages are served without commercial sponsorship. (No popup ads, etc...).Bandwidth abuse increases hosting cost forcing sponsorship or shutdown. This server aggressively defends against automated copying for any reason including offline viewing, duplication, etc... Please respect this requirement and DO NOT RIP THIS SITE. Questions? <A HREF="http://sxlist.com/Techref/method/aa0900.htm"> Techniques for exploiting the parallelism of bitwise operations [incl bit reversals, counting, and Morton keys] by Ron Gutman</A> |
Did you find what you needed? |
Welcome to sxlist.com!sales, advertizing, & kind contributors just like you! Please don't rip/copy (here's why Copies of the site on CD are available at minimal cost. |
Welcome to sxlist.com! |
.