bitwise-operators

How can I read the raw bytes of a Float or Double in Swift? Example: let x = Float(1.5) let bytes1: UInt32 = getRawBytes(x) let bytes2: UInt32 = 0b00111111110000000000000000000000 I want bytes1 and bytes2 to contain the same value, since this binary number is the Float representation of 1.5 . I need it to do bit-wise operations like & and >> (these are not defined on a float). Update for Swift 3: As of Swift 3, all floating point types have bitPattern property which returns an unsigned integer with the same memory representation, and a corresponding init(bitPattern:) constructor for the

I came across some code that looks like this: string someString; ... bool someBoolean = true; someBoolean &= someString.ToUpperInvariant().Equals("blah"); Why would I use the bitwise operator instead of "="? It's not a bitwise operator when it's applied to boolean operators. It's the same as: someBoolean = someBoolean & someString.ToUpperInvariant().Equals("blah"); You usually see the short-cut and operator && , but the operator & is also an and operator when applied to booleans, only it doesn't do the short-cut bit. You can use the && operator instead (but there is no &&= operator) to

I'm trying to port some functionality from a Java app to Python. In Java, System.out.println(155 << 24); Returns: -1694498816 In Python: print(155 << 24) Returns 2600468480 Many other bitwise operations have worked in the same way in both languages. Why is there a different result in these two operations? EDIT: I'm trying to create a function in python to replicate how the left shift operator works in Java. Something along the lines of: def lshift(val, n): return (int(val) << n) - 0x100000000 However this doesn't seem right as (I think) it turns all numbers negatives? EDIT2: Several hours

This question already has an answer here: Right Shift to Perform Divide by 2 On -1 6 answers While reading Java Source code for Collections.reverse method, Right Shift operator is used for finding middle. ...... for (int i=0, mid=size>>1, j=size-1; i<mid; i++, j--) // Right Shift swap(list, i, j); ..... Same can be done by using traditional divide by 2 approach. I explored on stack Right Shift to perform division and find that its better to use division operator and not Right Shift. UPDATE : But then why java guys used Right Shift and not division ? So which approach is better to use and Why ?

How can I overload the |= operator on a strongly typed (scoped) enum (in C++11, GCC)? I want to test, set and clear bits on strongly typed enums. Why strongly typed? Because my books say it is good practice. But this means I have to static_cast<int> everywhere. To prevent this, I overload the | and & operators, but I can't figure out how to overload the |= operator on an enum . For a class you'd simply put the operator definition in the class , but for enums that doesn't seem to work syntactically. This is what I have so far: enum class NumericType { None = 0, PadWithZero = 0x01, NegativeSign

I've read this interesting answer about " Checking if a number is divisible by 3 " Although the answer is in Java , it seems to work with other languages also. Obviously we can do : boolean canBeDevidedBy3 = (i % 3) == 0; But the interesting part was this other calculation : boolean canBeDevidedBy3 = ((int) (i * 0x55555556L >> 30) & 3) == 0; For simplicity : 0x55555556L = "1010101010101010101010101010110" Nb There's also another method to check it : One can determine if an integer is divisible by 3 by counting the 1 bits at odd bit positions, multiply this number by 2, add the number of 1-bits