https://www.chilton-computing.org.uk/acl/htmls/flexipede/flexipede.htm
The Flexipede Revisited
Kate Sullivan, David Duce, Bob Hopgood
On The Flexipede:
Hugh 'Ras' Riddle: I didn't see it as significant as I do now.
Tony Pritchett: I didn't think of it that way either. I thought -
this is fun!
* 1. Introduction
* 2. Flexipede Card Box
* 3. The Flexipede Program
* 4. Approach
+ 4.1 The Java Approach
* 5. Reprogramming Flexipede
+ 5.1 Body Parts
+ 5.2 Story Board
+ 5.3 Flexipede Walk
+ 5.4 Solipede Leap
+ 5.5 Solipede Capture
+ 5.6 Flexipede Hits the Wall
* 6. Conclusions
1. Introduction
Tony Pritchett created The Flexipede in 1967, probably the first
known character computer animation telling a story worldwide,
certainly in the UK. And it had a soundtrack.
[pritchett]
Large View
Outside the Chilton Atlas building: Kate Sullivan, Tony Pritchett,
Dik Leatherdale, Bob Hopgood, 26 February 2016 when Tony showed Kate
around one of his old stomping grounds
Sadly, Tony Pritchett passed away on the 28 August 2017.
Animator and filmmaker Kate Sullivan was a friend of Tony s. She is
currently creating a multimedia project which documents his work. The
pair were working on the project together at the time of his passing.
Kate is providing a temporary home for Tony s archive. The collection
includes all sorts of fascinating materials relating to his animation
career, (1967 1982). Items include, the original 16mm master
negative of The Flexipede along with film footage and printed
materials relating to a wide range of projects, (Ridley Scott s
Alien , Blade Runner and the very first Channel Four logo to name
but a few.)
Kate is very keen to hear from any one who would like to contribute
to the project, which is currently in progress. It is centred upon
Tony s career, but by extension documents the work of his colleagues
and the formative years of the British computer animation industry.
All contributions would be very much appreciated. No contribution is
either too anecdotal or technical! If you would like to get in touch
or simply find out more about the project-in-progress, please visit;
it s (regularly-updated) home: http://www.TonyPritchett.co.uk/.
Back in the archive - Kate mentioned to Victoria Marshall that
amongst Tony's possessions was a 2000-card drawer of computer
punched-cards cards which, according to Tony, included his Flexipede
program. Would it be possible to recreate The Flexipede 50 years
after it was written?
[small_card_deck]
Large View
2. Flexipede Card Box
The card box included several card decks destined for the London
Atlas Computing Service. Most cards had printing across the top,
rather faded at times. Some had no printing. It was then necessary to
read the hole punching.
[card]
Card with Printing
Large View
An early deck that we looked at appeared to be Flexipede but it was
an earlier version. Kate has some experimental 16mm footage
containing this version. Other decks were from other animation
projects.
An Early Flexipede
3. The Flexipede Program
Eventually, a card deck was found that looked correct. It was
generating an IBM-compatible magnetic tape for the Benson-Lehner 120
(BL120) Microfilm Recorder at Culham Laboratory (where Tony Pritchett
said the film was produced).
In the 1960s, the sensible way to generate computer animation was to
use a microfilm recorder. A Stromberg-Carlson 4020 (SC4020) microfilm
recorder was installed at AWRE Aldermaston in 1963 and was also used
by Harwell for displaying nuclear simulations on hardcopy paper or
16mm/35mm film. In 1965 thermonuclear research moved from Harwell to
Culham, who purchased a BL120 microfilm recorder (compatible with the
SC4020). The BL120 was a faster cheaper second-generation alternative
that could process all SC4020 magnetic tapes.
Kate Sullivan took on the mammoth job of photographing the box of
cards, 3 cards per photograph. Bob Hopgood typed in the contents
(making quite a few errors in the process) and David Duce produced a
Java program that performed as close to the Fortran program as
possible generating frames of SVG graphics that could be displayed
approaching 24 frames per second to simulate the BL120 output. This
uncovered quite a few errors in the card transcriptions that needed
to be addressed.
Only two cards of the deck were missing and we were able to deduce
these to arrive at a complete listing of the card deck:
JOB
LRF91PB1, A PRITCHETT BL120 TEST
INPUT
1 LEAP TRAJECTORY
2 WALK TABLE
OUTPUT
0 LINEPRINTER 2000 LINES
13 ANY 100 LINES
STORE 50/120 BLOCKS
TAPE
1 BL L0454*INHIBIT
TAPE IBM
14 LP099*PERMIT 556 DENSITY
COMPUTING 5 MINUTES
COMPILER FORTRAN
*RUN
*FORTRAN SOURCE
*LIBRARY TAPE 1 BLOCK 1
BEGIN
LM=12
NS=11
NAM=24
BEGIN
DIMENSION XK(NS,NAM),YK(NS,NAM),XFT(NS,NAM),YFT(NS,NAM),XBOD(NS)
READ(2,2) XFT,YFT,XK,YK,XBOD
2 FORMAT(1X,11F7.1)
C
YSKULL=0
YJAW=0
C
INTEGER XS,YS,XF,YF
REAL XSFTA,YSFTA,SBOT
PI=3.1416
PITCH=100
D=48
DX=8
BB=19600
DXSOL=40
DFT=6
C
C SET UP SOLIPEDE
DIMENSION YSOL(LM),XSFT(LM),YSFT(LM),XKS(LM),YKS(LM)
C
DO (SETUP) L=1,LM
C
READ(1,1) YSOL(L),YSFT(L)
1 FORMAT(2F5.0)
C
IF(YSFT(L)=0) XSFT(L)=DXSOL*(L-1)
IF(YSFT(L).NE.0) XSFT(L)=XSFT(L-1)+DFT
C
AY=YSOL(L)-YSFT(L)
AA = XSFT(L)**2 + AY**2
A = SQRT(AA)
C = SQRT(BB-AA)
XKSL(L) = (C*AY/A+XSFT(L))/2
YKSL(L) = (AY - C*XSFT(L)/A)/2
C
SETUP CONTINUE
C
C PICTURE ARRAYS
REAL (BODY(2,4)/
1 50., 5.,
2 -50., -5.,
3 -50.,205.,
4 50.,195./
NBODY=4
REAL SOLIBOD(2,5)/
1 50.,5.,
2 -50.,-5.,
3 -50.,205.,
4 50.,195.,
5 50.,5./
NSOLIBOD=5
REAL FOOT(2,4)/
1 0.,0.,
2 0.,-10.,
3 40.,-10.,
4 0.,0./
NFOOT=4
REAL SKULL(2,5)/
1 50.,30.,
2 50,.205.,
3 150.,195.,
4 230.,30.,
5 50.,30./
NSKULL=5
REAL DJAW(2,5)/
1 50.,30.,
2 210.,30.,
3 160.,0.,
4 50.,-10.,
5 50.,30./
NJAW=5
REAL EYE(2,8)/
1 150.,140.,
2 120.,140.,
3 120.,170.,
4 150.,170.,
5 150.,150.,
6 130.,150.,
7 130.,160.,
8 140.160./
NEYE=8
REAL PAD(2,11)/
1 -25.,50.,
2 -25.,30.,
3 -20.,20.,
4 -10.,12.,
5 -3.,10.,
6 0.,10.,
7 0.,70.,
8 -3.,70.,
9 -10.,68.,
/ -20.,60.,
1 -25,50./
NPAD=11
C
REAL PL(4,4)/
1 50.,50.,90.,110.,
2 66.,25.,120.,70.,
3 69.,10.,136.,30.,
4 70.,0.,140.,6./
C
C MAIN PROGRAM
C
CALL IDST
C
NS=10
L=1
NEYE=2
NA=1
C
C 1)FCROSS
SCALE=0.5
INVX=0
GRND=903
BOT=GRND+120
XHEAD=-240
NF=420
CALL FLEXIGO
C
NF=24
CALL BLANK
C
C 2)SCROSS
SCALE=0.2
INVX=1
SGRND=3250
XSOL=-50
NF=150
CALL SOLIHOP
C
NF=24
CALL BLANK
C
C 3)FCROSS
SCALE=0.75
INVX=1
GRND=420
BOT=GRND+120
XHEAD=-240
NF=100
CALL FLEXIGO
C
C 4)F STOPS, S APPEARS
SGRND=2000
XSOL=-1000
NF=120
NEYE=8
C
DO(SPY) M=1,NF
CALL ADVFLM(1)
SCALE=0.75
INVX=1
CALL FLEXIPEDE
SCALE=0.3
INVX=0
CALL LEAP
SPY CALL SOLIPEDE
C
C 6) F CONTINUES
SCALE=0.75
INVX=1
NEYE=2
NF=300
CALL FLEXIGO
C
NF=24
CALL BLANK
C
C 7) S FINAL CROSS
SCALE=1
INVX=1
SGRND=296
XSOL=-50
NF=30
CALL SOLIHOP
C
NF=24
CALL BLANK
C
C MEET
GRND=296
SGRND=GRND
BOT=GRND+120
XSOL=-190
XHEAD=-250
YSKULL=20
SCALE=1
INVX=0
L=10
NMEET=14
C
DO(MEET) N=1,NMEET
CALL ADVFLM(1)
CALL LEAP
CALL SOLIPEDE
MEET CONTINUE
C
C GRAB
XTONG=200
CALL ADVFLM(1)
CALL LEAP
CALL SOLIPEDE
CALL TONGUE
CALL ADVFLM(1)
CALL LEAP
CALL SOLIPEDE
XTONG=XSOL-50
CALL TONGUE
C
C GRABHOLD
NHA=24
DO (GRAB) M=1,NF
CALL ADVFLM(1)
CALL SOLIPEDE
GRAB CALL TONGUE
C
C ZOOM
XPAN=15
NZOOM=40
NA=6
SCNEW=0.6
SCOLD=SCALE
OD=1/SCOLD
DD=(1/SCNEW-OD)/NZOOM
ZZ=0
C
DO (ZOOM) M=1,NZOOM
C
D=1/SCOLD+DD*M
SCALE=1/D
Z=ZZ
ZZ=512*(D*SCOLD-1)
Z=ZZ-Z
X=XPAN+Z
C
CALL PAN
CALL ADVFLM(1)
CALL FLEXIPEDE
CALL TONGUE
CALL SOLIPEDE
ZOOM CONTINUE
100 CONTINUE
C
NHA=24
CALL HOLD(1,NHA)
C
C OPEN
OS=3
OJ=0.673
NOPEN=52
DO (OPEN) M=1,NOPEN
CALL ADVFLM(1)
CALL OPEN(OS,OJ)
CALL FLEXIPEDE
CALL TONGUE
CALL SOLIPEDE
OPEN CONTINUE
C
NHB=24
CALL HOLD(1,NHB)
C
C PULL
DPULL=150
NPULL=3
DO(PULL) N=1,NPULL
CALL ADVFLM(1)
XTONG=XTONG-DPULL
XSOL=XTONG+50
CALL FLEXIPEDE
CALL TONGUE
CALL PULSOL(N)
PULL CONTINUE
C
C HLDIN
NHLDIN=24
XSOL=XHEAD+100
DO (HLDIN) M=1,NHLDIN
CALL ADVFLM(1)
CALL FLEXIPEDE
CALL PULSOL(4)
HLDIN CONTINUE
C
C GULP
NS=11
NA=NA+6
X=50
Z=0
CALL PAN
NGULP=24
DO (GULP) M=1,NGULP
CALL ADVFLM(1)
CALL FLEXIPEDE
GULP CONTINUE
C
C SHUT
SS=-4
SJ=-0.795
NSHUT=44
DO (SHUT) N=1,NSHUT
CALL ADVFLM(1)
CALL OPEN(SS,SJ)
CALL FLEXIPEDE
SHUT CONTINUE
C
NHC=24
CALL HOLD(2,NHC)
C
C EXIT
NEXIT=270
DO(EXIT) N=1,NEXIT
CALL ADVFLM(1)
CALL WALK
CALL FLEXIPEDE
EXIT CONTINUE
C
CALL IDEND
C
STOP
C
SUBROUTINE FLEXIPEDE
DO(FLEX) N=1,NS
CALL START (XHEAD-XBOD(N),BOT)
CALL TO (XHEAD+XK(N,NA),BOT-YK(N,NA))
CALL TO (XHEAD+XFT(N,NA),GRND+YFT(N,NA))
CALL DRAW (FOOT, NFOOT, XHEAD+XFT(N,NA),GRND+YFT(N,NA))
CALL DRAW(BODY, NBODY, XHEAD-XBOD(N), BOT)
FLEX CONTINUE
C
CALL DRAW (SKULL, NSKULL, XHEAD, BOT+YSKULL)
CALL TO (XHEAD+DJAW(1,1), BOT+YJAW+DJAW(2,1))
CALL DRAW (DJAW, NJAW, XHEAD, BOT+YJAW)
CALL DRAW (EYE, NEYE, XHEAD, BOT+YSKULL)
C
RETURN
END
C
SUBROUTINE SOLIPEDE
C
CALL START(XSOL,SBOT)
CALL TO(XSOL+XKS(L),SBOT-YKS(L))
CALL TO(XSFTA,YSTFA)
CALL DRAW(FOOT,NFOOT,XSFTA,YSTFA)
CALL DRAW(SOLIBOD,NSOLIBOD,XSOL,SBOT)
RETURN
END
C
SUBROUTINE WALK
NA=NA+1
IF(NA.GT.NAM) NA=1
XHEAD=XHEAD+DX
RETURN
END
C
SUBROUTINE LEAP
L=L+1
IF(L.GT.LM) L=1
XSOL = XSOL+DXSOL
SBOT = SGRND+YSOL(L)
XSFTA = XSOL+XSFT(L)
YSFTA = SGRND+YSFT(L)
RETURN
END
C
SUBROUTINE OPEN(IS,IJ)
YSKULL=YSKULL+IS
YJAW=YJAW-IJ
RETURN
END
C
SUBROUTINE TONGUE
CALL DRAW(PAD,NPAD,XTONG,BOT)
DO 1 K=1,2
CALL START (XTONG+PAD(1,K), BOT+PAD(2,K))
1 CALL TO (XHEAD+50,BOT+PAD(2,K))
RETURN
END
C
SUBROUTINE HOLD(K,N)
DO I = 1,N
CALL ADVFLM(1)
CALL FLEXIPEDE
IF(K=1) BEGIN
CALL SOLIPEDE
CALL TONGUE
END
1 CONTINUE
RETURN
END
C
SUBROTINE PULSOL(J)
CALL DRAW (SOLIBOD,NSOLIBOD,XSOL,BOT)
CALL START (XSOL,BOT)
CALL TO (XSOL+PL(1,J), BOT-PL(2,J))
CALL DRAW (FOOT,NFOOT, XSOL+PL(3,J), BOT-PL(4,J))
RETURN
END
C
SUBROUTINE FLEXIGO
BOT=GRND+120
DO 1 I=1,NF
CALL ADVFLM(1)
CALL WALK
CALL FLEXIPEDE
1 CONTINUE
RETURN
END
C
SUBROUTINE SOLIHOP
DO 1 I=1,NF
CALL ADVFLM(1)
CALL LEAP
CALL SOLIPEDE
1 CONTINUE
RETURN
END
C
SUBROUTINE BLANK
DO 1 I=1,NF
CALL ADVFLM(1)
1 CONTINUE
RETURN
END
C
SUBROUTINE PAN
XHEAD=XHEAD+X
XSOL=XSOL+X
XTONG=XTONG+X
XSFTA=XSFTA+X
YSFTA=YSFTA+2
SGRND=SGRND+2
GRND=GRND+2
SBOT=SBOT+2
BOT=GRND+120
RETURN
END
C
SUBROUTINE START(XX,YY)
XS=INT(XX*SCALE)
YS =1023-INT(YY*SCALE)
IF(INVX.NE.0) XS=1023-XS
RETURN
END
SUBROUTINE TO(XX,YY)
XF=INT(XX*SCALE)
YF = 1023-INT(YY*SCALE)
IF(INVX.NE.0) XF=1023-XF
CALL VECTOR(XS,YS,XF,YF)
XS=XF
YS=YF
RETURN
END
SUBROUTINE DRAW(FIG,N,XORGN,YORGN)
DIMENSION FIG(2,N)
XS = INT((FIG(1,1)+XORGN)*SCALE)
YS = 1023-INT((FIG(2,1)+YORGN)*SCALE)
IF(INVX.NE.0) XS=1023-XS
DO 1 K=2,N
XF = INT((FIG(1,K)+XORGN)*SCALE)
YF = 1023-INT((FIG(2,K)+YORGN)*SCALE)
IF(INVX.NE.0) XF=1023-XF
CALL VECTOR(XS,YS,XF,YF)
XS=XF
1 YS=YF
RETURN
END
END
END
*ENTER
7/8 CARD
DATA
LEAP TRAJECTORY
80 0
120 0
192 72
248 138
288 188
312 222
320 240
312 232
288 208
248 168
192 102
120 20
7/8 CARD
DATA
WALK TABLE
48.0 -100.0 -248.0 -300.0 -352.0 -500.0 -648.0 -700.0 -752.0 -900.0-1048.0
40.0 -87.6 -246.4 -308.0 -360.0 -487.6 -646.4 -708.0 -760.0 -887.6-1046.4
32.0 -76.0 -241.6 -316.0 -368.0 -476.0 -641.6 -716.0 -768.0 -876.0-1041.6
24.0 -66.1 -233.9 -324.0 -376.0 -466.1 -633.9 -724.0 -776.0 -866.1-1033.9
16.0 -58.4 -224.0 -332.0 -384.0 -458.4 -624.0 -732.0 -784.0 -858.4-1024.0
8.0 -53.6 -212.4 -340.0 -392.0 -453.6 -612.4 -740.0 -792.0 -853.6-1012.4
0.0 -52.0 -200.0 -348.0 -400.0 -452.0 -600.0 -748.0 -800.0 -852.0-1000.0
-8.0 -60.0 -187.6 -346.4 -408.0 -460.0 -587.6 -746.4 -808.0 -860.0 -987.6
-16.0 -68.0 -176.0 -341.6 -416.0 -468.0 -576.0 -741.6 -816.0 -868.0 -976.0
-24.0 -76.0 -166.1 -333.9 -424.0 -476.0 -566.1 -733.9 -824.0 -876.0 -966.1
-32.0 -84.0 -158.4 -324.0 -432.0 -484.0 -558.4 -724.0 -832.0 -884.0 -958.4
-40.0 -92.0 -153.6 -312.4 -440.0 -492.0 -553.6 -712.4 -840.0 -892.0 -953.6
-48.0 -100.0 -152.0 -300.0 -448.0 -500.0 -552.0 -700.0 -848.0 -900.0 -952.0
-46.4 -108.0 -160.0 -287.6 -446.4 -508.0 -560.0 -687.6 -846.4 -908.0 -960.0
-41.6 -116.0 -168.0 -276.0 -441.6 -516.0 -568.0 -676.0 -841.6 -916.0 -968.0
-33.9 -124.0 -176.0 -266.1 -433.9 -524.0 -576.0 -661.1 -833.9 -924.0 -976.0
-24.0 -132.0 -184.0 -258.4 -424.0 -532.0 -584.0 -658.4 -824.0 -932.0 -984.0
-12.4 -140.0 -192.0 -253.6 -412.4 -540.0 -592.0 -653.6 -812.4 -940.0 -992.0
0.0 -148.0 -200.0 -252.0 -400.0 -548.0 -600.0 -652.0 -800.0 -948.0-1000.0
12.4 -146.4 -208.0 -260.0 -387.6 -546.4 -608.0 -660.0 -787.6 -946.4-1008.0
24.0 -141.6 -216.0 -268.0 -376.0 -541.6 -616.0 -668.0 -776.0 -941.6-1016.0
33.9 -133.9 -224.0 -276.0 -366.1 -533.9 -624.0 -676.0 -766.1 -933.9-1024.0
41.6 -124.0 -232.0 -284.0 -358.4 -524.0 -632.0 -684.0 -758.4 -924.0-1032.0
46.4 -112.4 -240.0 -292.0 -353.6 -512.4 -640.0 -692.0 -753.6 -912.4-1040.0
0.0 30.0 0.0 0.0 0.0 30.0 0.0 0.0 0.0 30.0 0.0
0.0 29.0 7.8 0.0 0.0 29.0 7.8 0.0 0.0 29.0 7.8
0.0 26.0 15.0 0.0 0.0 26.0 15.0 0.0 0.0 26.0 15.0
0.0 21.2 21.2 0.0 0.0 21.2 21.2 0.0 0.0 21.2 21.2
0.0 15.0 26.0 0.0 0.0 15.0 26.0 0.0 0.0 15.0 26.0
0.0 7.8 29.0 0.0 0.0 7.8 29.0 0.0 0.0 7.8 29.0
0.0 0.0 30.0 0.0 0.0 0.0 30.0 0.0 0.0 0.0 30.0
0.0 0.0 29.0 7.8 0.0 0.0 29.0 7.8 0.0 0.0 29.0
0.0 0.0 26.0 15.0 0.0 0.0 26.0 15.0 0.0 0.0 26.0
0.0 0.0 21.2 21.2 0.0 0.0 21.2 21.2 0.0 0.0 21.2
0.0 0.0 15.0 26.0 0.0 0.0 15.0 26.0 0.0 0.0 15.0
0.0 0.0 7.8 29.0 0.0 0.0 7.8 29.0 0.0 0.0 7.8
0.0 0.0 0.0 30.0 0.0 0.0 0.0 30.0 0.0 0.0 0.0
7.8 0.0 0.0 29.0 7.8 0.0 0.0 29.0 7.8 0.0 0.0
15.0 0.0 0.0 26.0 15.0 0.0 0.0 26.0 15.0 0.0 0.0
21.2 0.0 0.0 21.2 21.2 0.0 0.0 21.2 21.2 0.0 0.0
26.0 0.0 0.0 15.0 26.0 0.0 0.0 15.0 26.0 0.0 0.0
29.0 0.0 0.0 7.8 29.0 0.0 0.0 7.8 29.0 0.0 0.0
30.0 0.0 0.0 0.0 30.0 0.0 0.0 0.0 30.0 0.0 0.0
29.0 7.8 0.0 0.0 29.0 7.8 0.0 0.0 29.0 7.8 0.0
26.0 15.0 0.0 0.0 26.0 15.0 0.0 0.0 26.0 15.0 0.0
21.2 21.2 0.0 0.0 21.2 21.2 0.0 0.0 21.2 21.2 0.0
15.0 26.0 0.0 0.0 15.0 26.0 0.0 0.0 15.0 26.0 0.0
7.8 29.0 0.0 0.0 7.8 29.0 0.0 0.0 7.8 29.0 0.0
49.0 -46.4 -199.0 -263.9 -351.0 -446.4 -599.0 -663.9 -751.0 -846.4 -999.0
48.5 -41.5 -191.0 -268.2 -351.5 -441.5 -591.0 -668.2 -751.5 -841.5 -991.0
47.2 -39.1 -182.3 -273.2 -352.8 -439.1 -582.3 -673.2 -752.8 -839.1 -982.3
45.3 -39.0 -172.9 -278.7 -354.7 -439.0 -572.9 -678.7 -754.7 -839.0 -972.9
42.8 -40.7 -163.1 -284.8 -357.2 -440.7 -563.1 -684.8 -757.2 -840.7 -963.1
39.8 -44.6 -153.9 -291.5 -360.2 -444.6 -553.9 -691.5 -760.2 -844.6 -953.9
36.1 -51.0 -146.4 -299.0 -363.9 -451.0 -546.4 -699.0 -763.9 -851.0 -946.4
31.8 -51.5 -141.5 -291.0 -368.2 -451.5 -541.5 -691.0 -768.2 -851.5 -941.5
26.8 -52.8 -139.1 -282.3 -373.2 -452.8 -539.1 -682.3 -773.2 -852.8 -939.1
21.3 -54.7 -139.0 -272.9 -378.7 -454.7 -539.0 -672.9 -778.7 -854.7 -939.0
15.2 -57.2 -140.7 -263.1 -384.8 -457.2 -540.7 -663.1 -784.8 -857.2 -940.7
8.5 -60.2 -144.6 -253.9 -391.5 -460.2 -544.6 -653.9 -791.5 -860.2 -944.6
1.0 -63.9 -151.0 -246.4 -399.0 -463.9 -551.0 -646.4 -799.0 -863.9 -951.0
9.0 -68.2 -151.5 -241.5 -391.0 -468.2 -551.5 -641.5 -791.0 -868.2 -951.5
17.7 -73.2 -152.8 -239.1 -382.3 -473.2 -552.8 -639.1 -782.3 -873.2 -952.8
27.1 -78.7 -154.7 -239.0 -372.9 -478.7 -554.7 -639.0 -772.9 -878.7 -954.7
36.9 -84.8 -157.2 -240.7 -363.1 -484.8 -557.2 -640.7 -763.1 -884.8 -957.2
46.1 -91.5 -160.2 -244.6 -353.9 -491.5 -560.2 -644.6 -753.9 -891.5 -960.2
53.6 -99.0 -163.9 -251.0 -346.4 -499.0 -563.9 -651.0 -746.4 -899.0 -963.9
58.5 -91.0 -168.2 -251.5 -341.5 -491.0 -568.2 -651.5 -741.5 -891.0 -968.2
60.9 -82.3 -173.2 -252.8 -339.1 -482.3 -573.2 -652.8 -739.1 -882.3 -973.2
61.0 -72.9 -178.7 -254.7 -339.0 -472.9 -578.7 -654.7 -739.0 -872.9 -978.7
59.3 -63.1 -184.8 -257.2 -340.7 -463.1 -584.8 -657.2 -740.7 -863.1 -984.8
55.4 -53.9 -191.5 -260.2 -344.6 -453.9 -591.5 -660.2 -744.6 -853.9 -991.5
50.0 45.0 70.0 60.0 50.0 45.0 70.0 60.0 50.0 45.0 70.0
50.5 38.4 69.4 62.4 50.5 38.4 69.4 62.4 50.5 38.4 69.4
51.7 34.5 67.7 64.6 51.7 34.5 67.6 64.6 51.7 34.5 67.7
53.3 34.2 64.5 66.7 53.3 34.2 64.5 66.7 53.3 34.2 64.5
55.4 37.3 59.5 68.3 55.4 37.3 59.5 68.3 55.4 37.3 59.5
57.6 42.8 52.7 69.5 57.6 42.8 52.7 69.5 57.6 42.8 52.7
60.0 50.0 45.0 70.0 60.0 50.0 45.0 70.0 60.0 50.0 45.0
62.4 50.5 38.4 69.4 62.4 50.5 38.4 69.4 62.4 50.5 38.4
64.6 51.7 34.5 67.7 64.6 51.7 34.5 67.7 64.6 51.7 34.5
66.7 53.3 34.2 64.5 66.7 53.3 34.2 64.5 66.7 53.2 34.2
68.3 55.4 37.3 59.5 68.3 55.4 37.2 59.5 68.3 55.4 37.3
69.5 57.6 42.8 52.7 69.5 57.6 42.0 52.7 69.5 57.6 42.8
70.0 60.0 50.0 45.0 70.0 60.0 50.0 45.0 70.0 60.0 50.0
69.4 62.4 50.5 38.4 69.4 62.4 50.5 38.4 69.4 62.4 50.5
67.7 64.6 51.7 34.5 67.7 64.6 51.7 34.5 67.7 64.6 51.7
64.5 66.7 53.3 34.2 64.5 66.7 53.3 34.2 64.5 66.7 53.3
59.5 68.3 55.4 37.3 59.5 68.3 55.4 37.9 59.5 68.3 55.4
52.7 69.5 57.6 42.8 52.7 69.5 57.6 42.8 52.7 69.5 57.6
45.0 70.0 60.0 50.0 45.0 70.0 60.0 50.0 45.0 70.0 60.0
38.4 69.4 62.4 50.5 38.4 69.4 62.4 50.5 38.4 69.4 62.4
34.5 67.7 64.6 51.7 34.5 67.7 64.6 51.7 34.5 67.7 64.6
34.2 64.5 66.7 53.3 34.2 64.5 66.7 53.3 34.2 64.5 66.7
37.3 59.5 68.3 55.4 37.3 59.5 68.3 55.4 37.3 59.5 68.3
42.8 52.7 69.5 57.6 42.8 52.7 69.5 57.6 42.8 52.7 69.5
0.0 100.0 200.0 300.0 400.0 500.0 600.0 700.0 800.0 900.0 1000.0
Four subroutines were not found called IDST, IDEND, ADVFLM and
VECTOR. It turned out that these were provided as BAS cards. We
decided against reconstructing the Atlas instructions from the BAS
binary cards and then trying to work out what the original Fortran
code was.
Later, Kate found in her archive confirmation that Tony had made
visits to Aldermaston, Culham and Chilton to see if he could get
access to the Culham BL120 or the Aldermaston SC4020 and was offered
access to the BL120. Paul Nelson at Chilton offered him a Hartran
Fortran version of the basic SC4020 SCORS code for generating
IBM-compatible magnetic tapes for either the BL120 or the SC4020. As
these were written for Hartran's Fortran compiler, Tony used these as
the basis of a rewrite in London's Fortran V. The result was the BAS
subroutines IDST, IDEND, ADVFLM and VECTOR which Tony used on a
number of projects. To give some idea of the code, Woody Anderson did
a similar recoding for the IBM 360 which he published in the UAIDE
Proceedings for 1970. Tony's Fortran deck included a large set of
data cards giving all the positions of the flexipede legs An earlier
program must have pre-calculated these to save time in short
development runs.
4. Approach
The ultimate goal was a Scalable Vector Graphics (SVG) definition of
The Flexipede using either Javascript or SVG's declarative animation
that was as close to the original as possible. The ability to repeat
an animation cycle via the repeatCount attribute in SVG would greatly
reduced the size of the completed SVG document.
To understand the Flexipede program itself, the decision was made for
David Duce to reprogram it in Java and for Bob Hopgood to focus on
generating an animation that used the full power of SVG. Although the
Flexipede Program is not overly long, some of the code around the
algorithms used was worth reprogramming to ensure correctness.
The titles at the beginning and end were not part of the Flexipede
Fortran program. Tony had mentioned to Kate that he had done these
using Letraset and Kate found the original Letraset artwork in the
archive and was able to produce a good rendering of these.
The existing sound track needed some filtering to make it sound more
like the original. Paul Hopgood obliged.
The graphics package used was unknown initially but eventually it was
clear that it was a low level set of routines that just took
coordinates defined on the 1023 by 1023 grid of the microfilm
recorder and output vectors given the start and end positions.
4.1 The Java Approach
The aim here was to answer the question Is it feasible that the
Fortran we have was used to create The Flexipede animation? To an
author whose first exposure to Fortran was through Fortran IV in the
early 1970s, the code raised a few issues. Firstly, it contains DO
loops with alphabetic labels, e.g.
DO (GULP) M=1,NGULP
CALL ADVFLM(1)
CALL FLEXIPEDE
GULP CONTINUE
Secondly the program structure was unusual:
BEGIN
...
STOP
SUBROUTINE FLEXIPEDE
...
RETURN
END
...
SUBROUTINE ...
...
RETURN
END
END
END
Looking at the data flow through the program, some variables were
passed through subroutine arguments, other variables were clearly
shared, but the program didn't use COMMON blocks to achieve sharing.
It appeared that the dialect of Fortran used supported block
structuring in a similar manner to Algol and PL/1. In the absence of
any Fortran compiler with these features it was decided, for
pragmatic reasons, to translate the program into Java where it was
straightforward to match this structure. Since this work was done, a
Fortran V manual from ULCC (dated May 1967) has come to light in
Tony's archive. This describes these Fortran extensions so we are
confident this is the Fortran dialect used.
The aim of the Java translation was then to generate a frame-based
animation from output "similar" to that produced by the original
program. The four subroutines not defined in the Fortran card deck
but via BAS cards were:
IDST ADVFLM(N) VECTOR(XS,YS,XF,YF) IDEND
The subroutine ADVFLM was always called with argument 1. We initially
guessed, correctly, that IDST and IDEND were microfilm recorder
initialisation and termination routines, ADVFLM advanced the film to
a new frame and VECTOR drew a vector from (XS, YS) to (XF, YF) in the
1023 by 1023 coordinate system. Rather than generate graphical output
directly from the Fortran program we generated a trace file that
recorded invocations of these routines and their argument values
along with a lot of other tracing information that was used during
debugging and to better understand how the program was working.
The trace file was then converted to Scalable Vector Graphics (SVG)
for display using a simple script written in the awk scripting
language. Output from IDST and IDEND was translated to startup and
termination markup. Output from VECTOR was directly translated to SVG
line elements:
ADVFLM calls in the trace were translated into SVG group (g) elements
so that the content of each frame was wrapped in a g element. An id
attribute containing the frame number was added to each g element.
For example:
...
The style associated with the class attribute made the group
invisible (frameInvis) or visible (frameVis). Initially, all groups
except the first were made invisible. JavaScript code was added to
control the animation. The control panel at the top of the web
document is shown below.
Screen shot of the animation control panel
Animation Control Panel
When the Run button is pressed a JavaScript function is invoked which
in turn calls another function, UpdateAnimation() at specified
intervals (24 times per second). Update animation changes the value
of the class attribute of the currently visible group from frameVis
to frameInvis and the next group from frameInvis to frameVis, thereby
cycling through all the frames in turn. When the maximum frame count
is reached the animation recycles to frame 0. Pressing the Stop
button halts the animation. It turned out to be very useful in
understanding the code to be able to step through the animation frame
by frame (button Step) and to set a starting frame for this (number
input box and button Set Start Frame).
It was by stepping through the animation frame-by-frame, in
conjunction with examining the program and trace output that we
discovered some transcription errors in the data cards and worked out
how the flexipede is lengthened when the solipod (effectively
solipede) is swallowed.
The SVG animation generated in this way is an 8.3 MB document.
Representing each graphical element in the animation by a separate
SVG line element is very inefficient so an additional post-processing
step was added to replace sets of line elements by more compact path
elements. The advantage of doing this in a post processing step was
that no changes were required to the original program.
5. Reprogramming Flexipede in SVG
5.1 Body Parts
The body parts are defined by the arrays BODY, SOLIBOD, FOOT, SKULL,
DJAW, EYE and PAD at the beginning of the program:
BODY FOOT SKULL DJAW EYE SOLIBOD PAD FLEXIPEDE PARTS TOGETHER PLUS
LEGS
The SKULL and JAW are separate so that the flexipede can open up its
head to swallow the solipede. Only the first two lines of the eye are
normally drawn but the full eye is drawn when the solipede passes
overhead. PAD is the suction end of the flexipede's tongue.
5.2 Story Board
The storyboard of the animation is quite simple where the numbers
indicate the number of frames of the activity: (1) Flexipede lumbers
across screen from Left to Right (420 then 24 blank), (2) Solipede
bounces across from Right to Left (150 frames then 24 blank), (3)
Flexipede returns from R to L, stops as solipede bounces over its
head, continues off R (100, 120, 300), (4) Solipede bounces fast from
R to L and starts returning L to R when it is caught by a large
tongue (34, 14, 2), (5) Pause then pan and zoom showing the long
tongue of the flexipede and another pause (24, 40, 24), (6) The
flexipede's jaws open, hold, tongue pulls solipede in, it is then
swallowed (gulp) increasing flexipede's size by one segment, jaws
close, hold, (52, 24, 3, 24, 24, 44) (7) The satisfied flexipede
crosses from R to L (270). The flexipede and solipede sizes change on
each crossing.
Effectively the flexipede and solipede only travel from left to right
at full size but two variables adjust the size and flip the
coordinate in the X-direction about the centre so that right-to-left
and left-to-right traversals at various sizes can be easily achieved.
Accompanying the animation is a sound track of a flexipede that needs
oiling and a sprightly bouncing solipede that Tony created. Tony told
Kate that he created the film's soundtrack recording the sound of a
squeaky office chair, a garage hoist, a jaw harp and himself gulping
using a domestic Philips reel-to-reel tape recorder belonging to the
sister of his friend, Hugh 'Ras' Riddle.
(Tony went on to create the installation 'Sidebands' with Ras, which,
along with The Flexipede, was exhibited at Cybernetic Serendipity,
1968.) Tony told Kate that the sound was sneakily recorded at night
at Ras's workplace - a basement lab in the medical electronics
research department of Bart's Hospital.
Tony: "There was no security in those days!"
Ras: "True geeks work unlimited hours!"
Ras (laughing): "He (Tony) was facing the wrong way round on it
bouncing up and down ..."
Tony (laughing): "If anybody had seen it through the window they
would have wondered what was going on!"
Ras: "We thought it was hilarious. We were conscious of the absurdity
of it all the way through. Absurdity was in a way part of what one
lived for. This was Tony. It was what he did."
The timings for the various events defined in the program matched
those in The Flexipede film except that the holds between scenes were
not the same in the released film version. Our guess is that
additional blank frames were inserted at some later stage, presumably
to fit the soundtrack exactly to where it should be relative to the
animation and titles.
5.3 Flexipede Walk
The Flexipede walk is defined by a set of arrays (XK, YK, XFT, YFT,
XBOD) giving the absolute positions of the 11 legs for the 24
positions of the animation cycle which are read in from data cards.
Using absolute position values somewhat obscures the fact that the
leg movements are in a cycle of four (the 5th segment of the
flexipede has the same leg movement as the first, the 6th the same as
the second and so on. Also, the 2nd leg cycle is the same as the
first but displaced by 6 places, the 3rd displaced by 12 and the 4th
displaced by 18. So one leg cycle provides all the information needed
to create the animation of all the legs.
The path of each leg is from the top of the leg to the knee and then
to the start of the foot with the same horizontal foot for each
position.
The array XBOD defines the positions of the individual segments which
was one of the missing cards but easily guessed and the other missing
card was the final YFT positions which had to be guessed/
interpolated. Using absolute position values somewhat obscures the
fact that the leg movements are in a cycle of four, that is the fifth
segment of the flexipede has the same leg movement as the first, the
sixth the same as the second and so on. The walk, therefore, in
relative coordinates, only needs the first four of the 11 entries.
Also, the second leg cycle is the same as the first but displaced by
6 places, the third displaced by 12 and the fourth displaced by 18.
So actually one leg cycle provides all the information needed.
The walk tables define (XFT, YFT), (XK, YK) for the 24 frames in the
walk cycle.
The path of each leg is basically the top of the leg at (0,GRND+120),
the knee at (XK,YK) and the start of the foot at (XFT,GRND+YFT). The
coordinate system had the Y axis going upwards while the microfilm
recorders had it going downwards. Changing the Y to go downwards with
the origin at the top of the leg gives us an SVG path of:
M0,0 l XK,YK l XFT-XK,120-YFT-YK l 0,10 l40,0 l-40,-10
M defines the position at the top of the leg, l gives the X,Y
distances from the previous point. The last three l values define the
foot.
So in relative coordinates, the first leg cycle before the foot is:
M0,0 l 49.0, 50.0 l -1.0, 70.0 M0,0 l 48.5, 50.5 l -8.5, 69.5 M0,0 l 47.2, 51.7 l -15.2, 68.3
M0,0 l 45.3, 53.3 l -21.3, 66.7 M0,0 l 42.8, 55.4 l -26.8, 64.0 M0,0 l 39.8, 57.6 l -31.8, 62.4
M0,0 l 36.1, 60.0 l -36.1, 60.0 M0,0 l 31.8, 62.4 l -39.8, 57.6 M0,0 l 26.8, 64.6 l -42.8, 55.4
M0,0 l 21.3, 66.7 l -45.3, 53.3 M0,0 l 15.2, 68.3 l -47.2, 51.7 M0,0 l 8.5, 69.5 l -48.5, 50.5
M0,0 l 1.0, 70.0 l -49.0, 50.0 M0,0 l 9.0, 69.4 l -55.4, 42.8 M0,0 l 17.7, 67.7 l -59.3, 37.3
M0,0 l 27.1, 64.5 l -61.0, 34.3 M0,0 l 36.9, 59.5 l -60.9, 34.5 M0,0 l 46.1, 52.7 l -58.5, 38.3
M0,0 l 53.6, 45.0 l -53.6, 45.0 M0,0 l 58.5, 38.4 l -46.1, 52.6 M0,0 l 60.9, 34.5 l -36.9, 59.5
M0,0 l 61.0, 34.2 l -27.1, 64.6 M0,0 l 59.3, 37.3 l -17.7, 67.7 M0,0 l 55.4, 42.8 l -9.0, 69.4
The second leg cycle starts:
M0,0 l 53.6, 45.0 l -53.6, 45.0 M0,0 l 58.5, 38.4 l -46.1, 52.6 M0,0 l 60.9, 34.5 l -36.9, 59.5
The third leg cycle starts:
M0,0 l 1.0, 70.0 l -49.0, 50.0 M0,0 l 9.0, 69.4 l -55.4, 42.8 M0,0 l 17.7, 67.7 l -59.3, 37.3
The fourth leg cycle starts:
M0,0 l 36.1, 60.0 l -36.1, 60.0 M0,0 l 31.8, 62.4 l -39.8, 57.6 M0,0 l 26.8, 64.6 l -42.8, 55.4
The 24 leg positions are shown below. The dashed lines are the
starting positions from right to left of the animation of the first
four legs which then get repeated for the following legs.
Going from right to left, the foot positions move backwards along the
ground then come forward on the curve of a circle. The knee positions
are calculated using a similar algorithm we believe to that which is
used for the solipede.
Foot positions Knee positions
The Flexipede Walk
For each traversal of the flexipede variables are set to give its
size and direction of travel. For the initial walk the legs cycle
through the 24 positions as the flexipede traverses the screen over
420 frames. At 24 frames per cycle that amounts to 17.5 repeats which
SVG can handle so only a single 24 loop needs to be declared but with
a repeatCount attribute set to 17.5.
5.4 Solipede Leap
The path of the Solipede is defined by the leap trajectory which
gives the Y position of the top of leg and how far the foot is off
the ground for a 12-frame rather than 24-frame cycle. Most of the
y-values are defined as:
y = -72 + 112xt - 1/2x16xt^2
This is the standard vertical positioning of an object with an
initial velocity of 112 units per sec and a gravity of 16 units per
sec^2. The initial position being at y=-72. In the leap trajectory,
all the values correspond with the formula above except for the
initial positions that effectively generate the initial velocity.
There is a large constant forward movement of the solipede together
with a smaller additional forward movement in the first half of the
leap cycle and the same move backward in the second half that
simulates the added velocity forward at the start of the cycle after
the jump starts and the slowing down of the solipede during the
cycle. This is similar to the trajectory of a running kangaroo.
The solipede foot moves forward 6 units each frame of the cycle and
the position of the knee is calculated from the X and Y positions of
the foot and the Y-position of the top of the leg defined by the leap
trajectory table. This could be regarded as a straightforward
four-bar linkage with the foot position and top of leg constraining
the knee position by the fixed lengths of the upper and lower leg
(similar to cycling).
The example below shows a similar movement on a complete flexipede.
The basic motion from the leap trajectory table is shown together
with a forward movement to give the leaping motion.
The Solipede Jump
The leap program is designed to give a reasonably correct positioning
for the knee in this motion. This is done by a heuristic that moves
the knee up and forward depending on the distance that the foot is in
front of the top of the leg. The line between the top of the leg and
the foot is moved forward as though the leg was longer creating a
parallel line that stops at an arbitrary line above the top of the
leg. The knee is then positioned half way between the original half
way point and the new one. The choice of heuristic seems to be one
that Tony invented. Perhaps flexipedes and solipedes do have legs
that stretch and contract.
line above leg top
Positioning the Knee
The table of positions that define the flexipede's walk appear to be
defined in a similar way. An earlier program found in the deck of
cards may be an early version of the program that generated the
flexipede's leg movements.
The cycle of the animated solipede jump is shown below:
5.5 Solipede Capture
The solipede capture is reasonably complicated as the solipede has to
be sucked into the open jaws without the legs dangling below and then
to right the legs once the capture has occurred.
The array defined by:
REAL PL(4,4)/50.,50.,90.,110.,66.,25.,120.,70.,69.,10.,136.,30.,70.,0.,140.,6./
gives the intermediate coordinates of the solipede leg during
capture. Once captured, the head moves forward half a body segment
length and the body back by the same amount thus creating a flexipede
with an extra segment that walks off satisfied.
class="line07" d="M0,0 l 32,64 l -40, 56 l0,10l40,0l-40,-10"/>
The Solipede Capture
5.6 Flexipede Hits the Wall
One unusal aspect of the Flexipede film was that on reaching the edge
of the screen area it starts to generate a wall. Effectively the
lines of the Flexipede that are greater than 1023 in the X direction
or less than zero have the X-coordinate changed to either 1023 or
zero thus creating a set of vertical lines. With the microfilm
recorder overstriking the lines in question giving a much more
intense (thicker line) that appears on the film image.
That confirmed that the library used to draw the Flexipede was
relatively low level and had not included genuine clipping at the
screen boundary that was limited to lines drawn between 0 and 1023 in
the X and Y directions.
The basic SCORS library on the SC4020 which Tony used to define his
version of VECTOR had a routine:
CALL VECTOR(X1, Y1, X2, Y2)
The X and Y positions should be in the range 0 to 1023. As both the
SC4020 and BL120 microfilm recorders only draw vectors with less than
64 increments in the X and Y direction, the VECTOR routine breaks the
line into a set of segments. However, before breaking the line into
sections, the SCORS VECTOR code is:
DO 400 I=1,4
IF(J(I).LT.0) J(I)=0
IF(J(I).GT.1023) J(I)=1023
400 CONTINUE
It just reduces the coordinate values to the relevant boundary value
and this gives the exact effect seen on the Flexipede film.
This pretty well confirmed that Tony used the low-level SCORS routine
clipping for generating the Flexipede BL120 output.
The algorithm is quite crude biting off 64-bit sections of the line
to be output and finishing with whatever is left in the final
section.
An animation of The Flexipede shows the SCORS clip as the flexipede
emeges from a wall on the left and exits via one on the right.
The only way to be absolutely sure would of course be to work out
what the 38 binary BAS cards for VECTOR actually did. That would
entail examining over 500 Atlas machine instructions that the Fortran
compiler generated for the subroutine VECTOR. However, the code for
changing the coordinates outside the plotting area needs to be done
almost immediately so the code would be close to the top of the
subroutine.
VECTOR00, the first card indicated that the total length of the
routine in octal was 1030(8) and that the compilation took place on
the 27 June 1966 so the routine had been in use for quite some time.
[vector00]
VECTOR Initial BAS Card
Large View
BAS cards are relatively easy to read but quite time consuming.
Columns 7 and 8 give the relocatable address for the 16 instructions
on the card. On loading, addresses will be incremented to the actual
position in the memory where the routine will be executed. Starting
at column 9 the columns 9-12 have the 48 hole positions making up the
first 48-bit Atlas word. A hole punched indicates a 1 and no hole
punched a zero. You start at the top of the first column and finish
at the bottom of the fourth column. Columns 13-16 give the next word
and so on. What you find may be an Atlas instruction, alternatively
it can be a data value. Unless you know what the code generated by
the compiler is likely to be, it is a bit hit and miss trying to work
out which it is. It is somewhat helped by the columns 2-4 that say
whether each half-word on the card contains an address that needs to
be relocated.
After decoding the first few BAS cards it appeared that both INTEGER
and REAL variables were using floating point arithmetic to do
calculations and that the integer operations were using the
unstandardised floating point arithmetic which kept the integer
values in the lower right-hand bits of the 48-bit word. Also the
first few cards seemed to be taking the subroutine parameters and
storing them in consecutive positions in the relocatable storage
which is what you would expect if the plan was to do some tests in a
DO loop for values greater than 1023 or less than zero.
Things got more interesting around cards VECTOR05 and VECTOR06.
[vector05]
VECTOR05 BAS Card
Large View
[vector06]
VECTOR06 BAS Card
Large View
VECTOR05 is defining the contents of locations 126(8) to 145(8) and
VECTOR06 from 146(8) to 165(8).
Starting at column 53 on VECTOR05 are the instructions in positions
141(8) to 145(8) and starting at column 9 on VECTOR06 are the
instructions in positions 146(8) onwards.
53-56 0011011100 0000000 0000000 000000000000 000001000000 141
57-60 0010011110 1111111 0000000 000000000000 001100101000 142
61-64 0011011100 0000000 0000000 000000000001 000100100000 143
65-68 0011011100 0000000 0000000 000000000000 000001000000 144
69-72 0011011100 0000000 0000000 000000000000 000001000000 145
9-12 0011011010 0000000 0000000 000000000001 000101001000 146
13-16 0010011110 1111111 0000000 000000000000 001101010000 147
17-20 0011011100 0000000 0000000 000000000001 000101001000 150
21-24 0011101110 0000000 0000000 000000000000 000001000000 151
The first 10 bits give the instruction, the next 7 bits the first
B-register called Ba, the next 7 bits the second B-register called Bm
and the remaining 24 bits give the address. The top bit of the
instruction indicates an extracode which doesn't get used here. The
next 9 bits give the octal value of the instruction. Using the
standard Atlas layout for machine instructions (the B-registers are
in decimal) gives:
141 0334 0 0 10 Load storage location 10 into the floating point accumulator (Acc)
142 0236 127 0 145 Jump to address 145 if Acc is greater or equal to zero
143 0334 0 0 1044 Otherwise load the contents of address 1044 into Acc
144 0334 0 0 10 Store the contents of Acc in to address 10
145 0334 0 0 10 Store the contents of Acc in to address 10
146 0332 0 0 1051 Negate Acc and add the contents of 1051
147 0236 127 0 152 Jump to address 152 if Acc is greater or equal to zero
150 0334 0 0 1051 Otherwise load the contents of address 1051 into Acc
151 0356 0 0 10 Store contents of Acc in to address 10
So what are the contents of address 1044(8) and 1051(8)?
The answer is that we have to look at the VECTOR33 card columns 65 to
68 and columns 21 to 24 of VECTOR34.
1044 000011000000 000000000000 000000000000 000000000000
1051 000011000000 000000000000 000000000001 111111111000
Both 1044 and 1051 have an exponent of 24 which moves the fractional
values leftwards to having the integer values 0 and 1023 as expected.
In consequence, the sequence above is equivalent to the Fortran
statements:
IF(V.LT.0) V=0
IF(V.GT.1023) V=1023
So the VECTOR subroutine does constrain values provided as parameters
to be in the range 0 to 1023.
The compiled code is reasonably efficient but not optimal.
6. Conclusions
The big question was whether the card deck we found was the program
that generated the film called The Flexipede. The Java program
indicated that the program generated 1784 frames of film. Kate
managed to find a Job Control card saying it was the final run and
the lineprinter output giving the results of the run on the London
Atlas. This was:
LRF91PB1, A PRITCHETT BL120 TEST
DATE 07.10.67
TIME 14.35.27
SERIAL NUMBER 12337285
REQUESTED USED COMPILE
INSTRUCTION INTERRUPTS 96000 43353 1360
COMPILE STORE 120 89
EXECUTION STORE 50 34
DECKS BLOCKS WAITING
MAGNETIC TAPES 1 37 56
IBM MAGNETIC TAPES 1 1799
STORE TIME DRUM TIME DECK TIME
16718 10 322
COMPILER NUMBER 34
F FACTOR 18
BC 1 758
BC 2 762
INPUT 0 11 BLOCKS READER 1
INPUT 1 1 BLOCKS READER 1
INPUT 2 3 BLOCKS READER 1
OUTPUT 0 648 RECORDS LINE PRINTER
OUTPUT 13 32 RECORDS ANY
The run was made on 7 October 1967, ran for 4 minutes and 31 seconds
(of which 8.5 secs were for compilation). The main output was 1799
blocks of IBM magnetic tape. Magnetic tape blocks destined for the
SC4020 and BL120 had a maximum of 512 instructions. New frames took
place each advance film. Looking at the amount of instructions
required for each flexipede frame this was well within the 512
instruction limit for all but the most complex scene. The tongue is
the main drawing that needs vectors greater than 64 units long. Tapes
destined for the BL120 had header and footer frames added to identify
whose output it was. In consequence, the flexipede program generating
1784 film frames would require a few more than 1784 blocks of IBM
tape so 1799 blocks produced is pretty well exactly what you would
expect for a complete run of the Flexipede card deck. The evidence is
not conclusive but leads us to believe that Kate does have the card
deck that generated the film The Flexipede.
Some of the manuals that Tony had related to his use of the Culham
BL120 microfilm recorder from the London Atlas are available at the
Chilton website. Links to these and the various animations of The
Flexipede described above are:
* Original Flexipede Film
* Flexipede in SVG compared with Original
* Flexipede in SVG using either SVG animation or Javascript (GSAP)
* Flexipede via Java
* Flexipede via Java with the SCORS simple clip at the edge of the
display area
* Flexipede via Java with SCORS clip, soundtrack and titles
* Fortran V Manual, 1967
* Benson-Lehner 120 Manual, 1966
* SC4020 Plotter Manual, 1967
* SC4020 Supplement (FORTRAN), 1969
* Algol GROATS Manual, 1969
* GROATS Implementation, 1970
* GHOST Manual, 1967
* GHOST Guide, 1967
7. Acknowledgements
We would like to thank Paul Hopgood for getting rid of the worst of
the background noise on the soundtrack and increasing it to a
meaningful volume. Also to Victoria Marshall at Chilton who made us
aware of the possibilities, provided a home for online copies of the
relevant manuals etc, and gave some useful comments on the paper.
Some Early Tests