Stephen's sdlBasic programs 3

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().

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[10] : dim r[10] : dim a[10]
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))

' head
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
' END HEAD
' 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 display of strange attractor

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

sdlBasic page 3