How do you set and check a single bit in a programming language that does not support bitwise operations?

Question

I'm using a programming language (more a scripting language) that does not support any bitwise operators like AND, OR, XOR, NOT (and shift as well).

Common arithmetic and logical operations like + - * / %>>= < <= == !=, logical AND, OR, NOT and control flow (while, for, if,...) are supported however. It is like a "subset of C", but without these binary operators. My question does not target that particular language anyway.

I was wondering if there is any (mathematical ?) way to set and check a bit at a specific position in a programming language that does not support bitwise operations :

a = 0; //00000000b
a = togglebit(a, 5); //00100000b
a = togglebit(a, 2); //00100100b
a = 0xFE; //11111110b
bool result = checkbit(a, 4); //true

For example, there is a way to perform a left or right binary shift using integer multiplication or division :

a = a * 2; //similar to left shift : a = a << 1;
a = a / 2; //similar to right shift : a = a >> 1;

I'm looking for something similar but for setting or checking a flag.

• thorsten müller: The Wikipedia article on bitwise operations explains the mathematical equivalents, mostly they seem to be based on some modulo2 operations.

Answer 1

To check the n th bit, shift right n times. If the bit is set, the result will be odd (numbers are odd if and only if their final bit is 1.)

function checkbit(a, n)
 n times:
 a = a / 2 (integer division)
 return a % 2
end

To set the n th bit, add 2^n only if the bit is not yet set.

function pow2(n): (returns 2^n)
 result = 1
 n times: result = result * 2
 return result
end
function setbit(a, n)
 if checkbit(a, n):
 return a
 else:
 return a + pow2(n)
end

Toggling it is similar, but we subtract if the bit is already set:

function togglebit(a, n)
 if checkbit(a, n):
 return a - pow2(n)
 else:
 return a + pow2(n)
end

Bitwise negation depends on how big your bitmasks are; specifically, the bitwise negative of an n-bit bitmask a is 2^n-1-a. If you're using 16 bits, it would be 65535-a.