Pine Script Bitwise Operations: Boolean Flags and Integer Masks

Why bitwise_and and & fail as built-ins

TradingView lists arithmetic, comparison, logical, assignment, ternary, and history operators; it does not list &, |, ^, ~, <<, or >> as Pine operators. A standalone v6 call to bitwise_and(6, 3), without a local definition or import, also fails syntax validation. Changing only the version directive is not a fix. A library can export its own similarly named function, but that name is not a Pine built-in.

• If the operands are conditions, combine the boolean expressions with and or or.
• If the operands are packed integers, preserve the bit positions and width when porting the algorithm.
• For an imported helper, inspect the library author, version, alias, exported name, and supported numeric range.

Boolean logic does not reproduce integer AND

The integer operation 6 AND 3 returns 2 because binary 110 and 011 share the middle bit. Converting both operands to bool and combining them yields true and discards that bit pattern. Even testing whether both integers are nonzero is insufficient: 2 and 1 are nonzero, yet their bitwise AND is zero. For independent trading filters, named booleans usually express the intended condition directly.

• Mask 0 means neither condition, 1 means trend only, 2 means momentum only, and 3 means both.
• These conditions can change while the realtime bar is open. Choosing a flag representation does not prevent repainting.
• A numeric plot is required to inspect this mask in the Data Window; declaring a UDT does not create plots for its fields.

//@version=6
indicator("Boolean filters and mask encoding", overlay=false)

float average = ta.sma(close, 20)
float rsi = ta.rsi(close, 14)
bool trend = close > average
bool momentum = rsi > 50
bool both = trend and momentum

// Each flag owns a distinct bit. This sum encodes four possible states.
int mask = (trend ? 1 : 0) + (momentum ? 2 : 0)
plot(both ? 1 : 0, "Both conditions", color=color.teal)
plot(mask, "Mask 0 to 3", display=display.data_window)

A bounded arithmetic implementation of bitwise AND

For each position, divide the mask by its power-of-two weight, take the floor, and test whether the result is odd. Sum the weights present in both operands to construct AND. The helpers deliberately reject na, negative values, oversized masks, and invalid positions with runtime.error. Setting an existing bit leaves the mask unchanged; blindly adding its weight would carry into another bit.

//@version=6
indicator("Unsigned 16-bit mask checks", overlay=false)

requireMask(int mask) =>
    if na(mask) or mask < 0 or mask > 65535
        runtime.error("Mask must be an int from 0 to 65535")
    mask

bitWeight(int pos) =>
    if na(pos) or pos < 0 or pos > 15
        runtime.error("Bit position must be an int from 0 to 15")
    int(math.pow(2, pos))

testBit16(int mask, int pos) =>
    int checked = requireMask(mask)
    int weight = bitWeight(pos)
    math.floor(checked / weight) % 2 == 1

setBit16(int mask, int pos) =>
    testBit16(mask, pos) ? mask : mask + bitWeight(pos)

clearBit16(int mask, int pos) =>
    testBit16(mask, pos) ? mask - bitWeight(pos) : mask

and16(int a, int b) =>
    int left = requireMask(a)
    int right = requireMask(b)
    int result = 0
    for pos = 0 to 15
        if testBit16(left, pos) and testBit16(right, pos)
            result += bitWeight(pos)
    result

check(int actual, int expected, string name) =>
    if na(actual) or actual != expected
        runtime.error("Failed: " + name)
    actual

if barstate.isfirst
    check(and16(6, 3), 2, "overlapping bits")
    check(and16(2, 1), 0, "nonzero but disjoint")
    check(and16(0, 65535), 0, "zero boundary")
    check(and16(65535, 65535), 65535, "maximum mask")
    check(and16(32768, 32767), 0, "high bit disjoint")
    check(setBit16(0, 15), 32768, "set high bit")
    check(setBit16(65535, 15), 65535, "set is idempotent")
    check(clearBit16(65535, 15), 32767, "clear high bit")

plot(and16(6, 3), "Expected 2", color=color.purple)
// To exercise one rejection at a time, uncomment one line:
// plot(and16(-1, 3))
// plot(and16(65536, 3))
// plot(and16(int(na), 3))
// plot(testBit16(1, 16) ? 1 : 0)

Reproduce the boundaries before changing the width

Add the complete mask indicator to a chart. Its expected output is a line at 2, with no assertion error on the first bar. Uncomment one rejection line at a time to inspect the intended runtime error. These are reproducible expectations, not a report of chart execution: the published source was syntax-checked, while chart runtime verification remains a separate step.

• The width of 16 bits is a limit of this example, not the maximum size of a Pine int.
• Division and math.pow involve floating-point arithmetic. Increasing the width requires a fresh precision analysis; casting a rounded value to int cannot restore lost low bits.
• Do not truncate fractional inputs with int() and assume the resulting mask preserves the original value. The helper contract requires integer input.
• For 16-bit unsigned NOT, the mathematical complement is 65535 minus the mask. Signed NOT and arithmetic right shift require an explicit signed representation and are outside this example.
• OR cannot generally be replaced by addition: adding a flag twice can carry. A general OR implementation must preserve each bit present in either operand.