You can set the fourth bit of a number by OR-ing it with a value that is zero everywhere except in the fourth bit. This could be done as x |= (1u << 3); Similarly, you can clear the fourth bit by AND-ing it with a value that is one everywhere except in the fourth … Read more
Both are correct. Implementation defined behavior is a particular type of unspecified behavior. Citing section 3.4.1 of the C standard which defines “implementation-defined behavior”: 1 implementation-defined behavior unspecified behavior where each implementation documents how the choice is made 2 EXAMPLE An example of implementation-defined behavior is the propagation of the high-order bit when a signed … Read more
“yep base-10 is what I mean” In that case, yes, they can be extended to base-10 in several ways, though they aren’t nearly as useful as in binary. One idea is that &, |, etc. are the same as doing arithmetic mod-2 to the individual binary digits. If a and b are single binary-digits, then … Read more
Like many other languages, the bitwise operators & (bitwise AND), | (bitwise OR), ^ (bitwise XOR) exist: fn main() { let mut byte: u8 = 0b0000_0000; byte |= 0b0000_1000; // Set a bit println!(“0b{:08b}”, byte); byte &= 0b1111_0111; // Unset a bit println!(“0b{:08b}”, byte); byte ^= 0b0000_1000; // Toggle a bit println!(“0b{:08b}”, byte); } The … Read more
Multiply the value by a carefully designed 64-bit constant, then mask off the upper 4 bits. For any CPU with fast 64-bit multiplication, this is probably as optimal as you can get. int field_set(uint64_t input) { uint64_t field = input * 0x20406080a0c0e1ULL; return (field >> 60) & 15; } // field_set(0x0000000000000000ULL) = 0 // field_set(0x0000000000000080ULL) … Read more
Any reasons why you don’t simply use: int sign = (int) Math.signum(a); //1 cast for floating-points, 2 for Integer types Additionally most Number implementations have a signum method taking a primitive of that type and returning an int, so you can avoid casting for extra performance. int sign1 = Integer.signum(12); //no casting int sign2 = … Read more
Why not use the standard library? #include <bitset> int bits_in(std::uint64_t u) { auto bs = std::bitset<64>(u); return bs.count(); } resulting assembler (Compiled with -O2 -march=native): bits_in(unsigned long): xor eax, eax popcnt rax, rdi ret It is worth mentioning at this point that not all x86 processors have this instruction so (at least with gcc) you … Read more
Javascript represents all numbers as 64-bit double precision IEEE 754 floating point numbers (see the ECMAscript spec, section 8.5.) All positive integers up to 2^53 can be encoded precisely. Larger integers get their least significant bits clipped. This leaves the question of how can you even represent a 64-bit integer in Javascript — the native … Read more
You can use the same technique. I’m assuming that variables contain 32-bit integers with the highest 22 bits set to 0 (which is a bit more restrictive than necessary). For each variable x containing one of the three 10-bit integers we do the following: x = (x | (x << 16)) & 0x030000FF; x = … Read more
This algorithm goes through as many iterations as there are set bits. So if we have a 32-bit word with only the high bit set, then it will only go once through the loop. In the worst case, it will pass once per bit. An integer n has log(n) bits, hence the worst case is … Read more