Introductory motivation

The grid method can be introduced by thinking about how to add up the number of points in a regular array, for example the number of squares of chocolate in a chocolate bar. As the size of the calculation becomes larger, it becomes easier to start counting in tens; and to represent the calculation as a box which can be sub-divided, rather than drawing a multitude of dots.^[2][3]

At the simplest level, pupils might be asked to apply the method to a calculation like 3 × 17. Breaking up ("partitioning") the 17 as (10 + 7), this unfamiliar multiplication can be worked out as the sum of two simple multiplications:

×	10	7
3	30	21

so 3 × 17 = 30 + 21 = 51.

This is the "grid" or "boxes" structure which gives the multiplication method its name.

Faced with a slightly larger multiplication, such as 34 × 13, pupils may initially be encouraged to also break this into tens. So, expanding 34 as 10 + 10 + 10 + 4 and 13 as 10 + 3, the product 34 × 13 might be represented:

×	10	10	10	4
10	100	100	100	40
3	30	30	30	12

Totalling the contents of each row, it is apparent that the final result of the calculation is (100 + 100 + 100 + 40) + (30 + 30 + 30 + 12) = 340 + 102 = 442.

Standard blocks

Once pupils have become comfortable with the idea of splitting the whole product into contributions from separate boxes, it is a natural step to group the tens together, so that the calculation 34 × 13 becomes

×	30	4
10	300	40
3	90	12

giving the addition

300 40 90 + 12 ———— 442

so 34 × 13 = 442.

This is the most usual form for a grid calculation. In countries such as the UK where teaching of the grid method is usual, pupils may spend a considerable period of time regularly setting out calculations like the above, until the method is entirely comfortable and familiar.

Larger numbers

The grid method extends straightforwardly to calculations involving larger numbers.

For example, to calculate 345 × 28, the student could construct the grid with six easy multiplications

×	300	40	5
20	6000	800	100
8	2400	320	40

to find the answer 6900 + 2760 = 9660.

However, by this stage (at least in standard current UK teaching practice) pupils may be starting to be encouraged to set out such a calculation using the traditional long multiplication form without having to draw up a grid.

Traditional long multiplication can be related to a grid multiplication in which only one of the numbers is broken into tens and units parts to be multiplied separately:

×	345
20	6900
8	2760

The traditional method is ultimately faster and much more compact; but it requires two significantly more difficult multiplications which pupils may at first struggle with . Compared to the grid method, traditional long multiplication may also be more abstract and less manifestly clear , so some pupils find it harder to remember what is to be done at each stage and why . Pupils may therefore be encouraged for quite a period to use the simpler grid method alongside the more efficient traditional long multiplication method, as a check and a fall-back.

Fractions

While not normally taught as a standard method for multiplying fractions, the grid method can readily be applied to simple cases where it is easier to find a product by breaking it down.

For example, the calculation 21/2 × 11/2 can be set out using the grid method

×	2	1/2
1	2	1/2
1/2	1	1/4

to find that the resulting product is 2 + 1/2 + 1 + 1/4 = 33/4

Algebra

The grid method can also be used to illustrate the multiplying out of a product of binomials, such as (a + 3)(b + 2), a standard topic in elementary algebra (although one not usually met until secondary school):

×	a	3
b	ab	3b
2	2a	6

Thus (a + 3)(b + 2) = ab + 3b + 2a + 6.

Computing

32-bit CPUs usually lack an instruction to multiply two 64-bit integers. However, most CPUs support a "multiply with overflow" instruction, which takes two 32-bit operands, multiplies them, and puts the 32-bit result in one register and the overflow in another, resulting in a carry. For example, these include the umull instruction added in the ARMv4t instruction set or the pmuludq instruction added in SSE2 which operates on the lower 32 bits of an SIMD register containing two 64-bit lanes.

On platforms that support these instructions, a slightly modified version of the grid method is used. The differences are:

1. Instead of operating on multiples of 10, they are operated on 32-bit integers.
2. Instead of higher bits being multiplied by ten, they are multiplied by 0x100000000. This is usually done by either shifting to the left by 32 or putting the value into a specific register that represents the higher 32 bits.
3. Any values that lie above the 64th bit are truncated. This means that multiplying the highest bits is not required, because the result will be shifted out of the 64-bit range. This also means that only a 32-bit multiply is required for the higher multiples.

×	b	a
d	-	ad
c	bc	ac

This would be the routine in C:

#include <stdint.h>

uint64_t multiply(uint64_t ab, uint64_t cd)
{
    /* These shifts and masks are usually implicit, as 64-bit integers
     * are often passed as 2 32-bit registers. */
    uint32_t b = ab >> 32, a = ab & 0xFFFFFFFF;
    uint32_t d = cd >> 32, c = cd & 0xFFFFFFFF;

    /* multiply with overflow */
    uint64_t ac = (uint64_t)a * (uint64_t)c;
    uint32_t high = ac >> 32; /* overflow */
    uint32_t low = ac & 0xFFFFFFFF;

    /* 32-bit multiply and add to high bits */
    high += (a * d); /* add ad */
    high += (b * c); /* add bc */
    /* multiply by 0x100000000 (via left shift) and add to the low bits with a binary or. */
    return ((uint64_t)high << 32) | low;
}

This would be the routine in ARM assembly:

multiply:
        @ a = r0
        @ b = r1
        @ c = r2
        @ d = r3
        push    {r4, lr}        @ backup r4 and lr to the stack
        umull   r12, lr, r2, r0 @ multiply r2 and r0, store the result in r12 and the overflow in lr
        mla     r4, r2, r1, lr  @ multiply r2 and r1, add lr, and store in r4
        mla     r1, r3, r0, r4  @ multiply r3 and r0, add r4, and store in r1
                                @ The value is shifted left implicitly because the
                                @ high bits of a 64-bit integer are returned in r1.
        mov     r0, r12         @ Set the low bits of the return value to r12 (ac)
        pop     {r4, lr}        @ restore r4 and lr from the stack
        bx      lr              @ return the low and high bits in r0 and r1 respectively