Chaos game: Difference between revisions

This program will run on a PC with CGA-compatible graphics. It will keep running until a key is pressed.

bits 16

vmode: equ 0Fh ; Get current video mode

xchg bx,bp ; Restore the registers

xchg cx,di

=={{header|Action!}}==

INT x,w=[220],h=[190]

BYTE y,i,CH=$02FC,COLOR1=$02C5,COLOR2=$02C6

OD

CH=$FF

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Chaos_game.png Screenshot from Atari 8-bit computer]

{{trans|BASIC256}}

<p>Considerar que Hopper no usa modos gráficos, y solo imprime el caracter ascii 219 achicando el tamaño de caracteres de la terminal, dado la ilusión de un modo gráfico "arcaico".</p>

/* Chaos game - JAMBO hopper */

Set video text

End

=={{header|BASIC}}==

This should require minimal adaptation to work with any of the older Microsoft-style BASICs. Users of other dialects will need to replace lines <tt>10</tt> and <tt>150</tt> with the appropriate statements to select a graphics output mode (if necessary) and to plot a pixel at <tt>x,y</tt> in colour <tt>v</tt>; they should also add <tt>LET</tt> throughout and <tt>170 END</tt> if their dialects require those things.

20 X = INT(RND(0) * 200)

30 Y = INT(RND(0) * 173)

140 Y = Y/2

150 PSET X,Y,V

==={{header|Applesoft BASIC}}===

Adapted from the code given above.

20 X = INT(RND(1) * 200)

30 Y = INT(RND(1) * 173)

150 HCOLOR=V+4

160 HPLOT X,Y

==={{header|BASIC256}}===

#Chaos game

ImgSave "chaos_game.jpg", "jpg"

End

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

Adapted from the generic BASIC version. In [https://benchmarko.github.io/CPCBasic/cpcbasic.html CPCBasic] this program completes in less than a second. But on a real CPC (or equivalent emulator), the same program takes over six minutes to run. So using CPCBasic is strongly advised. On CPCBasic, one can also use "mode 3" instead of mode 1 in line 10 and increase iterations to e.g. 2000000 in line 40, resulting in a higher-resolution image.

20 x = 640 * rnd

30 y = 400 * rnd

140 y = y/2

150 plot x,y,v

==={{header|Sinclair ZX81 BASIC}}===

Note that ZX81 BASIC does not have an explicit computed <code>GOTO</code>; we can, however, actually compute the value of an expression and then <code>GOTO</code> it as a line number.

20 LET Y=RND*40

30 FOR I=1 TO 5000

130 LET Y=Y/2

140 PLOT X,42-Y

{{out}}

Screenshot [http://www.edmundgriffiths.com/zx81chaosgame.jpg here]. As with most ZX81 graphics, you can obtain the very best results by making it quite small and looking at it from a long way away.

==={{header|ZX Spectrum Basic}}===

The final <code>INK</code> statement sets the foreground colour back to black.

20 LET y=RND*173

30 FOR i=1 TO 20000

160 PLOT x,y

170 NEXT i

=={{header|C}}==

Interactive code which asks the side length of the starting triangle and number of iterations as inputs, a larger number of iterations produces a more accurate approximation of the Sierpinski fractal. Requires the [http://www.cs.colorado.edu/~main/bgi/cs1300/ WinBGIm] library.

#include<graphics.h>

#include<stdlib.h>

return 0;

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

using System.Drawing;

}

}

=={{header|C++}}==

This program will generate the Sierpinski Triangle and save it to your hard drive.

#include <windows.h>

#include <ctime>

return 0;

}

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

{{libheader|opticl}}

(:use #:cl

#:opticl))

(setf (pixel image (first point) (second point))

(values 255 0 0)))

=={{header|Delphi}}==

{{libheader| Winapi.Windows}}

{{libheader| Vcl.ExtCtrls}}

{{libheader| System.Generics.Collections}}

unit main;

end;

end;

=={{header|EasyLang}}==

[https://easylang.online/apps/_chaos-game.html Run it]

x[] = [ 0 100 50 ]

y[] = [ 93 93 7 ]

x = (x + x[h]) / 2

y = (y + y[h]) / 2

=={{header|Emacs Lisp}}==

(defun make-array (size)

(chaos-show arr size)))

=={{header|F Sharp|F#}}==

open System.Windows.Forms

open System.Drawing

f.Paint.Add (fun args -> args.Graphics.DrawImage(bmp, Point(0, 0)))

f.Show()

=={{header|Fortran}}==

This FORTRAN code creates an output file which can be drawn with gnuplot.

PROGRAM CHAOS

IMPLICIT NONE

END FUNCTION ZAHL

END PROGRAM CHAOS

Gnuplot Code to draw file:

set terminal jpeg enhanced size 1600,960

set output 'chaos.jpg'

set style line 1 lc rgb '#0060ad' lt 1 lw 3 pt 7 ps 0.3

plot 'aus.csv' using 1:3 with points ls 1 notitle

=={{header|FreeBASIC}}==

{{trans|BASIC256}}

' Chaos game

Const ancho = 320, alto = 240

Sleep

End

=={{header|Fōrmulæ}}==

{{works with|gforth|0.7.3}}

<br>

\ Chaos Game

STEPS game OUT-FILE to-pbm

{{out}}

'''"Game" Object Create Event:'''

//triangle vertex coordinates

step_count = 0;

interval = 1; //Number of frames between each step. 1 = no delay

'''"Game" Object Step Event:'''

{ // if the desired number of iterations is hit

vertex = choose(1, 2, 3);

step_count++;

'''"Game" Object Draw Event:'''

{

draw_triangle(x1, y1, x2, y2, x3, y3, true);

draw_circle(px, py, 1, false);

draw_line(px, py, vx, vy);

'''"Game" Object Alarm 0:'''

'''"Point" Object Draw Event:'''

=={{header|Gnuplot}}==

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

## Chaos Game (Sierpinski triangle) 2/16/17 aev

reset

set output

unset print

{{Output}}

<pre>

=={{header|Go}}==

This writes a simple GIF animation of the method.

import (

}

return err

=={{header|Groovy}}==

{{libheader|JavaFX}}

import javafx.application.Application

import javafx.scene.Scene

launch(ChaosGame)

}

=={{header|Haskell}}==

import Control.Monad.Random (fromList)

gameOfChaos :: MonadRandom m => Int -> Transformations -> Point -> m [Point]

gameOfChaos n transformations x = iterateA (fromList transformations) x

Some transformations:

triangle = [ (mid (0, 0), 1)

, (mid (1, 0), 1)

dragon = [(f1, 1), (f2, 1)]

where f1 (x,y) = (0.5*x - 0.5*y, 0.5*x + 0.5*y)

Drawing the result:

import Graphics.Gloss

display window white $ foldMap point pts

where window = InWindow "Game of Chaos" (400,400) (0,0)

=={{header|J}}==

[[File:j_chaos_game.png|300px|thumb|right]]

Note 'plan, Working in complex plane'

Make an equilateral triangle.

'marker'plot NEW_POINTS

=={{header|Java}}==

[[File:chaos_game.png|300px|thumb|right]]

{{works with|Java|8}}

import java.awt.event.*;

import java.util.*;

});

}

=={{header|JavaScript}}==

Plots the fractal on an HTML <tt>canvas</tt> element.

<head>

</body>

=={{header|Julia}}==

Run in REPL.

function chaos()

finish()

preview()

=={{header|Kotlin}}==

{{trans|Java}}

import java.awt.*

}

}

{{output}}

=={{header|Logo}}==

make "width :sidelength

make "height (:sidelength/2 * sqrt 3)

]

hideturtle

=={{header|Lua}}==

Needs L&Ouml;VE 2d Engine

math.randomseed( os.time() )

colors, orig = { { 255, 0, 0 }, { 0, 255, 0 }, { 0, 0, 255 } }, {}

love.graphics.draw( canvas )

end

=={{header|Maple}}==

local points, i;

randomize();

plots:-display( seq([plots:-display([seq(point(points[i]), i = 1..j)])], j = 1..numelems(points) ), insequence=true);

end use;

=={{header|Mathematica}}/{{header|Wolfram Language}}==

a = {0, 0};

b = {1, 0};

If[t == 0, d = Mean[{a, d}],

If[t == 1, d = Mean[{b, d}], d = Mean[{c, d}]]]; AppendTo[S, d]]

=={{header|Nim}}==

{{libheader|rapid}}

The "rapid" library is no longer maintained and this program fails to compile with last available version.

import rapid/gfx

ctx.noTexture()

update step:

==={{header|Using SDL}}===

{{libheader|SDL2}}

import sdl2, random

destroy render

==={{header|Writing result into an image}}===

{{libheader|imageman}}

import random

p = ((p.x + T[idx].x) / 2, (p.y + T[idx].y) / 2)

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

{{Works with|PARI/GP|2.9.1 and above}}

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

\\ Chaos Game (Sierpinski triangle) 2/15/17 aev

pChaosGameS3(size,lim)={

\\ Test:

pChaosGameS3(600,30000); \\ SierpTri1.png

{{Output}}

<pre>

=={{header|Pascal}}==

program ChaosGame;

end.

=={{header|Perl}}==

my $width = 1000;

}

=={{header|Phix}}==

{{libheader|Phix/online}}

You can run this online [http://phix.x10.mx/p2js/chaos.htm here]. Press space to cycle through the five fractals.

<span style="color: #000080;font-style:italic;">--

-- demo\rosetta\Chaos_game.exw

<span style="color: #000000;">main</span><span style="color: #0000FF;">()</span>

=={{header|Plain English}}==

Start up.

Initialize our reference points.

If the number is 1, put the top spot into the reference spot.

If the number is 2, put the right spot into the reference spot.

{{out}}

[https://commons.wikimedia.org/wiki/File:Chaos-game.png]

=={{header|Processing}}==

background(#ffffff); // white

}

set(x, height-y, colour);

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

size(300, 260)

colour = color(0, 0, 255) # blue

=={{header|Python}}==

import argparse

import random

main(arg_parser.parse_args())

=={{header|R}}==

{{Works with|R|3.3.1 and above}}

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

# Chaos Game (Sierpinski triangle) 2/15/17 aev

# pChaosGameS3(size, lim, clr, fn, ttl)

}

pChaosGameS3(600, 30000, "red", "SierpTriR1", "Sierpinski triangle")

{{Output}}

<pre>

'''Alternative code:'''

pta = c(1,2)

ptb = c(4,2)

}

}

=={{header|Racket}}==

{{trans|Haskell}}

(require 2htdp/image)

(draw-triangle)

(draw-fern)

=={{header|Raku}}==

{{works with|Rakudo|2018.10}}

my ($w, $h) = (640, 640);

}

=={{header|REXX}}==

parse value scrsize() with sd sw . /*obtain the depth and width of screen.*/

sw= sw - 2 /*adjust the screen width down by two. */

/* [↑] strip trailing blanks (output).*/

say strip(_, 'T') /*display one row (line) of the image. */

This REXX program makes use of &nbsp; '''SCRSIZE''' &nbsp; REXX program (or

=={{header|Ring}}==

# Project : Chaos game

}

label1 {setpicture(p1) show()}

* [https://lh3.googleusercontent.com/-xqBO5MB8fpc/Wg05SvwaF9I/AAAAAAAABDA/UGI2goKdDoAR6nbbGZF0YcuwGG6tancvACLcBGAs/s1600/CalmoSoftChaos.jpg Chaos Game (image)]

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

y = int(rnd(0) * 173)

graphic #g, 200,200

#g set(x,y)

next

=={{header|Rust}}==

Dependencies: image, rand

extern crate image;

extern crate rand;

imgbuf.save("fractal.png").unwrap();

}

=={{header|Scala}}==

===Java Swing Interoperability===

import java.awt._

import java.awt.event.ActionEvent

)

=={{header|Scilab}}==

This script uses complex numbers to represent (x,y) coordinates: real part as x position, and imaginary part as y position.

n_sides = 3;

side_length = 1;

plot2d(real(points),imag(points),0)

plot2d(real(vertices),imag(vertices),-3);

{{out}}

It outputs a graphic window and prints on the console the time elapsed during iterations.

=={{header|Sidef}}==

var width = 600

}

Output image: [https://github.com/trizen/rc/blob/master/img/chaos-game-sidef.png Chaos game]

=={{header|Simula}}==

INTEGER U, COLUMNS, LINES;

COLUMNS := 40;

END;

END

{{in}}

<pre>

{{libheader|Wren-dynamic}}

{{libheader|Wren-seq}}

import "graphics" for Canvas, Color

import "math" for Point

}

=={{header|X86 Assembly}}==

Sixty bytes handles it.

2 0000 .model tiny

3 0000 .code

36 0130 0140 002B 0255 Tx dw 320, 320-277, 320+277 ;equilateral triangle

37 0136 0000 01DF 01DF Ty dw 0, 479, 479

=={{header|XPL0}}==

[SetVid($12); \640x480x4 graphics

Tx:= [320, 320-277, 320+277]; \equilateral triangle

until KeyHit;

SetVid($03); \restore normal text mode

=={{header|Yabasic}}==

open window width, height

window origin "lb"

color 255 * (vertex = 0), 255 * (vertex = 1), 255 * (vertex = 2)

dot x, y

=={{header|Z80 Assembly}}==

space key.

VR0: equ 0F3DFh ; Copy of VDP R0 in memory

VR1: equ 0F3E0h ; Copy of VDP R1 in memory

ld e,a ; -> C

exx

{{trans|Java}}

[[File:ChaosGame.zkl.jpg|240px|thumb|right]]

bitmap:=PPM(w,h,0xFF|FF|FF); // White background

colors:=T(0xFF|00|00,0x00|FF|00,0x00|00|FF); // red,green,blue

done.wait(); // don't exit until thread is done