 Access Key Details

## sdlBasic page 3

If you have been reading my articles for the TI99/4a Home Computer you will have realised my interest in strange graphics. Moving on to a modern PC, there isn't too much available to allow you to have fun with these little programs, but at last I found a very old language- although far more recent than the 1979 TI Basic. This is sdlBasic, a cross platform language (Atari, Windows, Mac, Unix (Linux) etc.

There is a discrepancy between my sdlbasic and the documentation- in theory rnd() should return a number up to 999999999, but in practice it returns a number up to 32 bit signed maxint. To solve this I have used rnd(999999999) instead of rnd().

My sdlbasic page 1 || My 2nd sdlbasic page
Alphabetical index to the sdlbasic programs on this website.

The small images are portions of the displayed screen.

String Art Before home computers there was string art. On a baseboard covered with felt, hammer pins in, then lace bright thread around the pins. Some images were representational but many pictures were attractive shapes which appeared as if by magic as the lines crossed each other. This is a computer method, from "The loom of creation" in "Keys to Infinity" by Clifford A Pickover, 1995. Click on the image to see more shapes.
```'string art  for sdlbasic  (Windows, Unix etc etc)
'  S Shaw, 2013
SetDisplay(800,800,16,2) RANDOMIZE(timer)
p=3.1415926
scale=350 : ofs=390
r=1 : a=6 : b=6 :  dta=0
WHILE INKEY<>k_esc
cls
for i= 0 to 360
t=i*p/180.0
x=r*cos(t)
y=r*sin(t)
x2=r*cos(a*t)
y2=r*sin(b*t)```
``` line(x*scale+ofs,y*scale+ofs,x2*scale+ofs,y2*scale+ofs) next locate(1,1) : prints ("ESC to exit, n for next, r for random ")```
```   WAITKEY
IF INKEY=78 OR INKEY=110 THEN
dta=dta+1
if dta=1 then
a=2 : b=2
end if
if dta=2 then
a=3 : b=3
end if
if dta=3 then
a=100 : b=100
end if
if dta=4 then
a=2 : b=3 : dta=0
end if
end if
if inkey=82 or inkey=114 then
a=int(rnd(14)+1) : b=int(rnd(18)+1)
end if
wait(180)
wend
END```

Entwistle Generator Based upon an article in Fractal Report No 22, August 1992 by Ian Entwistle.
```' Entwistle Generation 91 from Gumowski and Mira
' functions with symmetric attractors for sdlbasic
'      (Windows, Unix etc etc)
'  S Shaw, 2013
' A between -1 and 1  B between 0.9 and 1.0001 ' m is a scalar
SetDisplay(1000,1000,16,2)
RANDOMIZE
it=4500 : cy=30 :  m=1
a=rnd(10000)/10000    :   b=0.90 + rnd(1000)/10000
if rnd(10)<5 then
a=-a
end if
b=b+rnd(10000)/10000000
WHILE INKEY<>k_esc
sc=1
cls
for t=1 to cy
c=2-2*a : x=4 : y=0 : w=a*x+c*x*x/(1+x*x)
for n=0 to it
dot(x*m*sc+490,y*m*sc+490)
z=x : x=b*y+w : u=x*x : w=a*x+c*u/(1+u) : y=w-z
next
sc=sc+1
next```
``` locate(1,1) : prints ("ESC to exit, i to zoom in, o to zoom out, space for another ") locate(40,65): fprints("a b sc ") locate(40,66): fprints(a) : fprints(" ") : fprints(b) : fprints(" ") fprints(sc) WAITKEY IF INKEY=73 OR INKEY=105 THEN m=m*1.5 END IF IF INKEY=79 OR INKEY=111 THEN m=m*0.65 END IF IF INKEY=32 THEN a=rnd(10000)/10000 : b=0.90 + rnd(1000)/10000 : m=1 if rnd(10)<5 then```
```      a=-a
end if
b=b+rnd(10000)/10000000
END IF
wend
END```

AT and T Graphics This has a long history before I saw it, but it started out as a program written for AT&T.
AT&T have a graphic routine to demo their DMD5620 terminal. and Peter Maurer (a mathematician of AT&T) published the algorithm in The American Mathematical Monthly, Vol 94. pages 631 to 645. This was in turn picked up by Keith Devlin and published in The Guardian on June 2nd 1988.

Maurer Rose on Wikipedia || A rose is a rose maths paper.

TI99/4A Group member Mike Cavanagh passed the general algorithm to me in 1989. Click on the small sample image for a collection of images put together into one big image.

This one here is essentially asymetric but many end results are quite pleasing, and a number of different graphics appear.

```'a t and t line-art  for sdlbasic
'     (Windows, Unix etc etc)
'  S Shaw, 2013
SetDisplay(800,800,16,2) RANDOMIZE(timer)
scale=350 : ofs=390
n=4 : d=43 : flag=0
WHILE INKEY<>k_esc
cls
A=0 : a=a+d
NEWX=ofs : NEWY=ofs
WHILE A>0.001
A=A+d
A=(A/360-INT(A/360))*360 : A=INT(A+0.0001)
X=n*A : X=(X/360-INT(X/360))*6.283185307
R=SIN (X)
T=A*0.0174532925
OLDX=NEWX : OLDY=NEWY
NEWX=R*SIN(T)*scale+ofs : NEWY=R*COS(T)*scale+ofs
'do not plot first line to reduce asymetry
flag=flag+1
if flag>1 then
LINE(OLDY,OLDX,NEWY,NEWX)
end if
END WHILE```
``` locate(1,1) : prints ("ESC to exit, r for random ") WAITKEY if inkey=82 or inkey=114 then n=int((rnd(35900)/100)+1) : d=int((rnd(35900)/100)+1)```
```   NEWX=ofs : NEWY=ofs : flag=0
end if
wait(180)
wend
END
```

Simple string art I found this one in a computer magazine I contributed to in 1990. I don't know its name or original source. Take a small number of points, equidistant on a circle, then join each one to every other one with a line. Fast and simple. And kind of pretty.
```'  image  using sdlBasic (Windows, Unix etc etc)
'   from ti*mes 29 p28
' take points equidistant on a circle and join each
' point to every other point with a line.  simple
'          S Shaw, 2014 SetDisplay(800,800,16,2)
pi=3.14159265
p=2*pi
dim a[30,1]
randomize
cls
n=int(((rnd(2600)/100))+4)
WHILE INKEY<>k_esc
for x=0 to n-1
a[x,0]=sin(p/n*x)*300+400
a[x,1]=cos(p/n*x)*300+400
next
fprints(n)
fprints("  ")
for i=0 to n-1
for ii=i+1 to n-1
line(a[i,1],a[i,0],a[ii,1],a[ii,0])
next
next
fprints("ESC to end, any other key for another")
WAITKEY
' delay
for x=1 to 1000000
next
cls
n=int(((rnd(2600)/100))+4)
WEND
END
```

Truchet Tiles The pattern is composed of just two tile designs, each design has a quarter circle in opposing corners, the second design is the first with different corners with circles. Think of a tile looking like this: If we place these tiles at true random one after the other in a rectangular array, they will sometimes form a complete circle, or a dumbell shape. For a truly random number generation, for every 800 tiles there should be about 40 complete circles and 10 simple dumbbells (two circles with a bridge).
The larger sample below has about 370 tiles, 4 dumbbells and 18 circles.
```'  using sdlBasic (Windows, Unix etc etc)
'   from ti*mes 31 p24
' Truchet Tiles  (an idea from 1704)
'   from Clifford Pickover
' "Computers Pattern Chaos and Beauty" (1990) p 329
'          S Shaw, 2014
SetDisplay(800,800,16,2)
pi=3.14159265 oldd=0
randomize
cls
dx=20
dy=20
xoff=0
yoff=0
r=dx/2

WHILE INKEY<>k_esc

for j=1 to 35*35
d=int((rnd(199999)/100000))
' select 0 or 1 random tile design

if d=1 then

if oldd=0 then
xoff=xoff+dx
end if

for i=90 to 180 step 2
x=r*cos(i/180*pi)+xoff
y=r*sin(i/180*pi)+yoff
dot(x,y)
next
xc=xoff-dx
yc=yoff+dy
for i=270 to 360 step 2
x=r*cos(i/180*pi)+xc
y=r*sin(i/180*pi)+yc
dot(x,y)
next
end if

if d=0 then

if oldd=1 then
xoff=xoff-dx
end if

for i=0 to 90 step 2
x=r*cos(i/180*pi)+xoff
y=r*sin(i/180*pi)+yoff
dot(x,y)
next
xc=xoff+dx
yc=yoff+dy
for i=180 to 270 step 2
x=r*cos(i/180*pi)+xc
y=r*sin(i/180*pi)+yc
dot(x,y)
next
end  if

xoff=xoff+dx

if xoff>700  then
yoff=yoff+dy
xoff=0
end if
oldd=d
next

fprints("   ESC to end, any other key for another   ")
WAITKEY
cls
dx=20
dy=20
xoff=0
yoff=0
r=dx/2
jump=180/dx

WEND
END
```

Symmetric Network Generation Stability Plot This is from page 150-151 of Clifford Pickover's book as noted below. The code is fairly small but the plots cover a wide range of shapes. It needs fine tuning if you want something completely symmetrical. It does not plot a network but rather the behaviour of a random network with various nodes, feedback and feedforward paths. How stable is the network? It is the stability that is being visualised. The arrays are conservatively constrained here and there is much opportunity for more experimental values. Array l is the length array and could have three values say 10, 5 and 10. Array a is the angle array and could be three values 30, 45 and 60. Array r is the repeat array and could have three values 4, 5 and 6. The three nested loops that do the drawing are i (overall repetition), and j (number of items in the arrays eg 3), k is the network interconnections.
```'  using sdlBasic (Windows, Unix etc etc) '   from ti*mes 31 p66
'   (an idea from Clifford Pickover
' "Computers Pattern Chaos and Beauty (1990)
'          S Shaw, 2014
SetDisplay(800,800,16,2)
pi=3.14159265
randomize
oc=200 : scale=1 : ct=0
dim l : dim r : dim a
WHILE INKEY<>k_esc
cls
oldx=90 : x=90 : oldy=110 : y=110
theta=0
for i=1 to ct*1.3333333
for j=1 to sets
for k=1 to r[j]
theta=theta+a[j]
if theta>(2*pi+.00001) then
theta=theta-2*pi
end if
x=l[j]*sin(theta)+x
y=l[j]*cos(theta)+y```
``` line(oldx*scale+oc,oldy*scale+oc,x*scale+oc,y*scale+oc)```
```         oldx=x : oldy=y
next
next
next
fprints("space  for initial image, ESC to exit")
fprints(" i and o to zoom in and out")
WAITKEY
cls
if inkey=32 then
cls
ct=0
sets=int(rnd(6000)/1000)+1
for i=1 to sets
l[i]=int(rnd(8000)/1000)+18
ang=rnd(360000)/1000
if ang <12.1  then
ang=ang+12.15
end if
if ang>350 then
ang=ang-12.1
end if
if ang>160 AND ang <210 then
ang=ang/4
end if
a[i]=ang*pi/180
r[i]=int(rnd(5000)/1000)+3
ct=ct+r[i]
next

fprints("any key for another, ESC to exit")
fprints(" i and o to zoom in and out")
end if
IF INKEY=73 OR INKEY=105 THEN
scale=scale*1.2
cls
END IF
IF INKEY=79 OR INKEY=111 THEN
scale=scale*0.8
cls
END IF
WEND
END```

Visualising Randomness We have a poor idea of what randomness is. This little program will visualise for you what an ordered and quite none-random sequence can look like, what a random sequence looks like, and what an interfered-with random sequence looks like - we are not visuallising randomness but rather the predictability of distribution. This type of graphing has been used to identify significant points in the DNA chain. Whatever it is and whatever it does, it is worth a look and an experiment.
```'   using sdlBasic (Windows, Unix etc etc)
'   from ti*mes 31 p66 - Plotting Randomness
'   (an idea from Clifford Pickover "Computers Pattern
'      Chaos and Beauty (1990))
'          S Shaw, 2014

SetDisplay(800,800,16,2)
randomize
cls
fprints("ESC to end")
box(2,2,798,798) : circle(400,400,340)
x=400 : oldx=400 : y=400 : oldy=400
c=1 : sp=1

WHILE INKEY<>k_esc

' rem three alternative codings to
'    rem in / rem out:
' rem using random numbers (?)
c=int(rnd(8000)/1000)+1

' rem absolutely none random sequence- use
' c=c*(c<8)+1```
``` ' rem where c runs 1,2,3,4,5,6,7,8,1,2,3,4,5,6,7,8 and so on. ' rem or spanner in the works- random with a hitch about every 80th value ' c=int(rnd(8000)/1000)+1 : sp=rnd(82) ' if sp=20 then ' c=3 ' end if ' rem try changing the value of c here from 1 to 8 and see the difference. X=X+(C=1)*-1 : X=X+(C=2)*-1 : X=X+(C=3)*-1 : X=X+(C=4)*1 : X=X+(C=5)*1 : X=X+(C=6)*1 Y=Y+(C=2)*1 : Y=Y+(C=3)*-1 : Y=Y+(C=5)*1:: Y=Y+(C=6)*-1 : Y=Y+(C=7)*1 :Y=Y+(C=8)*-1```
```
line(oldx,oldy,x,y) : oldx=x : oldy=y
locate(40,40)
fprints(c)
WEND
END
```

Random Cartoon Faces If you think this is a lot of code for not much output, do read the original book text- pages of it! to appreciate the potential uses for visualisation of this nature.
```'  image  using sdlBasic (Windows, Unix etc etc)
'   random faces -  pages 47 and  327 of Computers
'     Chaos Pattern and Beauty
'   by Clifford A Pickover).(1990)
'          for ti by S Shaw 1990  - SDL BASIC 2014
' headings in the book  include auto-correlation
'        cartoon-faces for speech,
'  cartoon faces in education, cognitive
'      association of coordinates with
' facial features, target-pictures for children,
'         faces and cancer genes.
SetDisplay(800,800,16,2)
pi=3.1415926 : S=4
' S sets scale
RANDOMIZE
WHILE INKEY<>k_esc
cls
fprints("ESC to end, other for random next")

Z=150 : OX=50 : OY=50
' select 10 features at random - 100 possibilities P1=5+INT(RND(6))-INT(RND(6))
P2=5+INT(RND(6))-INT(RND(6))
P3=5+INT(RND(6))-INT(RND(6))
P4=5+INT(RND(6))-INT(RND(6))
P5=5+INT(RND(6))-INT(RND(6))
P6=5+INT(RND(6))-INT(RND(6))
P7=5+INT(RND(6))-INT(RND(6))
P8=5+INT(RND(6))-INT(RND(6))
P9=5+INT(RND(6))-INT(RND(6))
P10=5+INT(RND(6))-INT(RND(6))

Z=150
EX=0 : EY=0 :: R=30
IF P1>5 THEN
EX=(P1-5)*2
ELSEIF P1<5 THEN
EY=ABS((P1-5)*2)
END IF
FOR T=1 TO 360
X=(R+EX)*cos(T/180*pi)+50
Y=(R+EY)*sin(T/180*pi)+50
IF T=1 THEN
DOT (X*S,Z*S-Y*S)
ELSE
LINE(OX*S,Z*S-OY*S,X*S,Z*S-Y*S)
END IF
OX=X :: OY=Y
NEXT
' eye P2 P7 P8
Z=150 : EX=0 : EY=0 : R=5
IF P2>5 THEN
EX=(P2-5)*2
ELSEIF P2<5 THEN
EY=ABS((P2-5)*2)
END IF
P7=P7-5 : P8=(P8-5)/2
FOR T=1 TO 360
X=(R+P8+EX)*COS(T/180*pi)+40-P7
Y=(R+P8+EY)*SIN(T/180*pi)+60
IF T=1 THEN
DOT(X*S,Z*S-Y*S)
ELSE
LINE(OX*S,Z*S-OY*S,X*S,Z*S-Y*S)
END IF
OX=X : OY=Y
NEXT
FOR T=1 TO 360
X=(R+P8+EX)*COS(T/180*pi)+60+P7
Y=(R+P8+EY)*SIN(T/180*pi)+60
IF T=1 THEN
DOT(X*S,Z*S-Y*S)
ELSE
LINE(OX*S,Z*S-OY*S,X*S,Z*S-Y*S)
END IF
OX=X : OY=Y
NEXT
'END EYE
' pupil P3 P7
Z=150 : PS=P3/6
FILLCIRCLE(40*S-P7*S,Z*S-60*S,(PS*S)+2)
FILLCIRCLE(60*S+P7*S,Z*S-60*S,(PS*S)+2)
' END PUPIL OF EYES
' eyebrow P4
Z=150 : Y1=70 : Y2=70 : Y1=(P4-5)+Y1 : Y2=Y2-(P4-5)
DOT(35*S,Z*S-Y1*S)
LINE(35*S,Z*S-Y1*S,45*S,Z*S-Y2*S)
DOT(55*S,Z*S-Y2*S)
LINE(55*S,Z*S-Y2*S,65*S,Z*S-Y1*S)
' END EYEBROW
' nose  P5
Z=150 : P5=(P5-5)/2 : DOT(50*S,Z*S-55*S)
LINE(50*S,Z*S-55*S,46*S,Z*S-45*S-P5*S)
LINE(46*S,Z*S-45*S-P5*S,54*S,Z*S-45*S-P5*S)
LINE(54*S,Z*S-45*S-P5*S,50*S,Z*S-55*S)
' END NOSE
' mouth - P9 P6 P10 - THE HARDEST BIT TO DO```
``` Z=150 : P9=P9-5 : X1=40-P9 : Y1=35 : X2=60+P9 : Y2=35 : X3=(X2-X1)/2+X1 : Y3=(P6-5)+35```
```   FOR K=1 TO 2
IF K=2 THEN
Y3=Y3+P10/2
END IF```
``` OX=X1 : OY=Y1 : D=X1^2*(X2-X3)+X1*(X3^2-X2^2)+X2^2*X3-X3^2*X2 A=(Y1*(X2-X3)+X1*(Y3-Y2)+Y2*X3-Y3*X2)/D BB=(X1^2*(Y2-Y3)+Y1*(X3^2-X2^2)+X2^2*Y3-X3^2*Y2)/D C=(X1^2*(X2*Y3-X3*Y2)+X1*( X3^2*Y2-X2^2*Y3)+Y1*(X2^2*X3-X3^2*X2))/D FOR I=X1 TO X2 X=I : Y=A*I^2+BB*I+C : LINE(OX*S,Z*S-OY*S,X*S,Z*S-Y*S) : OX=X : OY=Y```
```      NEXT
NEXT
WAITKEY
IF INKEY=82 OR INKEY=114 THEN
CLS
END IF
WEND
END
```

Popcorn 1 The original version of this listing used *X and *Y but I like varying things a bit so this listing will cycle through three variations: multiply X and Y; add X and Y, add one and multiply the other. Use key R to pass to the next variant.
```'  from Clifford Pickover via A K Dewdney
'   from ti*mes 36  Popcorn 1
'    for TI99/4a by S Shaw 1992
'          S Shaw, 2014
SetDisplay(800,800,16,2)
randomize cls
fprints("ESC to end, R for next")
H=0.05
flag=1
WHILE INKEY<>k_esc
FOR J=1 TO 30 step 0.5
FOR K=1 TO 30 step 0.5
X=-4.3+J/3
Y=-4.3+K/3
FOR N=1 TO 70
if flag=1 then
XX=X-H*SIN(Y+TAN(3+Y))
YY=Y-H*SIN(X+TAN(3+X))
end if
if flag=2 then
XX=X-H*SIN(Y+TAN(3*Y))
YY=Y-H*SIN(X+TAN(3*X))
end if
if flag=3 then
XX=X-H*SIN(Y+TAN(3+Y))
YY=Y-H*SIN(X+TAN(3*X))
end if
X=XX
Y=YY
ROW=X*50
COL=Y*50
DOT(COL+850,ROW+870)
NEXT
NEXT
NEXT
fprints("            flag=") : fprints(flag)
WAITKEY
IF INKEY=82 OR INKEY=114 THEN
CLS : fprints("ESC to end, R for next")
flag=flag+1
if flag=4 then
flag=1
end if
END IF
WEND
END
```

Attractor This is coding for a set of attractors, from Clifford Pickover "Computers and the Imagination". The attractors have been given no name but as Clifford plotted 1E6 points he called them "million point graphics". Many variations are possible- most will end up as a random scatter of points, but a few yield very odd shapes indeed.

```'  image  using sdlBasic (Windows, Unix etc etc)
'   attractor '   an idea from Clifford Pickover
'   Computers and the Imagination
'          S Shaw, 2014 / 2017
SetDisplay(800,800,16,2)
randomize
cls
while inkey<>k_esc
' a,b=1 is boring but try others eg a,b=2

a=2:b=1

' starting point x,y seems to
'     have little effect
x=int(rnd(9999/10000)*40)
y=int(rnd(9999/10000)*40)

for t=1 to 400000
v1=sin(y*b):v2=sin(x*b)
v3=sin(x*a):v4=sin(y*a)
' next lines sets the shape- try varying

nx=v1+v2*v2+v2*v2*v2:ny=v3+v1*v1+v1*v1*v1

' or nx=v1+v2*v2: ny=v3+v4*v4
' or nx=v1+v2*v2+v2*v2*v2: ny=v3+v4*v4+v1*v1*v1 x=nx: y=ny
px=180*x+220:py=180*y+200
dot(px,py)
next

fprints("ESC to end")
waitkey
WEND
END
```