Mandelbrot Generator

This program computes and renders the Mandelbrot set on a 160×160 grid, storing iteration counts as characters in a two-dimensional string array `P$` dimensioned at 161×160. The core iteration loop (lines 200–260) performs up to 128 iterations of the standard complex squaring formula, testing for escape when the squared magnitude exceeds 4. Users enter the southwest corner coordinates and side length of the complex plane region to explore, and the computation can be interrupted mid-run and resumed from the exact row and column where it left off. A main menu (line 1000) offers options to start a new run, save and verify the full program state including UDG data, preview the result with a boundary-detection plot routine, generate a hard-copy printout with character mapping to UDGs, and save or load the `P$` array along with control variables to tape. The save/load system stores up to ten numeric variables — including date fields for month, day, and year — in a separate `V()` array alongside the main data array, enabling interrupted sessions to be resumed later.

---

Program Analysis

Program Structure

The program is organized into well-separated functional blocks, navigated primarily through a central menu at line 1000:

Lines	Purpose
1–20	REM headers and initial jump to setup at line 500
100–310	Core Mandelbrot iteration engine (called as a subroutine from line 660)
400–450	Interrupt handler: displays progress, waits for ENTER or M-for-menu
500–660	Setup: prompts for SW corner coordinates and side length, initializes array
1000–1100	Main menu: dispatches to numbered options
3000	Resume run (menu option 3)
4000–4120	Preview: boundary-detection scatter plot and hard-copy (menu option 4)
5000–5150	Set character range limits for output mapping (menu option 5)
6005–6180	Final hard-copy printout using UDG character mapping (menu option 6)
7000–7140	Save and load P$ array plus control variables to/from tape
8998–9002	Master SAVE block and auto-run loader

Mandelbrot Iteration Core

The iteration loop runs at lines 200–260. For each grid point (M, N), the real coordinate CR and imaginary coordinate CI are computed from the user-supplied origin (AC, BC) and step size GAP (= S/192). The standard recurrence Z → Z² + C is computed in lines 200–220 using a temporary variable R to avoid overwriting ZR before ZI is updated. Escape is detected at line 240 when the squared modulus SZ exceeds 4. The iteration count C is capped at 127 (line 260: IF C<128) and stored as a character code directly into P$(M+1, N+1), using BASIC’s CHR$ to pack the byte.

The outer loop variable M represents rows (imaginary axis) and N columns (real axis), both running 0–159 for a 160×160 grid. The grid is offset by 1 in the string array indices to accommodate 1-based string addressing.

Interruptible Computation and State Preservation

Line 140 checks INKEY$ for ENTER on every inner column iteration, making interruption responsive. When triggered, line 400 displays the current row M and column N, then waits at lines 420–424 for a keypress. The computation can resume at exactly the interrupted cell because FOR M=M TO 159 (line 120) and FOR N=N TO 159 (line 130) re-enter the FOR loops using the current values of M and N. This is a deliberate exploitation of BASIC’s behavior when a FOR variable already holds a value.

Menu Dispatch Technique

The menu at lines 1030–1100 uses a compact dispatch idiom at line 1090:

GO SUB MENU*VAL Z$

Since MENU is set to 1000, pressing keys “3” through “6” causes jumps to GO SUB 3000, GO SUB 4000, GO SUB 5000, and GO SUB 6000 respectively — each a real subroutine entry point. Keys “1” and “2” are handled explicitly before this line, and the guard at line 1080 rejects out-of-range keys, so the multiplication dispatch is always valid when reached. The use of VAL Z$ rather than a direct numeric conversion reflects a memory-saving style common in Spectrum BASIC.

Array Storage Strategy

The main data structure is P$, dimensioned at line 630 as DIM P$(161,160). Each element holds a single character whose ASCII code encodes the iteration count (0–127) or escape marker. This is an efficient way to store a large integer matrix in BASIC: a numeric array of the same size would consume far more memory due to the 5-byte floating-point format per element. At 161×160 bytes, P$ occupies approximately 25,760 bytes of RAM.

Save and Load System

Two complementary tape routines are provided. The quick save at line 1070 saves the whole program with SAVE "MANDEL.20" LINE 1000 plus the UDG character set. The array-only save at lines 7010–7030 stores ten numeric control variables in V() (including month, day, year date fields in V(8)–V(10), and run parameters in V(1)–V(7)) followed by P$(), both verified after saving. The loader at lines 7110–7130 restores all variables and prints the saved date before returning to the menu.

Preview and Hard-Copy Output

The preview routine (lines 4000–4120) scans the P$ array for boundary pixels — cells where the iteration count differs by exactly 1 from either the left or upper neighbor, or equals 128 (the maximum). Boundary points are plotted using PLOT P+40, O, offsetting horizontally to center the 160-column output on the 256-pixel screen. After plotting, a COPY command sends the screen to the printer.

The full hard-copy routine (lines 6005–6180) maps iteration-count ranges to UDG characters using the limits array A(2, LEN F$) set up in the limits subroutine (lines 5000–5150). The output is printed in five horizontal passes (loop variable I 0–4), each 32 characters wide, covering the full 160-column grid. An error message is triggered at line 6080 if any iteration count falls outside all defined ranges.

Notable Anomalies

• Line 100 is targeted by GO SUB 100 at line 660 and by GO TO 100 at line 310, but line 100 does not exist — execution falls through to line 102. This is intentional: the missing line acts as a no-op entry point.
• Line 580 uses lowercase s in LPRINT s while all other variable references use uppercase S. In Spectrum BASIC, variable names are case-sensitive in that lowercase and uppercase are treated as the same variable for numeric scalars, so this is not a functional bug but is inconsistent style.
• The GAP computation at line 620 divides by 192 rather than 160, meaning the displayed region is slightly wider in the imaginary direction than the 160-row grid would suggest; this may be a deliberate aspect-ratio correction or an inadvertent mismatch.
• Line 1090 uses GO SUB MENU*VAL Z$, but menu option 7 (save array) and option 8 (load array) are handled with explicit GO TO jumps at lines 1072–1074 before the dispatch, since MENU*7 = 7000 and MENU*8 = 8000 — line 8000 does not exist. The explicit handling avoids a crash.