Bitwise operators

Currently osl has support for:\

Bitwise AND

Bitwise and for osl is identical to bitwise and in js

Bitwise AND (&) - JavaScript | MDNMDN Web Docs

log 101 & 100
// 100

Bitwise OR

Bitwise or for osl is identical to bitwise or in js

Bitwise OR (|) - JavaScript | MDNMDN Web Docs

log 101 | 100
// 101

Bitwise XOR (^^)

The bitwise XOR operator (^^) returns 1 for each bit position where the corresponding bits of its operands are different.

// Basic XOR operations
5 ^^ 3    // Returns 6 (binary: 101 ^^ 011 = 110)
12 ^^ 5   // Returns 9 (binary: 1100 ^^ 0101 = 1001)

// Common uses
// Toggle bits
flag = flag ^^ 1  // Toggles the least significant bit

// Swap variables without a temporary variable
a = 5
b = 3
a = a ^^ b  // a = 6
b = a ^^ b  // b = 5
a = a ^^ b  // a = 3

Bitwise Left Shift (<<)

The left shift operator (<<) shifts the bits of the first operand to the left by the number of positions specified by the second operand.

// Basic left shift operations
5 << 1     // Returns 10 (binary: 101 becomes 1010)
3 << 2     // Returns 12 (binary: 11 becomes 1100)

// Common uses
// Quick multiplication by powers of 2
num = 4 << 1  // Same as 4 * 2 = 8
num = 4 << 2  // Same as 4 * 4 = 16
num = 4 << 3  // Same as 4 * 8 = 32

Bitwise Right Shift (>>)

The right shift operator (>>) shifts the bits of the first operand to the right by the number of positions specified by the second operand.

// Basic right shift operations
8 >> 1     // Returns 4 (binary: 1000 becomes 0100)
12 >> 2    // Returns 3 (binary: 1100 becomes 0011)

// Common uses
// Quick division by powers of 2
num = 16 >> 1  // Same as 16 / 2 = 8
num = 16 >> 2  // Same as 16 / 4 = 4
num = 16 >> 3  // Same as 16 / 8 = 2

Important Notes

1. Operator Precedence

   • Bitwise operators have lower precedence than arithmetic operators

   • Use parentheses to ensure operations are performed in the intended order

2. Type Handling

   • Operands are converted to integers before the operation

   • Results are always integers

   • Negative numbers use two's complement representation

3. Common Use Cases

   • Bit manipulation in flags and masks

   • Fast multiplication/division by powers of 2

   • Memory-efficient storage of boolean values

   • Data encryption and hashing algorithms

4. Best Practices

   • Use comments to explain complex bitwise operations

   • Consider readability vs. performance when choosing between bitwise and arithmetic operations

   • Be careful with shift amounts larger than the number's bit width