Math

This program is a multi-section mathematics toolkit covering eight topics: greatest common divisor (Euclidean algorithm), least common multiple, prime factorisation, quadratic equations, zero-finding for functions, polynomial evaluation, polynomial multiplication, and function plotting. The zero-finding routine (lines 1440–1750) uses a sign-change bisection method with user-supplied interval, step size, and epsilon tolerance. The polynomial evaluator (lines 1940–1990) applies Horner’s method for efficient computation. The function plotter (lines 2820–2890) maps mathematical coordinates to the 64×44 pixel display grid using scaling factors MX and MY, and plots the hardcoded function sin(x)+sin(2x).

---

Program Analysis

Program Structure

The program is organised as a menu dispatcher with eight numbered sections. Lines 2–120 display the main menu, line 150 calls the key-reading subroutine at 8800, and lines 155–190 dispatch to each section via a chain of IF … THEN GOTO statements. Each section ends by calling the “press a key” subroutine at 9000, which offers return-to-index or re-run of the current section.

Menu Option	Topic	Start Line
1	Greatest Common Divisor	200
2	Smallest Common Multiple	400
3	Prime Factoring	700
4	Quadratic Equation	1000
5	Zeroes of a Function	1300
6	Value of a Function	1800
7	Polynomial (multiplication)	2100
8	Plot of Functions	2500

Key Input Subroutine (line 8800)

The subroutine at line 8800 polls INKEY$ in a tight loop, rejecting any character outside “1”–”8″. Once a valid digit is detected it reads INKEY$ a second time at line 8810 with LET W=VAL INKEY$ to convert it to a number. This introduces a potential race condition: if the key is released between lines 8800 and 8810, INKEY$ returns an empty string and VAL "" yields 0, sending the dispatcher to an unmatched branch. In practice SLOW mode makes this unlikely but it is a latent bug.

Greatest Common Divisor (lines 200–330)

The implementation is the classic Euclidean algorithm: compute quotient Q=INT(A/B), remainder R=A-Q*B, reassign A=B, B=R, and loop while R>0. The result is left in A and printed as “LCD=” (a labelling quirk — the correct abbreviation for Largest Common Divisor/Greatest Common Divisor is GCD or HCF).

Smallest Common Multiple (lines 400–620)

The SCM routine uses brute-force trial: starting from X=A, it increments X by 1 until X is divisible by all three inputs A, B, and C. Each divisibility test restarts the scan from the current X (via GOTO 510) rather than continuing forward, which is correct behaviour. This approach is slow for large inputs but straightforward.

Prime Factorisation (lines 700–930)

The routine at line 800 takes the absolute value of the input, then iterates I from 2 to the original value Z. For each candidate divisor, an inner loop repeatedly divides and counts the multiplicity N. A running product T tracks how much of the number has been accounted for; when T=E (the original absolute value) the outer FOR loop is exited early via GOTO 910. Negative inputs are handled by printing a leading minus sign before the factorisation.

Quadratic Equation (lines 1000–1220)

The discriminant is computed as Q=B*B-4*A*C. If negative, “NO REAL SOLUTION” is printed. Otherwise the formula is evaluated as Q=SQR Q/(2*A) and C=-B/(2*A), giving X1=C+Q and X2=C-Q. Note that operator precedence means SQR Q/(2*A) is parsed as (SQR Q)/(2*A), which is the intended formula.

Zero-Finding by Bisection (lines 1300–1780)

This section implements a sign-change bisection search. The outer scan (lines 1440–1600) steps across the interval [XA, XE] with step H, calling the function subroutine FCT at line 1610 and watching for a sign change in Y. When a sign change is detected, the bisection refinement subroutine SFZ at line 1640 narrows the bracket until ABS(Y) < E. The function itself is hardcoded at line 1620 as Y = X³ - 4X² - 11X + 30, which has roots at x = -3, 2, and 5. FAST mode is engaged for the numerical search and SLOW restored afterwards.

Subroutine addresses are stored in variables (LET FCT=1610, LET SFZ=1640) and called with GOSUB FCT — a notable technique exploiting the fact that GOSUB accepts a numeric variable as its target line number.

Polynomial Evaluation — Horner’s Method (lines 1800–2090)

Coefficients are stored in array W() with W(1) holding the constant term A(0). The evaluation at lines 1940–1990 applies Horner’s scheme: initialise with the leading coefficient, then repeatedly multiply by X and add the next coefficient working down to degree 1, finally adding W(1). This minimises multiplications compared to naive power evaluation.

Polynomial Multiplication (lines 2100–2495)

Two polynomials are entered separately. The first polynomial’s coefficients are copied into array A() of size K+1. The product array E() is initialised to zero, then the convolution sum E(I+J-1) += W(I)*A(J) is computed for all pairs (I,J). The result is printed as a list of coefficients E(0) through E(K+N). This is a correct discrete convolution of the coefficient arrays.

Function Plotter (lines 2500–2950)

The plotter draws axes at pixel position (31, 22) — roughly centred on the 64×44 display. Scaling factors are computed as MX=63/|XE-XA| and MY=43/|YE-YA|. The plotted function is hardcoded at line 2840 as Y = SIN(X) + SIN(2*X). Coordinate transformation applies at lines 2850–2860: X = X*MX + X0, Y = Y*MY + Y0. A bounds check at line 2870 prevents PLOT errors for out-of-range points.

Navigation Subroutine (line 9000)

The subroutine at 9000 displays a two-line prompt, waits with PAUSE 30 to debounce, then enters an INKEY$ poll loop. Pressing “R” returns to the main menu index (line 5, which is the REM crediting the source book). Any other key returns to the caller for re-entry of the same section. Line 9040 (SAVE "1024%1") is unreachable dead code following the conditional returns.

Notable Techniques and Anomalies

• Variable-target GOSUB FCT (lines 1450, 1500, 1540, 1670) stores line numbers in variables — an efficient and flexible dispatch mechanism.
• FAST/SLOW mode switching (lines 1310 and 1760) is used only in the zero-finding section, where the iterative bisection benefits most from faster execution.
• The SCM section accepts three inputs but the algorithm restarts from X=A rather than incrementing by A; for large coprime numbers this will be very slow.
• The prime factorisation loop iterates FOR I=2 TO Z using the original (potentially large) value of Z rather than the progressively reduced quotient, making it inefficient for numbers with large prime factors.
• The key-reading race condition at lines 8800–8810 (double INKEY$ read) could return W=0, causing all dispatch conditions at lines 155–190 to fail silently and loop back to the menu display.
• Section 6 (“Value of a Function”) shares the polynomial input subroutine code with section 7 but duplicates it at lines 1830–1930 rather than sharing lines 2130–2230, increasing program size unnecessarily.