I need the command bitwisexor. Somebody an idea to do that?

Jens

Here is a post from Kem Tekinay I picked up in the beta forum about the absence of bitwise in iOS. It may help :

You can still use AND, OR, and XOR as you could with the old framework.

Shift left/right can be emulated with value * 2^bits or value \ 2^bits.

Ones complement can be achieved with this code:

```
dim ones as UInt64 = &hFFFFFFFFFFFFFFFF
value = value Xor ones
```

I found it. It is just simple:

dim a as UInt32 = 3

dim b as UInt32 = 7

dim result as Uint32 = (a xor b)

Iâ€™m confusedâ€¦

I have the following

```
' value As UInt64, shift As Integer, bits As Integer
Dim result as UInt64 = Bitwise.ShiftLeft(value, shift, bits)
```

How do I translate this in new framework with

`value * 2^bits`

Iâ€™m missing the shift parameter, no ?

No, in your example, itâ€™s missing the â€śbitsâ€ť.

If I rewrite the params to be a bit clearer:

`result = Bitwise.ShiftLeft( value, placesToShift, numOfBitsToShift )`

that would translate to:

`result = value * 2^placesToShift`

You control the number of bits to shift by declaring your value and result accordingly, or applying a mask after the shift.

Now itâ€™s clear !

Thanks a lot Kem.

What would be nice to know is whether

`result = Bitwise.ShiftLeft( value, placesToShift, numOfBitsToShift )`

translates to a shift instruction in the processor, if that is the case substituting

`result = value * 2^placesToShift`

even though it works will result in a speed penalty for math intensive code. I still think that there should be a shift operator added to Xojo to go along side and, or, xor.

In prior testing I found that plain old XOR is way faster than Bitwise.XOR, so I suspect you are correct : if we had a dedicated << or >> operator there would be a speed improvement.

Thatâ€™s because Bitwise.Xor is a method call with all its associated overhead whereas Xor is an operator.

To maximize the speed of math-based shift-left/right, create an array with all the values of 2^n, then lookup from the array.

```
static powersOf2() as UInt64
if powersOf2.Ubound = -1 then
dim two as UInt64 = 2
dim zero as UInt64 = 0
dim sixtyThree as UInt64 = 63
for i as UInt64 = zero to sixtyThree
powersOf2.Append two^i
next
end if
dim shiftL as UInt64 = value * powersOf2( places )
dim shiftR as UInt64 = value \\ powersOf2( places )
```

(I havenâ€™t actually tried this in an iOS project so I canâ€™t tell you if there is some framework-based reason it wonâ€™t work.)