Compute logical AND and bitwise AND for up to 4 inputs — see truth tables, bit-by-bit visualization, binary/hex output, and Boolean algebra laws.
The AND operation is one of the most fundamental building blocks in logic and computing. In Boolean algebra, AND returns true only when every input is true — making it the logical equivalent of "all conditions must be met." In digital circuits, the AND gate is a basic component that appears in everything from simple combinational logic to complex CPU arithmetic units.
At the bitwise level, AND operates on each corresponding pair of bits in two integers. It is widely used for bit masking — isolating specific bits in a register or flag set. For example, masking an 8-bit value with 0x0F (00001111) extracts the lower nibble by zeroing out the upper four bits, a technique central to low-level programming, networking (subnet masks), and graphics processing.
This calculator handles both logical and bitwise AND for up to four inputs. In bitwise mode you can choose 4-, 8-, 16-, or 32-bit width and see the result in decimal, binary, and hexadecimal along with a colour-coded bit-by-bit visualisation. Preset buttons cover common cases like flag masking and single-bit checks. The truth-table reference and Boolean-algebra-laws table make this a handy study companion for anyone learning digital logic, discrete maths, or embedded programming.
Manually ANDing multi-bit numbers means writing out binary columns and comparing each pair — slow and easy to mis-align. This calculator instantly returns results in decimal, binary, and hex, with a colour-coded bit-by-bit breakdown that shows exactly which bits survive. Embedded developers use it to verify bitmask logic, networking students check subnet masks, and CS learners explore Boolean algebra laws without pencil-and-paper drudgery.
Logical AND: T iff all inputs T | Bitwise AND: result bit is 1 iff both input bits are 1
Result: 8 (0b1000)
AND each bit pair: 1&1=1, 0&1=0, 1&0=0, 0&0=0 → 1000 = 8 in decimal.
At the transistor level, an AND gate outputs high only when both inputs are high. Modern CPUs contain billions of AND gates wired into adders, multiplexers, and control logic. When you write `a & b` in code, the processor lines up the binary representations and feeds each bit pair through an AND gate in parallel — the entire operation completes in a single clock cycle regardless of bit width. This parallelism is what makes bitwise operations so fast compared to multiplication or division.
The most common use of bitwise AND is **masking**: extracting a subset of bits from a larger value. For example, `color & 0xFF` isolates the lowest 8 bits (the blue channel in a 32-bit ARGB colour). Network engineers AND an IP address with a subnet mask to determine the network prefix: `192.168.1.100 & 255.255.255.0 = 192.168.1.0`. Flags and permissions are stored as packed bits and tested with AND: `if (flags & READ_PERMISSION)` checks a single bit without disturbing the others.
In formal Boolean algebra, AND corresponds to logical conjunction (∧). Key identities include the **idempotent law** (A ∧ A = A), **identity** (A ∧ 1 = A), **annihilation** (A ∧ 0 = 0), and **De Morgan's theorem** (¬(A ∧ B) = ¬A ∨ ¬B). Digital-logic designers simplify circuits using these identities and Karnaugh maps. AND gates combine with OR, NOT, and XOR gates to build every combinational and sequential circuit, from simple decoders to complete ALUs.
Most programming languages provide two distinct operators: `&&` (logical AND) and `&` (bitwise AND). Logical AND short-circuits — if the first operand is false, the second is never evaluated. Bitwise AND always evaluates both operands and operates on every bit. Confusing the two is a classic bug: `if (x & 2)` tests a single bit but returns the masked value (which could be 2, not 1). In C-derived languages, use `!= 0` or `!!` to convert a bitwise result to a clean boolean when needed.
Logical AND evaluates boolean true/false and short-circuits. Bitwise AND operates on each bit position independently and always evaluates both operands.
Because AND with 1 preserves a bit and AND with 0 clears it, so a mask selects exactly the bits you want. Use this as a practical reminder before finalizing the result.
Yes — A AND B always equals B AND A, for both logical and bitwise operations. Keep this note short and outcome-focused for reuse.
NOT(A AND B) = (NOT A) OR (NOT B). This lets you rewrite AND expressions using OR and negation.
AND is associative, so (A AND B) AND C equals A AND (B AND C). The result is 1 only if ALL inputs are 1.
1 (true). A AND 1 = A for any A — the all-ones mask preserves the value unchanged.