[8.1.7] Library Routines

[8.1.7] Library Routines: MOD, DIV, ROUND, RANDOM

What this page covers

This page explains how to understand and use four common library routines you will meet in IGCSE programming tasks: MOD, DIV, ROUND, and RANDOM. These are building blocks for many algorithms, such as timetabling with remainders, formatting numbers to a set number of decimal places, and creating fair simulations or games. You will learn what each routine does, typical exam-ready patterns, and pitfalls to avoid. Where helpful, we compare outcomes using small, concrete examples and realistic scenarios.

Quick reference

Using DIV and MOD together

DIV and MOD are paired operations that fully describe a division of one integer by another: dividend = (divisor × (dividend DIV divisor)) + (dividend MOD divisor). This is extremely useful when splitting things into fixed-size groups and finding the remainder. Remember that DIV gives the count of full groups, while MOD gives what is left over.

• Full groups vs leftovers
• Timetabling scenario
• Edge case: exact division

Using ROUND accurately

ROUND converts a real to the nearest integer or to a specified number of decimal places. In exam contexts the instruction will usually be clear, such as “round to 2 decimal places”. If the digit after your last kept place is 5 or more, round up; otherwise round down. Show working when needed, and be careful with negative numbers and money formatting.

• Whole-number rounding
• To 2 decimal places (prices)
• Edge case: .5 and negatives

Using RANDOM for fair selection

RANDOM provides unpredictable values suitable for simulations. In many tasks, RANDOM() gives a real number in the interval [0, 1). To obtain integers in a range, either use an integer random routine if available (e.g. RANDOM_INT(low, high)) or scale a [0,1) value to the required bounds. State clearly whether the bounds are inclusive.

• Real in [0,1)
• Integer 1..6 (fair die)
• Edge case: seeding and repeatable tests

Combining routines in real tasks

These routines are often used together. For example, a shop might calculate how many complete packs are needed (DIV), how many items are leftover (MOD), offer a prize to a random customer (RANDOM), and display the total cost rounded to two decimal places (ROUND). Thinking in these small steps makes problems manageable and your solutions easier to explain in exams.

Deep Dive: Rounding rules

When questions involve money or a specified number of decimal places, the expected rule is usually “round half up”. If you are using a language routine that behaves differently by default, either show your working conceptually or use an alternative that matches the question. In pseudocode, ROUND(value, dp) is interpreted as “nearest” with .5 rounding up unless told otherwise.

Deep Dive: Pseudo-randomness and fairness

Computers generate pseudo-random numbers by algorithm. For fair outcomes (e.g. a die), ensure the mapping from the random value to outcomes is even. Avoid off-by-one errors when scaling, and confirm whether the upper bound is included.

Copy-ready reminder snippets

// CAIE-style pseudocode reminders
// Packs and leftovers
packs ← items DIV packSize
leftover ← items MOD packSize

// Rounding
price2dp ← ROUND(price, 2)

// Random checks
x ← RANDOM()           // 0 ≤ x < 1
IF x < 0.25 THEN
    OUTPUT "Prize"
ENDIF

// Die 1..6 (if RANDOM() only)
roll ← 1 + INT(RANDOM() * 6)

# Python reminders (mapping to CAIE ideas)
# DIV ↔ //, MOD ↔ %, ROUND ↔ round(x, dp), RANDOM ↔ random.random()/randint()
import random

packs = items // packSize
leftover = items % packSize
price2dp = round(price, 2)
x = random.random()        # 0 ≤ x < 1
roll = random.randint(1, 6)  # inclusive 1..6