Langton's ant: Difference between revisions

 

;Related task:

<br><br>

 

=={{header|Ada}}==

 

procedure Langtons_Ant is

Ada.Text_IO.Put_Line("# Iteration:" & Integer'Image(Iteration));

end Langtons_Ant;

Ouptut (to save space, I have removed the all-blank lines):

<pre style="height:30ex;overflow:scroll"> ## ############ ##

=={{header|Aime}}==

[[File:ant_phpoFTAAk.png|100px|Output png]]

ant(integer x, y, d, list map)

{

 

0;

 

=={{header|ALGOL 68}}==

# size of board for Langton's ant #

INT max board = 100;

print( ( board[ r, min col : max col ], newline ) )

OD

{{out}}

<pre>

##

</pre>

 

=={{header|AutoHotkey}}==

ahk forum: [http://ahkscript.org/boards/viewtopic.php?f=17&t=1363 discussion]

{{works with|AutoHotkey 1.1}} (Fixed by just me)

SetBatchLines, -1

; Directions

HBM := DllCall("User32.dll\CopyImage", "Ptr", HBM, "UInt", 0, "Int", 0, "Int", 0, "Int", 8, "UPtr")

return DllCall("User32.dll\CopyImage", "Ptr", HBM, "UInt", 0, "Int", BMW, "Int", BMH, "UInt", 0x200C, "UPtr")

 

=={{header|AutoIt}}==

Global $iCountMax = 100000

Global $aFields[100][100][2]

Return 1

EndFunc ;==>_SetAnt

[http://www.imgbox.de/users/BugFix/langtons_ant.png To see the GUI output, click here.]

--[[User:BugFix|BugFix]] ([[User talk:BugFix|talk]]) 14:48, 16 November 2013 (UTC)

 

=={{header|AWK}}==

# usage: awk -v debug=0 -f langton.awk

 

}

END { print("END.") }

 

=={{header|BBC BASIC}}==

REM Implementation of Langton's ant for Rosetta Code

fieldsize%=100

UNTIL x%>fieldsize% OR x%<0 OR y%>fieldsize% OR y%<0

END

 

=={{header|bc}}==

The output function <code>o</code> prints the resulting image (as a [[wp:Netpbm_format|PBM image]]) to <code>stdout</code>. One can either store it into a file or pipe it through an image viewer (e.g. <code>bc langton.bc | display</code>).

 

auto i, j

 

l(100, 100, 50, 50)

 

=={{header|Befunge}}==

 

!"$(0@`vp00_^#!:p+7/"P"<<^g+7/*5"p"\%"P"/7::+g03*"d":_$,1+>:40g`!^1g03<

_::10g\v>00g+4%:00p::3\`\1-*50g+50p:2\-\0`*+::0\`\"c"`+50g:0\`\"c"`++#^

-*84g1<v^+1*2g09pg08g07-*g06-1*2p09:%2/g06:gp08:+7/*5"p"\p07:%"P"/7:p06

 

{{out}}

####

##</pre>

 

=={{header|C}}==

Requires ANSI terminal.

#include <stdlib.h>

#include <string.h>

walk();

return 0;

 

=={{header|C sharp|C#}}==

 

namespace LangtonAnt

}

}

Output:

<pre>

 

If you want to see it running infinitely, set the const bool INFINIT_RUN = true

#include <windows.h>

#include <string>

}

//--------------------------------------------------------------------------------------------------

 

=={{header|Chapel}}==

config const gridHeight: int = 100;

config const gridWidth: int = 100;

image.writeImage( "output.png" );

}

 

=={{header|Clojure}}==

In keeping with the spirit of Clojure, this program eschews mutable state entirely. Instead, all computation occurs within a single recursive loop whose "variables" are "adjusted" at each iteration, a natural fit for this particular execution model.

xs [1 0 -1 0] ys [0 -1 0 1]]

(loop [dir 0 x 50 y 50

(apply str

(map #(if (grid [% col]) \# \.)

 

=={{header|COBOL}}==

The following program displays the simulation in the console, and a very small font size (~4pt) will be needed to fit it into the window.

{{works with|OpenCOBOL}}

PROGRAM-ID. langtons-ant.

 

WITH BACKGROUND-COLOR White-Background

END-PERFORM

 

=={{header|CoffeeScript}}==

class Ant

constructor: (@world) ->

console.log "Ant is at #{ant.location}, direction #{ant.direction}"

world.draw()

 

output

 

> coffee langstons_ant.coffee

Ant is at -24,46, direction W

_____##_________________________________________

______##________________________________________

 

=={{header|Common Lisp}}==

 

(defun langtons-ant (width height start-x start-y start-dir)

 

(setf *random-state* (make-random-state t))

 

=={{header|D}}==

===Textual Version===

import std.stdio, std.traits;

 

 

writefln("%(%-(%c%)\n%)", M);

{{out}}

<pre>...........................................................................

===Image Version===

This similar version requires the module from the Grayscale Image Task to generate and save a PGM image.

 

void main() {

 

M.savePGM("langton_ant.pgm");

 

=={{header|Dyalect}}==

 

func move(ant) {

ant.position.x += xInc[ant.direction]

ant.position.y += yInc[ant.direction]

}

var leftTurn = this[ptCur.x][ptCur.y]

ant.direction =

ant.position

}

func newAnt(width, height) {

(

)

}

func run() {

while !ant.outOfBounds {

}

var iRow = 0;

while iRow < w {

var iCol = 0;

}

}

 

{{out}}

=={{header|EasyLang}}==

 

 

.

.

.

 

=={{header|EchoLisp}}==

We implement multi-colored ants, as depicted in the article. An ant is described using L(eft)R(ight) patterns. LR is the basic black and white ant, other are RRLLLRRL or RRLLLRLLLRRR. See results for s [http://www.echolalie.org/echolisp/images/ant-1.png black-and-white] or [http://www.echolalie.org/echolisp/images/ant-2.png colored] ants.

(lib 'plot)

(lib 'types)

 

(ant) ;; run

 

=={{header|Ela}}==

A straightforward implementation (assumes that we start with ant looking forward):

 

type Field = Field a

left Bwd = Rgt

left Rgt = Fwd

 

This implementation is pure (doesn't produce side effects).

Testing:

 

 

Output (empty lines are skipped to save space):

{{works with|Elixir|1.1+}}

{{trans|Ruby}}

def ant(sizex, sizey) do

{px, py} = {div(sizex,2), div(sizey,2)} # start position

end

 

 

{{out}}

 

=={{header|Elm}}==

import Matrix

import Time exposing (Time, every, second)

, update = update

, subscriptions = subscriptions

 

Link to live demo: https://dc25.github.io/langtonsAntElm/

=={{header|Erlang}}==

Over-engineered sine I have summer vacation. Ex: Display function only display lines with black cells.

-module( langtons_ant ).

 

plane_create( Controller, Max_x, Max_y ) -> [{plane_create_cell(Controller, Max_x, Max_y, {X, Y}), {X,Y}} || X <- lists:seq(1, Max_x), Y<- lists:seq(1, Max_y)].

plane_create_cell( Controller, Max_x, Max_y, Position ) -> erlang:spawn_link( fun() -> loop( #state{controller=Controller, max_x=Max_x, max_y=Max_y, position=Position} ) end ).

 

{{out}}

=={{header|Euphoria}}==

{{works with|Euphoria|4.0.3, 4.0.0 RC1 and later}}

include std\graphics.e

 

 

printf(1,"\n%d Iterations\n",iterations)

Code needed to run SDL example with Mark Akita's SDL_gfx_Test1.exw (as template) included with his SDL_gfx package from rapideuphoria.com's archive -

sequence grid = repeat(repeat(1,100),100) --fill 100 by 100 grid with white (1)

In main() , after keystate=SDL_GetKeyState(NULL) , you can adapt the program above to draw the ant's step each frame.

Use dummy=pixelColor(surface,x+20,y+12,#000000FF) (for example) to replace the text output.

Just before the close of the while loop, use dummy=pixelColor(surface,antData[1]+20,antData[2]+12,#FF0000FF) for the ant

and SDL_UpdateRect(surface,0,0,0,0) to display the graphic.

 

=={{header|Fantom}}==

 

class World

{

}

}

 

Output (snipping the blank lines):

{{works with|GNU Forth|0.7.0}}

All array manipulations were taken from Rosetta Code examples.

1 0 0 0 \ pushes orientation of the ant to the stack.

 

: langton.ant run.ant draw.grid ; \ launches the ant, outputs the result

 

{{out}}

<pre style="height:60ex;overflow:scroll">

=={{header|Fortran}}==

{{works with|Fortran|90 and later}}

implicit none

 

write(*,*)

end do

{{out}} (Cropped to save space)

<pre style="height:60ex;overflow:scroll">

 

===But, if one remembers complex numbers===

PROGRAM LANGTONSANT

C Langton's ant wanders across an initially all-white board, stepping one cell at a go.

Completed.

END

 

Output is the same, except for orientation. Here I have stuck to (x,y) Cartesian orientation rather than lines (y) increasing downwards. Just for fun, + signs mark cells that have been trampled and then cleaned. But not to pure white... Notice that some interior cells have never been trampled.

 

=={{header|FreeBASIC}}==

' compile with: fbc -s gui

 

'Print : Print "hit any key to end program"

Sleep

 

=={{header|Gambas}}==

 

hGridView As GridView 'The display is on a GridView

End With

 

'''[http://www.cogier.com/gambas/Langton's%20ant.png Click here for an image of the result]'''

 

To make it easier to see the output on small Atari screens, the output is written to a text file.

 

'

' Langton's ant

WEND

RETURN

 

=={{header|Go}}==

[[file:GoAnt.png|right|thumb|Output png]]

 

import (

fmt.Println(err)

}

 

=={{header|Haskell}}==

Necessary import:

 

 

In order to express the ant's algorithm literally we define two operators:

 

(>>>) = flip (.)

 

-- functional choice

 

Finally define the datatype representing the state of ant and ant's universe

, antDirection :: Point

, getCells :: Set Point }

 

 

Now we are ready to express the main part of the algorithm

step = isBlack ?>> (setWhite >>> turnRight,

setBlack >>> turnLeft) >>> move

turnRight (State p (x,y) m) = State p (y,-x) m

turnLeft (State p (x,y) m) = State p (-y,x) m

 

That's it.

 

Here is the solution of the task:

task = iterate step

>>> dropWhile ((< 50) . distance . antPosition)

>>> getCells . head

 

For given initial configuration it returns the set of black cells at the end of iterations.

 

We can display it graphically using Gloss library

 

main = display w white (draw (task initial))

initial = State (0,0) (1,0) mempty

draw = foldMap drawCell

 

Or animate the ant's trajectory

where

w = InWindow "Langton's Ant" (400,400) (0,0)

initial = State (0,0) (1,0) mempty

draw (State p _ s) = pictures [foldMap drawCell s, color red $ drawCell p]

 

=={{header|Icon}} and {{header|Unicon}}==

[[file:LangtonsAnt_unicon_100x100_11655.gif|right|thumb]]

 

procedure main(A)

WAttrib(label)

WDone()

 

{{libheader|Icon Programming Library}}

=={{header|J}}==

 

langton=:3 :0

loc=. <.-:$cells=. (_2{.y,y)$dir=. 0

end.

' #' {~ cells

 

<pre style="font-size: 2px"> langton 100 100

=={{header|Java}}==

This implementation allows for sizes other than 100x100, marks the starting position with a green box (sometimes hard to see at smaller zoom levels and the box is smaller than the "pixels" so it doesn't cover up the color of the "pixel" it's in), and includes a "zoom factor" (<code>ZOOM</code>) in case the individual "pixels" are hard to see on your monitor.

import java.awt.Graphics;

 

return plane;

}

Output (click for a larger view):

 

Utilises the HTML5 canvas element to procedurally generate the image... I wanted to see the progress of the grid state as it was generated, so this implementation produces a incrementally changing image until an 'ant' hits a cell outside of the coordinate system. It can also accept multiple ants, this adds minimal complexity with only the addition of an 'ants' array which is iterated in each step, no additional conditions are necessary to simulate multiple ants, they coexist quite well... good ants ! 1st argument is an array of ant objects, 2nd argument is an object property list of options to change grid size, pixel size and interval (animation speed).

 

// create global canvas

var canvas = document.createElement('canvas');

simulate();

}

 

Usage: default ants, custom opts

 

langtonant({}, {

gridsize: 100,

interval: 4

});

 

{{out}}

Usage: custom ants, default opts

 

langtonant([

{

}

]);

 

{{out}}

Requires lodash. Wants a canvas with id = "c"

 

///////////////////

// LODASH IMPORT //

 

updateWorld(world, ant, RUNS);

 

=={{header|jq}}==

In the following, the grid is boolean, and white is represented by true.

def matrix(m; n; init):

if m == 0 then [range(0;n)] | map(init)

| ($grid|length) as $height

| ($grid[0]|length) as $width

. + reduce range(0;$width) as $j ("\n";

. + if $grid[$i][$j] then " " else "#" end ) );

;

{{Out}}

The output is the same as for [[#Rexx|Rexx]] below.

=={{header|Julia}}==

{{works with|Julia|1.0}}

function ant(width, height)

y, x = fld(height, 2), fld(width, 2)

 

ant(100, 100)

 

=={{header|Kotlin}}==

{{trans|D}}

 

enum class Direction { UP, RIGHT, DOWN, LEFT }

println()

}

 

{{out}}

Same as D entry (textual version)

</pre>

 

=={{header|Liberty BASIC}}==

Native graphics.

[[Image:langtonsant.png]]

black=0

white=not(black)

end

end sub

 

Text version.

'move up=1 right=2 down=3 left=4

' ---------------------------------

next x

 

=={{header|Locomotive Basic}}==

 

20 ink 1,0:ink 0,26

30 x=50:y=50:ang=270

120 y=y+cos(ang)

130 if x<1 or x>100 or y<1 or y>100 then end

 

Output:

 

=={{header|Logo}}==

make "white 1

make "black 2

]

]

 

{{Output}}

=={{header|LOLCODE}}==

 

 

I HAS A plane ITZ A BUKKIT

IM OUTTA YR printer BTW, UR OUTTA CYAN

 

 

=={{header|Lua}}==

For this example, the lua Socket and Curses modules and a terminal with enough lines are needed.

local curses = require 'curses' -- used for graphics

 

socket.sleep(naptime)

until false

 

=={{header|M2000 Interpreter}}==

Module Ant {

Form 120,102

}

Ant

 

{{out}}

</pre >

 

[[File:LangtonsAnt.png|right|thumb|Output]]

 

data = SparseArray[{{50, 50} -> -1}, {100, 100}, 1];

NestWhile[

{Re@#, Im@#} &@(direction *= (data[[Sequence @@ #]] *= -1) I) + # &,

{50, 50}, 1 <= Min@# <= Max@# <= 100 &];

 

=={{header|MATLAB}} / {{header|Octave}}==

if nargin<1, n=100; end;

A = sparse(n,n); % white

if (~mod(k,100)),spy(A);pause(.1);end; %display after every 100 interations

end;

 

=={{header|Nim}}==

{{trans|Python}}

 

type

 

var i = 0

let turn = m[y][x] == black

m[y][x] = if m[y][x] == black: white else: black

for row in m:

echo map(row, proc(x: Color): string =

 

=={{header|OCaml}}==

 

 

type dir = North | East | South | West

if not(key_pressed()) then loop (move pos dir) dir

in

 

Run with:

 

=={{header|Octave}}==

E=100 % Size of lattice.

N=11200 % Number of iterations.

endfor;

imagesc(reshape(z,E,E)) % Draw the Lattice

 

=={{header|Ol}}==

{{libheader|OpenGL}}

#!/usr/bin/ol

(import (otus random!))

 

)))

 

=={{header|PARI/GP}}==

[[File:Langton-pari.png|right|thumb]]

my(M=matrix(100,100),x=50,y=50,d=0);

while(x && y && x<=100 && y<=100,

plothraw(u,v)

};

 

=={{header|Pascal}}==

{{works with|Turbo Pascal}} Except, the green arrow on step 4 does not appear!

 

{$B- Early and safe resolution of If x <> 0 and 1/x...}

Program LangtonsAnt; Uses CRT;

 

END.

 

=={{header|Perl}}==

use strict;

# Perl 5 implementation of Langton's Ant

}

print "\n";

 

=={{header|Phix}}==

{{out}}

<pre style="font-size: 2px">

''to the halves of width and height.)''<br>

<br>

// INIT AND DEFINITION

define('dest_name', 'output.png'); // destination image

// SAVE IMAGE

imagepng($img, dest_name);

 

=={{header|PicoLisp}}==

[[File:Picolisp_ant.gif|right|thumb]]

This code pipes a PBM into ImageMagick's "display" to show the result:

(let (Field (make (do Height (link (need Width)))) Dir 0)

(until (or (le0 X) (le0 Y) (> X Width) (> Y Height))

(out '(display -) (ant 100 100 50 50))

(bye)

 

=={{header|PowerShell}}==

{{works with|PowerShell|2}}

To simplify the steps within the loop, -1 and 1 are used to represent the binary state of the spaces in the grid. As neither state is now a default value, to simplify setting the starting states, an array of arrays is used instead of a two dimensional array.

$Size = 100

 

# Convert to strings for output

ForEach ( $Row in $G ) { ( $Row | ForEach { ( ' ', '', '#')[$_+1] } ) -join '' }

{{out}}

Default PowerShell console colors reverse the colors from black on white to white on dark blue. Most blank lines not included below.

=={{header|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.

* we use the following conventions:

* directions 0: up, 1: left, 2: down: 3: right

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

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

 

==={{header|Processing Python mode}}===

we use the following conventions:

directions 0: up, 1: left, 2: down: 3: right

 

def setBool(x, y, white):

 

=={{header|Prolog}}==

{{works with|SWI Prolog|6.2.6 by Jan Wielemaker, University of Amsterdam}}

[[File:ant.jpg|thumb|right|Sample output]]

% Langtons ant.

:-dynamic

(direction(Row,Col,right), R is Row - 1, !, move(north, R, Col)).

 

 

=={{header|PureBasic}}==

[[File:PureBasic_Langtons_ant.png|thumb|Sample display of PureBasic solution]]

#Black = 0

#planeHeight = 100

Delay(10) ;control animation speed and avoid hogging CPU

Sample output:

<pre>Out of bounds after 11669 steps.</pre>

 

=={{header|Python}}==

"""Langton's ant implementation."""

from enum import Enum, IntEnum

if __name__ == "__main__":

ant(width=75, height=52, max_nb_steps=12000)

The output is similar to the basic D version.

 

=={{header|R}}==

langton.ant = function(n = 100) {

map = matrix(data = 0, nrow = n, ncol = n)

 

image(langton.ant(), xaxt = "n", yaxt = "n", bty = "n")

 

=={{header|Racket}}==

This Racket program attempts to avoid mutation.

 

 

;; contracts allow us to describe expected behaviour of funcitons

((#t) (place-image (circle 2 "solid" "black") (* x 4) (* y 4) scn)))))

(show-grid/png (langton (make-ant 'u 50 50) (hash)))

Output (text):

<pre style="height:60ex;overflow:scroll">

{{trans|Perl}}

In this version we use 4-bits-per-char graphics to shrink the output to a quarter the area of ASCII graphics.

constant @blocky = ' ▘▝▀▖▌▞▛▗▚▐▜▄▙▟█'.comb;

constant $size = 100;

+ 8 * @plane[$x+1][$y+1] ];

}

{{out}}

<pre>Out of bounds after 11669 moves at (-1, 26)

<br>the screen to display the maximum area of the ant's path (walk).

<br>Or in other words, this REXX program only shows the pertinent part of the ant's walk─field.

parse arg dir char seed . /*obtain optional arguments from the CL*/

if datatype(seed, 'W') then call random ,,seed /*Integer? Then use it as a RANDOM SEED*/

if char=='' | char=="," then char= '#' /*binary colors: 0≡white, 1≡black. */

parse value scrSize() with sd sw . /*obtain the terminal's depth and width*/

do #=1 until (maxX-minY>sw)|(maxY-minY>sd) /*is the path out─of─bounds for screen?*/

select /*ant walks the direction it's facing. */

when dir==1 then y= y + 1 /*is ant walking north? Then go up. */

when dir==4 then x= x - 1 /* " " " west? " " left. */

end /*select*/ /*the DIRection is always normalized.*/

end /*steps*/ /* [↑] ant walks hither and thither. */

/* [↓] show Langton's ant's trail. */

do y=maxY to minY by -1; _= /*display a single row of cells. */

do x=minX to maxX; _=_ || @.x.y /*build a cell row for the display. */

end /*x*/ /* [↓] strip trailing blanks from line*/

if _\=='' then say _ /*display line (strip trailing blanks).*/

Programing note: &nbsp; the 23^rd REXX line:

could've been coded as:

The terminal's screen size used was &nbsp; '''80'''<small>x</small>'''160'''.

 

 

=={{header|Ring}}==

load "guilib.ring"

load "stdlib.ring"

}

label1 { setpicture(p1) show() }

 

Output:

 

=={{header|Ruby}}==

class OutOfBoundsException < StandardError; end

moves = ant.run

puts "out of bounds after #{moves} moves: #{ant.position}"

 

{{out}}

....................................................................................................</pre>

'''Simple Version:'''

MOVE = [[1,0], [0,1], [-1,0], [0,-1]] # [0]:east, [1]:south, [2]:west, [3]:north

end

 

;Output is the same above.

 

=={{header|Run BASIC}}==

 

x = 50: y = 50: minY = 100

 

next y

render #g

 

Ouptut (Produces both character and graphic):[[File:Langtons_ant_run_basic.png‎|right|graphic]]

 

=={{header|Rust}}==

x: usize,

y: usize,

println!("{}", string);

}

 

=={{header|Scala}}==

import Langton._

val rows=matrix.size

println(l)

}

Output:

<pre style="height: 40ex; overflow: scroll">Out of bounds after 11669 moves

=={{header|Scilab}}==

{{works with|Scilab|5.4.1 or above}}

ant_pos=round([grid_size/2 grid_size/2]); //ant's initial position at center of grid

head_direction='W'; //ant's initial direction can be either

end

 

{{out}}

<pre style="font-size: 10px">

 

=={{header|Seed7}}==

 

const type: direction is new enum UP, RIGHT, DOWN, LEFT end enum;

writeln;

end for;

 

{{out}}

=={{header|Sidef}}==

{{trans|Raku}}

define size = 100

 

 

say "Out of bounds after #{moves} moves at (#{x}, #{y})"

 

=={{header|Swift}}==

{{trans|C#}}

 

let WIDTH = 100

}

println()

{{out}}

Blank lines omitted

{{libheader|Tk}}

[[File:LangtonAnt_Tcl.gif|thumb|Output of Tcl solution of Langton's ant task]]

 

proc step {workarea} {

 

# Produce output in file

 

=={{header|TI-83 BASIC}}==

The variable N counts the generation number.

:ClrDraw

:0→N

:N+1→N

:End

 

=={{header|VBA}}==

 

Option Explicit

 

Sub Ant()

'init variables

LigF = 80

ColF = 50

Next

'directory

'name txt file

sFile = "Langton_Ant.txt"

'start

For i = 1 To 15000

LigA = LigF

ColA = ColF

If LigA = 1 Or ColA = 1 Or ColA = 256 Or LigA = 200 Then GoTo Fin

If TablDatas(LigA, ColA) = " " Then

TablDatas(LigA, ColA) = "#"

Select Case True

Case Top: Top = False: Right = True: LigF = LigA: ColF = ColA + 1

Case Bottom: Bottom = False: Left = True: LigF = LigA: ColF = ColA - 1

Case Right: Right = False: Bottom = True: LigF = LigA + 1: ColF = ColA

End Select

End If

Next i

'result in txt file

Num = FreeFile

Open sDir & sFile For Output As #Num

For i = 1 To UBound(TablDatas, 1)

Str = vbNullString

Str = Str & TablDatas(i, j)

Next j

Next i

Close #Num

Exit Sub

End Sub

{{out}}

 

=={{header|Vim Script}}==

function! CurrChar()

return matchstr(getline('.'), '\%' . col('.') . 'c.')

endif

endwhile

 

=={{header|Whitespace}}==

 

 

Following is the pseudo-Assembly from which the above was generated.

 

push 10003 dup push 100 store

push 1 sub dup push -1 store

 

5: ; Print a newline and jump back to the counter check.

 

=={{header|XPL0}}==

[[File:AntXPL0.gif|right]]

int X, Y, Dir;

[SetVid($13); \set 320x200 graphic video mode

X:= ChIn(1); \wait for keystroke

SetVid(3); \restore normal text mode

 

=={{header|zkl}}==

{{trans|XPL0}}

Uses the PPM class from http://rosettacode.org/wiki/Bitmap/Bresenham%27s_line_algorithm#zkl

w:=h:=100; bitmap:=PPM(w,h,white);

x:=w/2; y:=h/2; dir:=0; // start in middle facing east

}while((0<=x<w) and (0<=y<h));

 

{{out}}

Same as XPL0 (and using their image).