Math II

Multiple math routines.

• Plot = Super Function Plot – See REMs for instructions
• RSC = Scaling Program
• RUKU = 4th Order Runge Kutta
• RTFND = Transcendental Equation Solution
• CMAR = Doesn’t run

Math II is a collection of five mathematical routines for the ZX81/TS1000: a complex number calculator (CMAR), a function plotter (Super Function Plot), a scale-interval calculator (RSC), a fourth-order Runge-Kutta ODE integrator (RUKU), and a transcendental equation solver (RTFND). The function plotter compiles a 386-byte machine code routine into RAM starting at address 16514, allowing subsequent plotting via RAND USR 16514 without re-running the BASIC. RUKU implements the classical four-stage Runge-Kutta method, accepting the derivative function as a string evaluated with VAL R$ at runtime. The complex number calculator (CMAR) stores a history of operands in array X(8) and supports 12 operations (selected by jumping to line 50*F) including addition, subtraction, multiplication, division, reciprocal, and square root of complex numbers, though the routine is noted as non-functional.

---

Program Analysis

Program Structure

The listing contains five independent programs loaded separately. Each is identified by a REM label at its start. The five components are:

1. CMAR — Complex number calculator (noted as non-functional)
2. Super Function Plot — Graphing utility with machine code compilation
3. RSC — Axis scaling calculator
4. RUKU — Fourth-order Runge-Kutta ODE integrator
5. RTFND — Transcendental equation solver (listing not included)

CMAR — Complex Number Calculator

CMAR uses a single array X(8) as a register stack, storing the current complex number in X(1)/X(2) and history entries in higher slots. The operation selector at line 20 accepts an integer F from 1 to 12, then dispatches via GOTO 50*F, placing each operation’s code at line multiples of 50. This is a compact computed-GOTO idiom that avoids a long IF-THEN chain.

The 12 operations mapped to line numbers are:

Line	Operation
50	Enter R, I (input new complex number)
100	Push history (shift X array up by 2)
150	Swap X and Y registers
200	Store to K, M memory
250	Recall from K, M memory
300	Add: (R+X(3), J+X(4))
350	Subtract: (X(3)−R, X(4)−J)
400	Multiply: (R·X(3)−J·X(4), R·X(4)+J·X(3))
450	Divide: uses D=R²+J² as denominator
500	Reciprocal: (R/D, −J/D)
550	Square root: principal square root formula
600	Real part of square (R²−J²)

Line 74 computes D=R*R+J*J (the modulus squared) immediately after each entry, making it available for division and reciprocal operations. The subroutine at line 1000 shifts the result array down by 2 positions after binary operations, maintaining register-stack semantics. The square root at line 554 uses the standard formula SQR((R+|Z|)/2) with the imaginary part derived as J/(2·re); special-casing for zero is handled at lines 550–553.

Super Function Plot — Machine Code Compilation

This is the most technically sophisticated component. Line 0 contains a long REM statement that encodes a 386-byte machine code routine as character data within the REM body. Lines 2–5 fill the screen rapidly in FAST mode as a side-effect of the initialization. The program then accepts three inputs: a function expression string (e.g., SIN X), a lower X limit, and an upper X limit.

The plotting proceeds in two passes. The first pass (lines 70–110) scans all 64 X values to find the function’s minimum L and maximum H, enabling auto-scaling. The second pass (lines 130–150) uses POKE to write the machine code plot data into RAM starting at address N=16514. Each iteration advances N by 6 bytes.

Key idioms used:

• SGN PI evaluates to 1 — used as a loop start value to avoid the literal digit 1
• CODE "RND" evaluates to 82 (ASCII of ‘R’) — used as an upper loop bound of 64 via CODE "RND" which is actually 82; the loop at line 70 runs TO CODE "RND" which is 82 steps, matching the 63-step increment from line 40 (DX=(A-X)/VAL "63")
• NOT PI evaluates to 0 — used as loop start in the second pass
• CODE "Z" = 90 — used as upper bound for the POKE loop
• VAL "16514", VAL "2", VAL "43-...", VAL "6" — all use VAL of string literals for constants, a memory-saving technique since numeric literals stored in BASIC lines carry a 5-byte floating-point overhead
• UNPLOT NOT USR VAL "16514",RND at line 500 calls the machine code at 16514 via USR; NOT of the return value (typically non-zero) yields 0, so UNPLOT 0,RND is a harmless no-op used purely to trigger the USR call
• GOTO PI*PI at line 600 jumps to approximately line 9 (PI²≈9.87), which rounds down to the nearest existing line

Line 133 computes the Y screen coordinate inline within a VAL string: VAL "43-(H-VAL A$)/(H-L)*43", where A$ holds the function expression. This evaluates the user’s function and scales the result to the 44-row display in a single expression.

Lines 9900–9930 provide a self-listing routine that uses LPRINT and LLIST to produce a hard-copy listing on a printer, repeating 20 times. Line 9999 contains the full user instructions as a REM.

RSC — Scaling Program

RSC computes aesthetically “round” axis tick intervals given a data range and a desired number of intervals. It mirrors standard chart-scaling algorithms:

1. Compute raw interval D=(Y-X)/N
2. Find the order of magnitude E=INT(LN D/LN 10)
3. Normalize to F=D/10^E and snap to 1, 2, 5, or 10 using square-root thresholds (lines 240–260)
4. Compute rounded minimum and maximum bounds aligned to the chosen tick size

The tolerance variable J=D/1E5 guards against floating-point rounding at lines 290 and 320, adjusting boundary indices when the computed value is within J of an integer. The program loops back to line 40 after each result, allowing repeated scaling queries.

RUKU — Fourth-Order Runge-Kutta Integrator

RUKU numerically integrates a first-order ODE dy/dx = f(x,y) using the classical RK4 algorithm. The derivative function is entered as a string in R$ and evaluated at runtime via LET R=VAL R$ at line 1000. The variables X and Y must appear in the function string — they are set directly by the integrator before each GOSUB 1000 call.

The four RK4 stages are computed at lines 270–460:

• K = G·f(F, H)
• L = G·f(F+G/2, H+K/2)
• M = G·f(F+G/2, H+L/2)
• N = G·f(F+G, H+M)
• Update: H = H + K/6 + L/3 + M/3 + N/6

The variable G holds the signed step size (SGN(D-B)*A), allowing integration in either direction. After the main loop, a partial step is taken if the endpoint D is not exactly reached (lines 210–230). A PAUSE 20 at line 450 slows output display between steps. The program loops at line 260 back to the interval prompt, allowing repeated integrations.

Notable Techniques and Anomalies

• The GOTO 50*F dispatch in CMAR is a computed-GOTO pattern that keeps the code compact and eliminates a multi-branch IF structure.
• Super Function Plot’s use of VAL strings for numeric constants throughout is a systematic memory optimization, since BASIC stores each unquoted numeric literal with a 5-byte binary float.
• The machine code written by Super Function Plot is encoded character-by-character in the line 0 REM, a common technique for embedding binary data in BASIC programs.
• The VAL R$ trick in RUKU for runtime function evaluation is a powerful but fragile idiom — it works only because X and Y are simple BASIC variable names accessible in the evaluation context.
• RSC’s use of square-root thresholds (SQR 50, SQR 10, SQR 2) for interval rounding is mathematically elegant: each threshold is the geometric mean of adjacent standard values (5 and 10, 2 and 5, 1 and 2), giving a logarithmically fair rounding rule.
• CMAR is explicitly noted as non-functional; inspection of the code does not reveal an obvious syntax error, but the logic at line 73 prints X(3) and X(4) before they are initialized on first entry, which would display undefined values.