Bits across languages

Python · flags/flags.py

"""One user's settings kept in a single 32-bit mask: each bit position is one flag."""

DARK_MODE, EMAIL_ALERTS, SMS_ALERTS, TWO_FACTOR, BETA = 0, 1, 2, 3, 31
NAMES = {DARK_MODE: "dark mode", EMAIL_ALERTS: "email alerts", SMS_ALERTS: "SMS alerts", TWO_FACTOR: "two-factor", BETA: "beta"}


def show(step, flags):
    print(f"{step:<22}{flags:>12}  {flags:032b}")


flags = 0
flags |= 1 << DARK_MODE  # set a bit: OR with its mask
flags |= 1 << SMS_ALERTS
flags |= 1 << BETA
show("set dark, SMS, beta", flags)
flags &= ~(1 << SMS_ALERTS)  # clear a bit: AND with the mask inverted
show("clear SMS", flags)
flags ^= 1 << EMAIL_ALERTS  # toggle a bit: XOR with its mask
show("toggle email", flags)

on = [name for bit, name in NAMES.items() if (flags >> bit) & 1]
print(f"on: {', '.join(on)}")
print(f"flags on: {flags.bit_count()}   highest bit on: {flags.bit_length() - 1}")
print(f"beta tested with > 0: {(flags & (1 << BETA)) > 0}")

set dark, SMS, beta     2147483653  10000000000000000000000000000101
clear SMS               2147483649  10000000000000000000000000000001
toggle email            2147483651  10000000000000000000000000000011
on: dark mode, email alerts, beta
flags on: 3   highest bit on: 31
beta tested with > 0: True

JavaScript · flags/flags.mjs

// One user's settings kept in a single 32-bit mask: each bit position is one flag.
const DARK_MODE = 0, EMAIL_ALERTS = 1, SMS_ALERTS = 2, TWO_FACTOR = 3, BETA = 31;
const NAMES = new Map([[DARK_MODE, "dark mode"], [EMAIL_ALERTS, "email alerts"], [SMS_ALERTS, "SMS alerts"], [TWO_FACTOR, "two-factor"], [BETA, "beta"]]);

function show(step, flags) {
  const bits = (flags >>> 0).toString(2).padStart(32, "0"); // >>> 0 reads the 32 bits as unsigned
  console.log(`${step.padEnd(22)}${String(flags).padStart(12)}  ${bits}`);
}

let flags = 0;
flags |= 1 << DARK_MODE; // set a bit: OR with its mask
flags |= 1 << SMS_ALERTS;
flags |= 1 << BETA;
show("set dark, SMS, beta", flags);
flags &= ~(1 << SMS_ALERTS); // clear a bit: AND with the mask inverted
show("clear SMS", flags);
flags ^= 1 << EMAIL_ALERTS; // toggle a bit: XOR with its mask
show("toggle email", flags);

const on = [...NAMES].filter(([bit]) => (flags >>> bit) & 1).map(([, name]) => name);
console.log(`on: ${on.join(", ")}`);
let count = 0;
for (let bit = 0; bit < 32; bit++) count += (flags >>> bit) & 1; // JavaScript has no built-in bit count
console.log(`flags on: ${count}   highest bit on: ${31 - Math.clz32(flags)}`);
console.log(`beta tested with > 0: ${(flags & (1 << BETA)) > 0}`);

set dark, SMS, beta    -2147483643  10000000000000000000000000000101
clear SMS              -2147483647  10000000000000000000000000000001
toggle email           -2147483645  10000000000000000000000000000011
on: dark mode, email alerts, beta
flags on: 3   highest bit on: 31
beta tested with > 0: false

Java · compiled/Flags.java

// One user's settings kept in a single 32-bit mask: each bit position is one flag.
import java.util.StringJoiner;

public class Flags {
    static final int DARK_MODE = 0, EMAIL_ALERTS = 1, SMS_ALERTS = 2, TWO_FACTOR = 3, BETA = 31;
    static final int[] BITS = {DARK_MODE, EMAIL_ALERTS, SMS_ALERTS, TWO_FACTOR, BETA};
    static final String[] NAMES = {"dark mode", "email alerts", "SMS alerts", "two-factor", "beta"};

    static void show(String step, int flags) {
        String bits = String.format("%32s", Integer.toBinaryString(flags)).replace(' ', '0');
        System.out.printf("%-22s%12d  %s%n", step, flags, bits);
    }

    public static void main(String[] args) {
        int flags = 0;
        flags |= 1 << DARK_MODE; // set a bit: OR with its mask
        flags |= 1 << SMS_ALERTS;
        flags |= 1 << BETA;
        show("set dark, SMS, beta", flags);
        flags &= ~(1 << SMS_ALERTS); // clear a bit: AND with the mask inverted
        show("clear SMS", flags);
        flags ^= 1 << EMAIL_ALERTS; // toggle a bit: XOR with its mask
        show("toggle email", flags);

        StringJoiner on = new StringJoiner(", ");
        for (int k = 0; k < BITS.length; k++) {
            if (((flags >>> BITS[k]) & 1) != 0) on.add(NAMES[k]);
        }
        System.out.println("on: " + on);
        System.out.println("flags on: " + Integer.bitCount(flags) + "   highest bit on: " + (31 - Integer.numberOfLeadingZeros(flags)));
        System.out.println("beta tested with > 0: " + ((flags & (1 << BETA)) > 0));
    }
}

C++ · compiled/flags.cpp

// One user's settings kept in a single 32-bit mask: each bit position is one flag.
#include <bit>
#include <cstdint>
#include <print>
#include <string>
#include <utility>
#include <vector>

constexpr int DARK_MODE = 0, EMAIL_ALERTS = 1, SMS_ALERTS = 2, TWO_FACTOR = 3, BETA = 31;
const std::vector<std::pair<int, std::string>> NAMES = {
    {DARK_MODE, "dark mode"}, {EMAIL_ALERTS, "email alerts"}, {SMS_ALERTS, "SMS alerts"}, {TWO_FACTOR, "two-factor"}, {BETA, "beta"}};

void show(const std::string& step, std::uint32_t flags) {
    std::println("{:<22}{:>12}  {:032b}", step, flags, flags);
}

int main() {
    std::uint32_t flags = 0;  // unsigned: bit 31 is just another bit
    flags |= 1u << DARK_MODE;  // set a bit: OR with its mask
    flags |= 1u << SMS_ALERTS;
    flags |= 1u << BETA;
    show("set dark, SMS, beta", flags);
    flags &= ~(1u << SMS_ALERTS);  // clear a bit: AND with the mask inverted
    show("clear SMS", flags);
    flags ^= 1u << EMAIL_ALERTS;  // toggle a bit: XOR with its mask
    show("toggle email", flags);

    std::string on;
    for (const auto& [bit, name] : NAMES) {
        if ((flags >> bit) & 1u) on += (on.empty() ? "" : ", ") + name;
    }
    std::println("on: {}", on);
    std::println("flags on: {}   highest bit on: {}", std::popcount(flags), std::bit_width(flags) - 1);
    std::println("beta tested with > 0: {}", (flags & (1u << BETA)) > 0);
}

Go · compiled/flags.go

// One user's settings kept in a single 32-bit mask: each bit position is one flag.
package main

import (
	"fmt"
	"math/bits"
	"strings"
)

const (
	DarkMode    = 0
	EmailAlerts = 1
	SMSAlerts   = 2
	TwoFactor   = 3
	Beta        = 31
)

var names = []struct {
	bit  int
	name string
}{{DarkMode, "dark mode"}, {EmailAlerts, "email alerts"}, {SMSAlerts, "SMS alerts"}, {TwoFactor, "two-factor"}, {Beta, "beta"}}

func show(step string, flags uint32) {
	fmt.Printf("%-22s%12d  %032b\n", step, flags, flags)
}

func main() {
	var flags uint32       // unsigned: bit 31 is just another bit
	flags |= 1 << DarkMode // set a bit: OR with its mask
	flags |= 1 << SMSAlerts
	flags |= 1 << Beta
	show("set dark, SMS, beta", flags)
	flags &^= 1 << SMSAlerts // clear a bit: Go's AND NOT operator
	show("clear SMS", flags)
	flags ^= 1 << EmailAlerts // toggle a bit: XOR with its mask
	show("toggle email", flags)

	var on []string
	for _, f := range names {
		if (flags>>f.bit)&1 != 0 {
			on = append(on, f.name)
		}
	}
	fmt.Println("on:", strings.Join(on, ", "))
	fmt.Printf("flags on: %d   highest bit on: %d\n", bits.OnesCount32(flags), bits.Len32(flags)-1)
	fmt.Println("beta tested with > 0:", flags&(1<<Beta) > 0)
}

Python · shifts/shifts.py

"""Shifting a negative number, and shifting 1 by 31 and 32 places, in Python."""

x = -7
rows = [
    ("-7 >> 1", x >> 1),  # right shift rounds down
    ("-7 // 2", x // 2),  # so does //, Python's integer division
    ("-7 >>> 1 (32 bits)", (x & 0xFFFFFFFF) >> 1),  # no >>> operator: mask to 32 bits, then shift
    ("1 << 31", 1 << 31),
    ("1 << 32", 1 << 32),
]
for label, value in rows:
    print(f"{label:<20}{value}")

-7 >> 1             -4
-7 // 2             -4
-7 >>> 1 (32 bits)  2147483644
1 << 31             2147483648
1 << 32             4294967296

JavaScript · shifts/shifts.mjs

// Shifting a negative number, and shifting 1 by 31 and 32 places, in JavaScript.
const x = -7;
const rows = [
  ["-7 >> 1", x >> 1], // right shift rounds down
  ["-7 / 2", Math.trunc(x / 2)], // integer division rounds towards zero
  ["-7 >>> 1 (32 bits)", x >>> 1], // zero-filling right shift
  ["1 << 31", 1 << 31],
  ["1 << 32", 1 << 32], // the count is taken modulo 32
];
for (const [label, value] of rows) console.log(`${label.padEnd(20)}${value}`);

-7 >> 1             -4
-7 / 2              -3
-7 >>> 1 (32 bits)  2147483644
1 << 31             -2147483648
1 << 32             1

Java · compiled/Shifts.java

// Shifting a negative number, and shifting 1 by 31 and 32 places, in Java.
public class Shifts {
    static void row(String label, int value) {
        System.out.printf("%-20s%d%n", label, value);
    }

    public static void main(String[] args) {
        int x = -7, one = 1, count = 32;
        row("-7 >> 1", x >> 1); // right shift rounds down
        row("-7 / 2", x / 2); // integer division rounds towards zero
        row("-7 >>> 1 (32 bits)", x >>> 1); // zero-filling right shift
        row("1 << 31", one << 31);
        row("1 << 32", one << count); // an int shift uses only the low 5 bits of the count
    }
}

C++ · compiled/shifts.cpp

// Shifting a negative number, and shifting 1 by 31 places, in C++ (shift32.cpp tries 32).
#include <cstdint>
#include <print>

void row(const char* label, auto value) {
    std::println("{:<20}{}", label, value);
}

int main() {
    int x = -7, one = 1;
    row("-7 >> 1", x >> 1);  // right shift rounds down (defined since C++20)
    row("-7 / 2", x / 2);  // integer division rounds towards zero
    row("-7 >>> 1 (32 bits)", static_cast<std::uint32_t>(x) >> 1);  // no >>>: shift the unsigned value
    row("1 << 31", one << 31);  // the 1 moves into the sign bit: the lowest int
}

C++, by 32 · compiled/shift32.cpp

// Shifting a 32-bit int by 32 places: undefined behaviour in every version of C++.
#include <print>

int main() {
    int one = 1, count = 32;
    std::println("1 << 32 = {}", one << count);
}

Go · compiled/shifts.go

// Shifting a negative number, and shifting 1 by 31 and 32 places, in Go.
package main

import "fmt"

func row(label string, value any) {
	fmt.Printf("%-20s%v\n", label, value)
}

func main() {
	var x, one int32 = -7, 1
	count := 32
	row("-7 >> 1", x>>1)                    // right shift rounds down
	row("-7 / 2", x/2)                      // integer division rounds towards zero
	row("-7 >>> 1 (32 bits)", uint32(x)>>1) // no >>>: shift the unsigned value
	row("1 << 31", one<<31)                 // int32 wraps around
	row("1 << 32", one<<count)              // no limit on the count: every bit is shifted out
	row("1 << 32 as int", 1<<count)         // a plain int has 64 bits here
}

Python · precedence/precedence.py

"""Two bit expressions without parentheses, as Python reads them."""

x, i = 6, 2
print("x & 1 == 0  ", x & 1 == 0)  # meant: is x even?
print("1 << i + 1  ", 1 << i + 1)  # meant: the mask of bit i + 1

x & 1 == 0   True
1 << i + 1   8

JavaScript · precedence/precedence.mjs

// Two bit expressions without parentheses, as JavaScript reads them.
const x = 6, i = 2;
console.log(`x & 1 == 0   ${x & 1 == 0}`); // meant: is x even?
console.log(`1 << i + 1   ${1 << i + 1}`); // meant: the mask of bit i + 1

x & 1 == 0   0
1 << i + 1   8

Java: AND · compiled/AndPrecedence.java

// x & 1 == 0 without parentheses, as Java reads it.
public class AndPrecedence {
    public static void main(String[] args) {
        int x = 6;
        System.out.println("x & 1 == 0   " + (x & 1 == 0)); // meant: is x even?
    }
}

Java: shift · compiled/ShiftPrecedence.java

// 1 << i + 1 without parentheses, as Java reads it.
public class ShiftPrecedence {
    public static void main(String[] args) {
        int i = 2;
        System.out.println("1 << i + 1   " + (1 << i + 1)); // meant: the mask of bit i + 1
    }
}

C++ · compiled/precedence.cpp

// Two bit expressions without parentheses, as C++ reads them.
#include <print>

int main() {
    int x = 6, i = 2;
    std::println("x & 1 == 0   {}", x & 1 == 0);  // meant: is x even?
    std::println("1 << i + 1   {}", 1 << i + 1);  // meant: the mask of bit i + 1
}

Go · compiled/precedence.go

// Two bit expressions without parentheses, as Go reads them.
package main

import "fmt"

func main() {
	x, i := 6, 2
	fmt.Println("x & 1 == 0  ", x&1 == 0) // meant: is x even?
	fmt.Println("1 << i + 1  ", 1<<i+1)   // meant: the mask of bit i + 1
}

Python · bases/bases.py

"""Binary text in Python: signed digits, a 32-bit pattern, and the way back."""

x = -5
bits = format(x & 0xFFFFFFFF, "032b")  # the 32-bit pattern of x
u = int(bits, 2)  # int() reads the pattern as an unsigned number
rows = [
    ("bin(x)", bin(x)),
    ('format(x, "b")', format(x, "b")),
    ("32-bit pattern", bits),
    ("int(bits, 2)", u),
    ("back to signed", (u ^ 0x80000000) - 0x80000000),
    ('int("1011", 2)', int("1011", 2)),
    ('int("0b1011", 0)', int("0b1011", 0)),
    ("hex(255)", hex(255)),
]
for label, value in rows:
    print(f"{label:<18}{value}")

bin(x)            -0b101
format(x, "b")    -101
32-bit pattern    11111111111111111111111111111011
int(bits, 2)      4294967291
back to signed    -5
int("1011", 2)    11
int("0b1011", 0)  11
hex(255)          0xff

JavaScript · bases/bases.mjs

// Binary text in JavaScript: signed digits, a 32-bit pattern, and the way back.
const x = -5;
const bits = (x >>> 0).toString(2).padStart(32, "0"); // the 32-bit pattern of x
const rows = [
  ["x.toString(2)", x.toString(2)],
  ["32-bit pattern", bits],
  ["parseInt(bits, 2)", parseInt(bits, 2)], // read as an unsigned number
  ["back to signed", parseInt(bits, 2) | 0], // | 0 converts to a signed 32-bit integer
  ['parseInt("1011", 2)', parseInt("1011", 2)],
  ['Number("0b1011")', Number("0b1011")],
  ["(255).toString(16)", (255).toString(16)],
];
for (const [label, value] of rows) console.log(`${label.padEnd(21)}${value}`);

x.toString(2)        -101
32-bit pattern       11111111111111111111111111111011
parseInt(bits, 2)    4294967291
back to signed       -5
parseInt("1011", 2)  11
Number("0b1011")     11
(255).toString(16)   ff

Java · compiled/Bases.java

// Binary text in Java: signed digits, a 32-bit pattern, and the way back.
public class Bases {
    static void row(String label, Object value) {
        System.out.printf("%-35s%s%n", label, value);
    }

    public static void main(String[] args) {
        int x = -5;
        String bits = Integer.toBinaryString(x); // 32 digits here; pad with zeros when bit 31 is 0
        row("Integer.toString(x, 2)", Integer.toString(x, 2));
        row("Integer.toBinaryString(x)", bits);
        try {
            row("Integer.parseInt(bits, 2)", Integer.parseInt(bits, 2));
        } catch (NumberFormatException e) {
            row("Integer.parseInt(bits, 2)", "NumberFormatException"); // 4294967291 does not fit an int
        }
        row("Integer.parseUnsignedInt(bits, 2)", Integer.parseUnsignedInt(bits, 2));
        row("Integer.parseInt(\"1011\", 2)", Integer.parseInt("1011", 2));
        row("Integer.toHexString(255)", Integer.toHexString(255));
    }
}

C++ · compiled/bases.cpp

// Binary text in C++: signed digits, a 32-bit pattern, and the way back.
#include <bitset>
#include <cstdint>
#include <format>
#include <print>
#include <stdexcept>
#include <string>

void row(const char* label, const auto& value) {
    std::println("{:<31}{}", label, value);
}

int main() {
    int x = -5;
    std::string bits = std::format("{:032b}", static_cast<std::uint32_t>(x));  // the 32-bit pattern of x
    row("std::format(\"{:b}\", x)", std::format("{:b}", x));
    row("32-bit pattern", bits);
    row("std::bitset<32>(x)", std::bitset<32>(x).to_string());
    try {
        row("std::stoi(bits, nullptr, 2)", std::stoi(bits, nullptr, 2));
    } catch (const std::out_of_range&) {
        row("std::stoi(bits, nullptr, 2)", "std::out_of_range");  // 4294967291 does not fit an int
    }
    row("back to signed", static_cast<std::int32_t>(std::stoul(bits, nullptr, 2)));
    row("std::stoi(\"1011\", nullptr, 2)", std::stoi("1011", nullptr, 2));
    row("std::format(\"{:x}\", 255)", std::format("{:x}", 255));
}

Go · compiled/bases.go

// Binary text in Go: signed digits, a 32-bit pattern, and the way back.
package main

import (
	"fmt"
	"strconv"
)

func row(label string, value any) {
	fmt.Printf("%-33s%v\n", label, value)
}

func main() {
	var x int32 = -5
	bits := fmt.Sprintf("%032b", uint32(x)) // the 32-bit pattern of x
	row(`fmt.Sprintf("%b", x)`, fmt.Sprintf("%b", x))
	row("32-bit pattern", bits)
	if _, err := strconv.ParseInt(bits, 2, 32); err != nil {
		row("strconv.ParseInt(bits, 2, 32)", err) // 4294967291 does not fit 32 signed bits
	}
	u, _ := strconv.ParseUint(bits, 2, 32)
	row("back to signed", int32(u))
	n, _ := strconv.ParseInt("1011", 2, 64)
	row(`strconv.ParseInt("1011", 2, 64)`, n)
	row("strconv.FormatInt(255, 16)", strconv.FormatInt(255, 16))
}