Langton's ant: Difference between revisions

From Rosetta Code
Content added Content deleted
(→‎{{header|Processing}}: Added PureBasic)
Line 515: Line 515:
set(x,y,white?#ffffff:#000000);
set(x,y,white?#ffffff:#000000);
}</lang>
}</lang>
=={{header|PureBasic}}==
[[File:PureBasic_Langtons_ant.png|thumb|Sample display of PureBasic solution]]
<lang purebasic>#White = $FFFFFF
#Black = 0
#planeHeight = 100
#planeWidth = 100
#canvasID = 0
#windowID = 0
OpenWindow(#windowID, 0, 0, 150, 150, "Langton's ant", #PB_Window_SystemMenu | #PB_Window_ScreenCentered)
CanvasGadget(#canvasID, 25, 25, #planeWidth, #planeHeight)
StartDrawing(CanvasOutput(#canvasID))
Box(0, 0, #planeWidth, #planeHeight, #White)
StopDrawing()

Define event, quit, ant.POINT, antDirection, antSteps

ant\x = #planeHeight / 2
ant\y = #planeWidth / 2
Repeat
Repeat
event = WindowEvent()
If event = #PB_Event_CloseWindow
quit = 1
event = 0
EndIf
Until event = 0

StartDrawing(CanvasOutput(#canvasID))
Select Point(ant\x, ant\y)
Case #Black
Plot(ant\x, ant\y, #White)
antDirection = (antDirection + 1) % 4 ;turn left
Case #White
Plot(ant\x, ant\y, #Black)
antDirection = (antDirection - 1 + 4) % 4 ;turn right
EndSelect
StopDrawing()

Select antDirection
Case 0 ;up
ant\y - 1
Case 1 ;left
ant\x - 1
Case 2 ;down
ant\y + 1
Case 3 ;right
ant\x + 1
EndSelect
antSteps + 1
If ant\x < 0 Or ant\x >= #planeWidth Or ant\y < 0 Or ant\y >= #planeHeight
MessageRequester("Langton's ant status", "Out of bounds after " + Str(antSteps) + " steps.")
quit = 1
EndIf
Delay(10) ;control animation speed and avoid hogging CPU
Until quit = 1</lang>
Sample output:
<pre>Out of bounds after 11669 steps.</pre>


=={{header|Python}}==
=={{header|Python}}==

Revision as of 18:49, 7 December 2011

Task
Langton's ant
You are encouraged to solve this task according to the task description, using any language you may know.

Langton's ant models an ant sitting on a plane of cells, all of which are white initially, facing in one of four directions. Each cell can either be black or white. The ant moves according to the color of the cell it is currently sitting in, with the following rules:

  1. If the cell is black, it changes to white and the ant turns left;
  2. If the cell is white, it changes to black and the ant turns right;
  3. The Ant then moves forward to the next cell, and repeat from step 1.

This rather simple ruleset leads to an initially chaotic movement pattern, and after about 10000 steps, a cycle appears where the ant moves steadily away from the starting location in a diagonal corridor about 10 pixels wide. Conceptually the ant can then travel to infinitely far away.

For this task, start the ant near the center of a 100 by 100 field of cells, which is about big enough to contain the initial chaotic part of the movement. Follow the movement rules for the ant, terminate when it moves out of the region, and show the cell colors it leaves behind.

The problem has received some analysis, for more details, please take a look at the Wikipedia article.

C

Requires ANSI terminal. <lang c>#include <stdio.h>

  1. include <stdlib.h>
  2. include <string.h>
  3. include <unistd.h>

int w = 0, h = 0; unsigned char *pix;

void refresh(int x, int y) { int i, j, k; printf("\033[H"); for (i = k = 0; i < h; putchar('\n'), i++) for (j = 0; j < w; j++, k++) putchar(pix[k] ? '#' : ' '); }

void walk() { int dx = 0, dy = 1, i, k; int x = w / 2, y = h / 2;

pix = calloc(1, w * h); printf("\033[H\033[J");

while (1) { i = (y * w + x); if (pix[i]) k = dx, dx = -dy, dy = k; else k = dy, dy = -dx, dx = k;

pix[i] = !pix[i]; printf("\033[%d;%dH%c", y + 1, x + 1, pix[i] ? '#' : ' ');

x += dx, y += dy;

k = 0; if (x < 0) { memmove(pix + 1, pix, w * h - 1); for (i = 0; i < w * h; i += w) pix[i] = 0; x++, k = 1; } else if (x >= w) { memmove(pix, pix + 1, w * h - 1); for (i = w-1; i < w * h; i += w) pix[i] = 0; x--, k = 1; }

if (y >= h) { memmove(pix, pix + w, w * (h - 1)); memset(pix + w * (h - 1), 0, w); y--, k = 1; } else if (y < 0) { memmove(pix + w, pix, w * (h - 1)); memset(pix, 0, w); y++, k = 1; } if (k) refresh(x, y); printf("\033[%d;%dH\033[31m@\033[m", y + 1, x + 1);

fflush(stdout); usleep(10000); } }

int main(int c, char **v) { if (c > 1) w = atoi(v[1]); if (c > 2) h = atoi(v[2]); if (w < 40) w = 40; if (h < 25) h = 25;

walk(); return 0; }</lang>

D

A basic textual version. <lang D>import std.stdio, std.algorithm, std.traits;

enum Direction { up, right, down, left } enum Turn : bool { left = false, right = true } enum Color : char { white = '.', black = '#' }

void main() {

 enum width = 75, height = 52;
 enum nsteps = 12_000;
 auto M = new Color[][](height, width);
 int x = width / 2;
 int y = height / 2;
 auto dir = Direction.up;
 for (int i = 0; i < nsteps &&
      x >= 0 && y >= 0 && x < width && y < height; i++) {
   immutable turn = M[y][x] == Color.black ? Turn.left : Turn.right;
   M[y][x] = M[y][x] == Color.black ? Color.white : Color.black;
   immutable d = (4 + dir + (turn == Turn.right ? 1 : -1)) % 4;
   dir = [EnumMembers!Direction][d];
   final switch(dir) {
     case Direction.up:    y--; break;
     case Direction.right: x--; break;
     case Direction.down:  y++; break;
     case Direction.left:  x++; break;
   }
 }
 foreach (row; M)
   writeln(cast(char[])row);

}</lang> Output:

...........................................................................
...........................................................................
...........................................................................
...........................................................................
..........................##..############..##.............................
.........................##..#..........####..#............................
........................#.##............##...###...........................
........................#....#..#.........#..#.#...........................
......................#.......###.........#.#.##..##.......................
......................###..##.##.....#.....#...#..#.###....................
..................##..##.#..#.#...##.####.##..###..#.#.....................
.................###...###.....#.#.###..##.#..##.###.#.....................
................#.#.#.###...#..####..#.#.#####...#.....#...................
................#...#.###.#.######.##.##..####.#...##.###..................
.................##.###.#####...#.##.##.##.#.#.##.#.###.#..................
...............##.#....####..#.#...#...###.##.#...#.#......................
..............##.....#.##.....##..#...##.##.........#..#...................
.............#.##..##.###...#.....##..#..###.##.#.#...###..................
.............#...####.##..#....#..###...##.##...##..###..#.................
..............#.....#..###.##.#..##.####.#.#..#.#...#...###................
............##..#..#.##.###......#..###.#..#....##.#..###..#...............
...........#...##.####..####.#####..##..##.#.##.#.....#...###..............
..........#...#....#.#.#...##......##.#.#.###.#..#.#.#..###..#.............
..........#......#...####.####.......##...#.##..###.##..#...###............
...........#....#....#..####..#.###########..##...#..#.#..###..#...........
...........##..#....##..#..#########..##..####.#......##..#...###..........
..........#.####..##.#..#...###.###.##.##...##.#..##...#.#..###..#.........
..........#...##...###.###....#.#.##.#.##.######.#..#...##..#...###........
...........#...##....#.##..#.#.....#####.#.#####.....#...#.#..###..#.......
...........#..#..#.##..#..#...#.#..##.#####.##.#.....#....##..#...###......
...........##...##########...##.#####..#.####...#....#.....#.#..###..#.....
...............##.####.##...#..####...#..#...##...##.#......##..#...###....
.............#.#..#..#..#.#....#...#.##...##..#.#####........#.#..###..#...
.............##..##..#..##.#.#.##.##....#.#.#.##..##..........##..#...###..
.............#.####..##.#.#.########.#....#..#.................#.#..###..#.
.............#.##..#..#...##.##.......#...#..#..................##..#...###
.............####.##...##..##..#......#..#..#....................#.#..##...
............###.#...#....##..##.......#...##......................##..#..##
............####.###.####....####..##.#............................#.#.#.#.
...........#..#.#.##.#..##....####..##..............................##.####
..........#####.##.###.##....##....##................................#.##.#
..........####..#.##.#................................................####.
..........##.##.##.....................................................##..
................##.........................................................
........#.####..##.#.......................................................
........###..###.#..#......................................................
.........#..#..#.##.#......................................................
..........##......##.......................................................
.................##........................................................
...........................................................................
...........................................................................
...........................................................................

Icon and Unicon

<lang Icon>link graphics,printf

procedure main(A)

  e := ( 0 < integer(\A[1])) | 100   # 100 or whole number from command line
  LangtonsAnt(e)

end

record antrec(x,y,nesw)

procedure LangtonsAnt(e)

  size  := sprintf("size=%d,%d",e,e)
  label := sprintf("Langton's Ant %dx%d [%d]",e,e,0)
  &window := open(label,"g","bg=white",size) | 
              stop("Unable to open window") 
  ant := antrec(e/2,e/2,?4%4)
  board := list(e)
  every !board := list(e,"w")
  
  k := 0
  repeat {
     k +:= 1
     WAttrib("fg=red")
     DrawPoint(ant.x,ant.y)
     
     cell := board[ant.x,ant.y]
     if cell == "w" then {                        # white cell
        WAttrib("fg=black")
        ant.nesw := (ant.nesw + 1) % 4            # . turn right
        }
     else {                                       # black cell
        WAttrib( "fg=white")   
        ant.nesw := (ant.nesw + 3) % 4            # . turn left = 3 x right
        }
     board[ant.x,ant.y] := map(cell,"wb","bw")    # flip colour         
     DrawPoint(ant.x,ant.y)
     
     case ant.nesw of {                           # go
        0: ant.y -:= 1                            # . north
        1: ant.x +:= 1                            # . east
        2: ant.y +:= 1                            # . south
        3: ant.x -:= 1                            # . west
        }
        
     if 0 < ant.x <= e & 0 < ant.y <= e then next
     else break      
     }
  printf("Langton's Ant exited the field after %d rounds.\n",k)
  label := sprintf("label=Langton's Ant %dx%d [%d]",e,e,k)
  WAttrib(label)
  WDone()

end</lang>

printf.icn provides formatting graphics.icn provides graphics support (WDone)

J

<lang j>dirs=: 0 1,1 0,0 _1,:_1 0 langton=:3 :0

 loc=. <.-:$cells=. (_2{.y,y)$dir=. 0
 while. *./(0<:loc), loc<$cells do.
   color=. (<loc) { cells
   cells=. (-.color) (<loc)} cells
   dir=. 4 | dir +  _1 ^ color
   loc=. loc + dir { dirs
 end.
 ' #' {~ cells

)</lang>

   langton 100 100
                          # #                                                                       
                        ## # #                                                                      
                       # ### ##                                                                     
                      #### ### #                                                                    
                      ##### #  ##                                                                   
                       #   ## ## #                                                                  
                        ###   #  ##                                                                 
                         #   ## ## #                                                                
                          ###   #  ##                                                               
                           #   ## ## #                                                              
                            ###   #  ##                                                             
                             #   ## ## #                                                            
                              ###   #  ##                                                           
                               #   ## ## #                                                          
                                ###   #  ##                                                         
                                 #   ## ## #                                                        
                                  ###   #  ##                                                       
                                   #   ## ## #                                                      
                                    ###   #  ##                                                     
                                     #   ## ## #                                                    
                                      ###   #  ##                                                   
                                       #   ## ## #                                                  
                                        ###   #  ##                                                 
                                         #   ## ## #                                                
                                          ###   #  ##                                               
                                           #   ## ## #                                              
                                            ###   #  ##                                             
                                             #   ## ## #                                            
                                              ###   #  ##                                           
                                               #   ## ## #                                          
                                                ###   #  ##                                         
                                                 #   ## ## #  ##                                    
                                                  ###   #  ##  ##                                   
                                                   #   ## ##  ##   #                                
                                             ####   ###   #   #  ###                                
                                            #    #   #   ## ####   #                                
                                           ###    #   # #      # ## #                               
                                           ###    # ##     # ##  # ##                               
                                            #    #   ## # #     ##                                  
                                            # #      # #####  #   #                                 
                                           #   #####          ## ######                             
                                           ###  ##  # ## # # #   ## # ##                            
                                         ##  # ####### #   #  ###    ## #                           
                                        #  #  ###### ##   #  # ##   #   #                           
                                       #    # # ## #  ###### #######   #                            
                                       # #### ## # ####    ##  ## # ## #                            
                                        #    ####   #  # ###### ##    ###                           
                                           #   # ## # ### #  ##  ##   ###                           
                                              #######    #  ## ## #     #                           
                                      ####  ## ##  #### ## ## ##  #     #                           
                                     #    # #   ### ## ###    # ####    #                           
                                    ###       ### # # #####    # #      #                           
                                    # #   ### #### ## #   ## ### ##     #                           
                                          ## ##  ####    #### # # #     #                           
                                     #    #  ##   ###  ###     ###      #                           
                                     ##   ## ### ####  #      ###   ##  #                           
                                     ## # ####     #   #  # ## ### ##   #                           
                                    #### ##   ## ####  # #  #  #  ###   #                           
                                    # ## ###  # # ## # #     # #     # #                            
                                        # #  #    ## ##  # #  ### ##                                
                                        ## #    #  ##### #    #    #  # #                           
                                       # ## #  #    ## ## #  ###      ###                           
                                     # #   #  #  #  #  ###   ##  ##    #                            
                                    ### # ##### ###### ### ####### # ##                             
                                    # # #    #####   ##  ##### #####                                
                                      #  ##   #      #  # ##  ### ###                               
                                   ####   ##### #########   # #                                     
                              ##    #  #     ### # #   # ###  ###                                   
                             #  #  #### ##   ### ##   ### ##     ##                                 
                            ###    # ## # #####   #    #  #  ## ###                                 
                            # ##### # #   ##  ##     #    #   #  #                                  
                                ###### ####  ## #   #  ##  # # ##                                   
                              ##      # ### ##  ####   #   ###                                      
                               #  # #####  #   # ##   #  #  #                                       
                               ## ### #######     #     # ##                                        
                              # #  ## ##      #   ##    #                                           
                             #  # ####        ###  ##  #                                            
                             # ## ###            ##  ##                                             
                              ##                                                                    
                               ##                                                                   
                                                                                                    
                                                                                                    
                                                                                                    
                                                                                                    
                                                                                                    
                                                                                                    
                                                                                                    
                                                                                                    
                                                                                                    
                                                                                                    
                                                                                                    
                                                                                                    
                                                                                                    
                                                                                                    
                                                                                                    
                                                                                                    
                                                                                                    
                                                                                                    
                                                                                                    
                                                                                                   

OCaml

<lang ocaml>open Graphics

type dir = North | East | South | West

let turn_left = function

 | North -> West
 | East  -> North
 | South -> East
 | West  -> South

let turn_right = function

 | North -> East
 | East  -> South
 | South -> West
 | West  -> North

let move (x, y) = function

 | North -> x, y + 1
 | East  -> x + 1, y
 | South -> x, y - 1
 | West  -> x - 1, y

let () =

 open_graph "";
 let rec loop (x, y as pos) dir =
   let color = point_color x y in
   set_color (if color = white then black else white);
   plot x y;
   let dir = (if color = white then turn_right else turn_left) dir in
   if not(key_pressed()) then loop (move pos dir) dir
 in
 loop (size_x()/2, size_y()/2) North</lang>

Run with:

$ ocaml graphics.cma langton.ml

PARI/GP

<lang parigp>langton()={

 my(M=matrix(100,100),x=50,y=50,d=0);
 while(x && y && x<=100 && y<=100,
   d=(d+if(M[x,y],1,-1))%4;
   M[x,y]=!M[x,y];
   if(d%2,x+=d-2,y+=d-1);
 );
 M

}; show(M)={

 my(d=sum(i=1,#M[,1],sum(j=1,#M,M[i,j])),u=vector(d),v=u,t);
 for(i=1,#M[,1],for(j=1,#M,if(M[i,j],v[t++]=i;u[t]=j)));
 plothraw(u,v)

}; show(langton())</lang>

PicoLisp

This code pipes a PBM into ImageMagick's "display" to show the result: <lang PicoLisp>(de ant (Width Height X Y)

  (let (Field (make (do Height (link (need Width)))) Dir 0)
     (until (or (le0 X) (le0 Y) (> X Width) (> Y Height))
        (let Cell (nth Field X Y)
           (setq Dir (% (+ (if (car Cell) 1 3) Dir) 4))
           (set Cell (not (car Cell))) 
           (case Dir
              (0 (inc 'X))
              (1 (inc 'Y))
              (2 (dec 'X))
              (3 (dec 'Y)) ) ) )
     (prinl "P1")
     (prinl Width " " Height)
     (for Row Field
        (prinl (mapcar '[(X) (if X 1 0)] Row)) ) ) )

(out '(display -) (ant 100 100 50 50)) (bye) </lang>

Processing

Processing implementation, this uses two notable features of Processing, first of all, the animation is calculated with the draw() loop, second the drawing on the screen is also used to represent the actual state.

Sample output

<lang processing>/*

* we use the following conventions:
* directions 0: up, 1: right, 2: down: 3: left
*
* pixel white: true, black: false
*
* turn right: true, left: false
*
*/

// number of iteration steps per frame // set this to 1 to see a slow animation of each // step or to 10 or 100 for a faster animation

final int STEP=100;

int x; int y; int direction;

void setup() {

 // 100x100 is large enough to show the
 // corridor after about 10000 cycles
 size(100, 100, P2D);
 background(#ffffff);
 x=width/2;
 y=height/2;
 direction=0;

}

int count=0;

void draw() {

 for(int i=0;i<STEP;i++) {
   count++;
   boolean pix=get(x,y)!=-1;
   setBool(x,y,pix);
 
   turn(pix);
   move();
 
   if(x<0||y<0||x>=width||y>=height) {
     println("finished");
     noLoop();
     break;
   }
 }
 if(count%1000==0) {
   println("iteration "+count);
 }

}

void move() {

 switch(direction) {
   case 0:
     y--;
     break;
   case 1:
     x++;
     break;
   case 2:
     y++;
     break;
   case 3:
     x--;
     break;
 }

}

void turn(boolean rightleft) {

 direction+=rightleft?1:-1;
 if(direction==-1) direction=3;
 if(direction==4) direction=0;

}

void setBool(int x, int y, boolean white) {

 set(x,y,white?#ffffff:#000000);

}</lang>

PureBasic

Sample display of PureBasic solution

<lang purebasic>#White = $FFFFFF

  1. Black = 0
  2. planeHeight = 100
  3. planeWidth = 100
  4. canvasID = 0
  5. windowID = 0

OpenWindow(#windowID, 0, 0, 150, 150, "Langton's ant", #PB_Window_SystemMenu | #PB_Window_ScreenCentered) CanvasGadget(#canvasID, 25, 25, #planeWidth, #planeHeight) StartDrawing(CanvasOutput(#canvasID))

 Box(0, 0, #planeWidth, #planeHeight, #White)

StopDrawing()

Define event, quit, ant.POINT, antDirection, antSteps

ant\x = #planeHeight / 2 ant\y = #planeWidth / 2 Repeat

 Repeat
   event = WindowEvent()
   If event = #PB_Event_CloseWindow
     quit = 1
     event = 0
   EndIf 
 Until event = 0
 StartDrawing(CanvasOutput(#canvasID))
   Select Point(ant\x, ant\y)
     Case #Black
       Plot(ant\x, ant\y, #White)
       antDirection = (antDirection + 1) % 4 ;turn left
     Case #White
       Plot(ant\x, ant\y, #Black)
       antDirection = (antDirection - 1 + 4) % 4 ;turn right
   EndSelect
 StopDrawing()
 Select antDirection
   Case 0 ;up
     ant\y - 1
   Case 1 ;left
     ant\x - 1
   Case 2 ;down
     ant\y + 1
   Case 3 ;right
     ant\x + 1
 EndSelect
 antSteps + 1
 
 If ant\x < 0 Or ant\x >= #planeWidth Or ant\y < 0 Or ant\y >= #planeHeight
   MessageRequester("Langton's ant status", "Out of bounds after " + Str(antSteps) + " steps.")
   quit = 1
 EndIf    
 
 Delay(10) ;control animation speed and avoid hogging CPU

Until quit = 1</lang> Sample output:

Out of bounds after 11669 steps.

Python

Translation of: D

<lang python>width = 75 height = 52 nsteps = 12000

class Dir: up, right, down, left = range(4) class Turn: left, right = False, True class Color: white, black = '.', '#' M = [[Color.white] * width for _ in xrange(height)]

x = width // 2 y = height // 2 dir = Dir.up

i = 0 while i < nsteps and 0 <= x < width and 0 <= y < height:

   turn = Turn.left if M[y][x] == Color.black else Turn.right
   M[y][x] = Color.white if M[y][x] == Color.black else Color.black
   dir = (4 + dir + (1 if turn else -1)) % 4
   dir = [Dir.up, Dir.right, Dir.down, Dir.left][dir]
   if   dir == Dir.up:    y -= 1
   elif dir == Dir.right: x -= 1
   elif dir == Dir.down:  y += 1
   elif dir == Dir.left:  x += 1
   else: assert False
   i += 1

print "\n".join("".join(row) for row in M)</lang> The output is the same as the basic D version.

Ruby

<lang ruby>class Ant

 Directions = [:north, :east, :south, :west]
 def initialize(plane, pos_x, pos_y)
   @plane = plane
   @position = Position.new(plane, pos_x, pos_y)
   @direction = :south
 end
 attr_reader :plane, :direction, :position
 def run
   moves = 0
   loop do
     begin
       if $DEBUG and moves % 100 == 0
         system "clear"
         puts "%5d %s" % [moves, position]
         puts plane
       end
       moves += 1
       move
     rescue OutOfBoundsException
       break
     end
   end
   moves
 end
 def move
   plane.at(position).toggle_colour
   position.advance(direction)
   if plane.at(position).white?
     turn(:right)
   else
     turn(:left)
   end
 end
 def turn(left_or_right)
   idx = Directions.index(direction)
   case left_or_right
   when :left  then @direction = Directions[(idx - 1) % Directions.length]
   when :right then @direction = Directions[(idx + 1) % Directions.length]
   end
 end

end

class Plane

 def initialize(x, y)
   @x = x
   @y = y
   @cells = Array.new(y) {Array.new(x) {Cell.new}}
 end
 attr_reader :x, :y
 def at(position)
   @cells[position.y][position.x]
 end
 def to_s
   @cells.collect {|row|
     row.collect {|cell| cell.white? ? "." : "#"}.join + "\n"
   }.join
 end

end

class Cell

 def initialize
   @colour = :white
 end
 attr_reader :colour
 def white?
   colour == :white
 end
 def toggle_colour
   @colour = (white? ? :black : :white)
 end

end

class Position

 def initialize(plane, x, y)
   @plane = plane
   @x = x
   @y = y
   check_bounds
 end
 attr_accessor :x, :y
 def advance(direction)
   case direction
   when :north then @y -= 1
   when :east  then @x += 1
   when :south then @y += 1
   when :west  then @x -= 1
   end
   check_bounds
 end
 def check_bounds
   unless (0 <= @x and @x < @plane.x) and (0 <= @y and @y < @plane.y)
     raise OutOfBoundsException, to_s 
   end
 end
 def to_s
   "(%d, %d)" % [x, y]
 end

end

class OutOfBoundsException < StandardError; end

  1. the simulation

ant = Ant.new(Plane.new(100, 100), 50, 50) moves = ant.run puts "out of bounds after #{moves} moves: #{ant.position}" puts ant.plane</lang>

output

out of bounds after 11669 moves: (26, -1)
..........................#.#.......................................................................
........................##.#.#......................................................................
.......................#.###.##.....................................................................
......................####.###.#....................................................................
......................#####.#..##...................................................................
.......................#...##.##.#..................................................................
........................###...#..##.................................................................
.........................#...##.##.#................................................................
..........................###...#..##...............................................................
...........................#...##.##.#..............................................................
............................###...#..##.............................................................
.............................#...##.##.#............................................................
..............................###...#..##...........................................................
...............................#...##.##.#..........................................................
................................###...#..##.........................................................
.................................#...##.##.#........................................................
..................................###...#..##.......................................................
...................................#...##.##.#......................................................
....................................###...#..##.....................................................
.....................................#...##.##.#....................................................
......................................###...#..##...................................................
.......................................#...##.##.#..................................................
........................................###...#..##.................................................
.........................................#...##.##.#................................................
..........................................###...#..##...............................................
...........................................#...##.##.#..............................................
............................................###...#..##.............................................
.............................................#...##.##.#............................................
..............................................###...#..##...........................................
...............................................#...##.##.#..........................................
................................................###...#..##.........................................
.................................................#...##.##.#..##....................................
..................................................###...#..##..##...................................
...................................................#...##.##..##...#................................
.............................................####...###...#...#..###................................
............................................#....#...#...##.####...#................................
...........................................###....#...#.#......#.##.#...............................
...........................................###....#.##.....#.##..#.##...............................
............................................#....#...##.#.#.....##..................................
............................................#.#......#.#####..#...#.................................
...........................................#...#####..........##.######.............................
...........................................###..##..#.##.#.#.#...##.#.##............................
.........................................##..#.#######.#...#..###....##.#...........................
........................................#..#..######.##...#..#.##...#...#...........................
.......................................#....#.#.##.#..######.#######...#............................
.......................................#.####.##.#.####....##..##.#.##.#............................
........................................#....####...#..#.######.##....###...........................
...........................................#...#.##.#.###.#..##..##...###...........................
..............................................#######....#..##.##.#.....#...........................
......................................####..##.##..####.##.##.##..#.....#...........................
.....................................#....#.#...###.##.###....#.####....#...........................
....................................###.......###.#.#.#####....#.#......#...........................
....................................#.#...###.####.##.#...##.###.##.....#...........................
..........................................##.##..####....####.#.#.#.....#...........................
.....................................#....#..##...###..###.....###......#...........................
.....................................##...##.###.####..#......###...##..#...........................
.....................................##.#.####.....#...#..#.##.###.##...#...........................
....................................####.##...##.####..#.#..#..#..###...#...........................
....................................#.##.###..#.#.##.#.#.....#.#.....#.#............................
........................................#.#..#....##.##..#.#..###.##................................
........................................##.#....#..#####.#....#....#..#.#...........................
.......................................#.##.#..#....##.##.#..###......###...........................
.....................................#.#...#..#..#..#..###...##..##....#............................
....................................###.#.#####.######.###.#######.#.##.............................
....................................#.#.#....#####...##..#####.#####................................
......................................#..##...#......#..#.##..###.###...............................
...................................####...#####.#########...#.#.....................................
..............................##....#..#.....###.#.#...#.###..###...................................
.............................#..#..####.##...###.##...###.##.....##.................................
............................###....#.##.#.#####...#....#..#..##.###.................................
............................#.#####.#.#...##..##.....#....#...#..#..................................
................................######.####..##.#...#..##..#.#.##...................................
..............................##......#.###.##..####...#...###......................................
...............................#..#.#####..#...#.##...#..#..#.......................................
...............................##.###.#######.....#.....#.##........................................
..............................#.#..##.##......#...##....#...........................................
.............................#..#.####........###..##..#............................................
.............................#.##.###............##..##.............................................
..............................##....................................................................
...............................##...................................................................
....................................................................................................
....................................................................................................
....................................................................................................
....................................................................................................
....................................................................................................
....................................................................................................
....................................................................................................
....................................................................................................
....................................................................................................
....................................................................................................
....................................................................................................
....................................................................................................
....................................................................................................
....................................................................................................
....................................................................................................
....................................................................................................
....................................................................................................
....................................................................................................
....................................................................................................
....................................................................................................

TI-83 BASIC

The initial Pxl-On(0,0) calibrates the screen, otherwise it doesn't work, and the variable N counts the generation number. <lang TI-83b>PROGRAM:LANT

ClrDraw
0→N
Pxl-On(0,0)
47→X
31→Y
90→Θ
Repeat getKey
If pxl-Test(Y,X)
Then
Θ+90→Θ
Else
Θ-90→Θ
End
Pxl-Change(Y,X)
X+cos(Θ°)→X
Y+sin(Θ°)→Y
N+1→N
End

</lang>