# Tag Archives: binary

## Bitwise OR | and Variable Function Arguments (bitwise flags)

Actionscript:
1. const A:uint = 1;
2. const B:uint = 2;
3. const C:uint = 4;
4. const D:uint = 8;
5. const E:uint = 16;
6.
7. function orArgs(args:uint):void{
8.     if (args & A){
9.         trace("A");
10.     }
11.     if (args & B){
12.         trace("B");
13.     }
14.     if (args & C){
15.         trace("C");
16.     }
17.     if (args & D){
18.         trace("D");
19.     }
20.     if (args & E){
21.         trace("E");
22.     }
23. }
24.
25. // test out the function:
26. orArgs(A | B);
27. trace("--");
28. orArgs(A | C | E);
29. trace("--");
30. orArgs(B | E | D);
31. trace("--");
32. orArgs(C | A);
33.
34. /* outputs:
35. A
36. B
37. --
38. A
39. C
40. E
41. --
42. B
43. D
44. E
45. --
46. A
47. C
48. */

If you've every used Array.sort(Array.NUMERIC | Array.DESCENDING) you should have at least a vague idea about what this snippet is doing. It shows how you can pass a variable number of arguments to a function using | (bitwise OR) and & (bitwise AND). I believe the correct term for these kind of arguments is "bitwise flags". This snippet works by having a series of constant values... in this case A - E. Each constant is assigned an unsigned integer... now you may not see the significance of the values 1, 2, 4, 8 and 16 until you see them in binary... get ready this is a pretty cryptic description...

A = 00001 = 1
B = 00010 = 2
C = 00100 = 4
D = 01000 = 8
E = 10000 = 16

If we OR all these together we get: 11111... If we do:

A | E
00001 | 10000

we end up with 10001...

...we can then check which values are stored in the resulting unsigned integer by using AND:

check for A... 10001 & 00001 = 00001 = true
check for E... 10001 & 10000 = 10000 = true
check for C... 10001 & 00100 = 00000 = false

That's it... I just guessed at the way this was being done... if you have another way to do the same thing, feel free to post it in the comments....

Posted in Math, Operators, binary, misc | Also tagged , , | 1 Comment

## XOR Conditional

Actionscript:
2.
3. function onLoop(evt:Event):void {
4.     var boolA:Boolean = false;
5.     var boolB:Boolean = false;
6.
7.     if (mouseX> 200){
8.         boolA = true;
9.     }else{
10.         boolA = false;
11.     }
12.
13.     if (mouseY <200){
14.         boolB = true
15.     }else{
16.         boolB = false;
17.     }
18.
19.     if (boolA || boolB){
20.         trace("regular or");
21.     }
22.
23. // this is the XOR conditional
24.     if (int(boolA) ^ int(boolB)){
25.         trace("exclusive or");
26.     }
27.
28. }

There's an obvious more logical ways to do this. But I thought it was somewhat interesting to see....

So in binary XOR will give us:
0^0 = 0;
0^1 = 1;
1^0 = 1;
1^1 = 0;

What other operator might you use to get the same results?... that's right !=

With regular OR we get:
0|0 = 0;
0|1 = 1;
1|0 = 1;
1|1 = 1;

## XOR Color Invert

Actionscript:
1. var yellow:uint = 0xFFFF00;
2.
3. // draws yellow circle
4. with(graphics) beginFill(yellow), drawCircle(100,100,50);
5.
6. // invert the color using XOR assignment
7. // yellow becomes 0x0000FF
8. yellow ^= 0xFFFFFF;
9.
10. // draws blue  circle
11. with(graphics) beginFill(yellow), drawCircle(200,100,50);

Just a fun use for XOR. You could also do it without XOR assignment:

Actionscript:
1. with(graphics) beginFill(yellow ^ 0xFFFFFF), drawCircle(200,100,50);

Playing a little with bitwise operators is a good way to make sure you understand them. Try tweaking this trace statement:

Actionscript:
1. trace((0x543210 ^ 0xFFFFFF).toString(16));

If you'd like to read about bitwise operators, I recommend wikipedia's article.