Mandelbrot set: Difference between revisions

{{trans|Python}}

R (0.<50).reduce(0i, (z, _) -> z * z + @a)

V rows = (step(1, -0.05, 41).map(y -> (step(-2.0, 0.0315, 80).map(x -> (I abs(mandelbrot(x + 1i * @y)) < 2 {‘*’} E ‘ ’)))))

=={{header|ACL2}}==

(+ (expt (realpart z) 2)

(expt (imagpart z) 2)))

(defun draw-mandelbrot (width iters)

(let ((height (floor (* 1000 width) 3333)))

{{out}}

{{libheader|Lumen}}

mandelbrot.adb:

package body Mandelbrot is

function Create_Image (Width, Height : Natural) return Lumen.Image.Descriptor is

end Create_Image;

mandelbrot.ads:

package Mandelbrot is

function Create_Image (Width, Height : Natural) return Lumen.Image.Descriptor;

test_mandelbrot.adb:

with Lumen.Window;

with Lumen.Image;

when Program_End =>

null;

{{out}}

Plot part of the Mandelbrot set as a pseudo-gif image.

INT pix = 300, max iter = 256, REAL zoom = 0.33 / pix;

[-pix : pix, -pix : pix] INT plane;

OD;

close (plot)

=={{header|ALGOL W}}==

Generates an ASCII Mandelbrot Set. Translated from the sample program in the Compiler/AST Interpreter task.

% This is an integer ascii Mandelbrot generator, translated from the %

% Compiler/AST Interpreter Task's ASCII Mandelbrot Set example program %

end for_y0

end.

{{out}}

<pre>

Hopper-code & macros Version:

#!/usr/bin/hopper

{mandel,"mandel.dat"}save

{0}return

Hopper-Basic high level language version:

#!/usr/bin/hopper

{mandel,"mandel.dat"}save

{0}return

{{trans|Nim}}

z: to :complex [0 0]

do.times: 50 [

mandelbrot #[ yStart: 1.0 yStep: neg 0.05

xStart: neg 2.0 xStep: 0.0315

{{out}}

=={{header|AutoHotkey}}==

Width := Height := 400

;---------------------------------------------------------------------------

Return, (r&0xFF)<<16 | g<<8 | b

=={{header|AWK}}==

XSize=59; YSize=21;

MinIm=-1.0; MaxIm=1.0;MinRe=-2.0; MaxRe=1.0;

}

exit;

{{out}}

<pre>

This implements a 16bit fixed point arithmetic Mandelbrot set calculation.

{{works with|The Amsterdam Compiler Kit - B|V6.1pre1}}

auto cx,cy,x,y,x2,y2;

auto iter;

return(0);

{{out}}

<pre>

{{trans|QBasic}}

WINDOW 2,"Mandelbrot",,0,1

' endless loop, use Run -> Stop from the menu to stop program

WHILE (1)

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

This version takes into account the Apple II's funky 280&times;192 6-color display, which has an effective resolution of only 140&times;192 in color.

10 HGR2

20 XC = -0.5 : REM CENTER COORD X

330 NEXT YS

340 NEXT YI

By making the following modifications, the same code will render the Mandelbrot set in monochrome at full 280&times;192 resolution.

150 FOR XS = 0 TO 279

301 C = (C - INT(C/2)*2)*3

310 HCOLOR = C: HPLOT XS, YS

This can be run in BeebEm. Select BBC model as Master 128 with ARM Second Processor. Load disc armdisc3.adl and switch to ADFS. At the prompt load ARM Basic by running the AB command.

10MODE5:VDU5

20D%=100 : REM adjust for speed/precision

70PLOT69,X%,Y%

80NEXT

[[File:Mandelbrot_armbasic.png]]

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

graphsize 384,384

next x

imgsave "Mandelbrot_BASIC-256.png", "PNG"

{{out|Image generated by the script}}

[[File:Mandelbrot BASIC-256.jpg|220px]]

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

{{works with|BBC BASIC for Windows}}

maxiter% = 128

VDU 23,22,sizex%;sizey%;8,8,16,128

PLOT X%,Y% : PLOT X%,-Y%

NEXT

[[File:Mandelbrot_bbc.gif]]

==={{header|Commander X16 BASIC}}===

10 CLS

20 SCREEN $80

190 PSET X,YR,I

200 :NEXT:NEXT

==={{header|Commodore BASIC}}===

Runs in about 90 minutes.

110 COLOR 1,3,0,0:GRAPHIC 2:TH=20

120 FOR PY=0 TO 80

280 NEXT PY

290 GET K$:IF K$="" THEN 290

===={{header|C-64 with Super Expander 64}}====

Runs in about 4.5 hours.

110 COLOR 6,0,0,0,6:GRAPHIC 2,1

120 FOR PY=0 TO 100

280 NEXT PY

290 GET K$:IF K$="" THEN 290

===={{header|Commodore-16 / 116 / Plus/4}}====

{{works with|Commodore BASIC|3.5}}

Despite the faster clock on the TED systems compared to the C-64, this takes almost six hours to run.

110 COLOR 0,2:COLOR 1,1:GRAPHIC 1,1

120 FOR PY=0 TO 100

250 NEXT PY

260 GETKEY K$

===={{header|Commodore 128 (40-column display)}}====

64 and Plus/4 versions.

110 COLOR 0,12:GRAPHIC 1,1:COLOR 1,1:GRAPHIC0:FAST

120 FOR PY=0 TO 100

260 SLOW:GRAPHIC 1

270 GETKEY K$

===={{header|Commodore 128 (80-column display)}}====

This uses BASIC 8 to create a 640x200 render on the C-128's 80-column display. The doubled resolution comes with a commensurate increase in run time; this takes about 5h20m using FAST 2MHz mode.

110 @MODE,0:@COLOR,15,0,0:@SCREEN,0,0:@CLEAR,0:FAST

120 FOR PY=0 TO 100

250 NEXT PY

260 GETKEY K$

{{Out}}

===={{header|Commodore PET}}====

Here's a version using mostly ASCII and some PETSCII (could probably improve the tile set for PETSCII) inspired by the Perl solution. Designed for a PET with an 80-column display.

110 CH$=" .:-=+*#@"+CHR$(255)

120 FOR Y=1 TO -1 STEP -0.08

270 NEXT I

280 IF I>TH THEN I=TH

{{Out}} VICE screenshot [https://i.imgur.com/y4zYmyD.png here].

160 NEXT Y

170 END

{{out}}

<pre>>>>>>>=====<<<<<<<<<<<<<<<;;;;;;:::96032:;;;;<<<<===========

==={{header|FreeBASIC}}===

#define zero_x 320

#define zero_y 240

while inkey=""

wend

==={{header|GW-BASIC}}===

20 ZEROY = 100 : MAXIT = 32

30 SCREEN 1

180 PSET (X, 2*ZEROY-Y), 1+(I MOD 3)

190 NEXT Y

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

Any words of description go outside of lang tags.

WindowWidth =440

close #w

end

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

{{trans|QBasic}}

This program is meant for use in [https://benchmarko.github.io/CPCBasic/cpcbasic.html CPCBasic] specifically, where it draws a 16-color 640x400 image in less than a minute. (Real CPC hardware would take far longer than that and has lower resolution.)

2 FOR xp = 0 TO 639

3 FOR yp = 0 TO 399

15 PLOT xp, yp, c MOD 16

16 NEXT

==={{header|Microsoft Small Basic}}===

GraphicsWindow.Show()

size = 500

EndFor

EndFor

==={{header|Microsoft Super Extended Color BASIC (Tandy Color Computer 3)}}===

1 REM MANDELBROT SET - TANDY COCO 3

2 POKE 65497,1

170 NEXT Y

180 GOTO 180

==={{header|Nascom BASIC}}===

Only a fragment of the shape is drawn because of low resolution of block graphics. Like in the ZX81 version, you can adjust the constants in lines 40 and 70 to zoom in on a particular area, if you like.

{{works with|Nascom ROM BASIC|4.7}}

10 REM Mandelbrot set

20 CLS

510 DATA 27085,14336,-13564,6399,18178,10927

520 DATA -8179,233

==={{header|OS/8 BASIC}}===

Works under BASIC on a PDP-8 running OS/8. Various emulators exist including simh's PDP-8 emulator and the [http://www.bernhard-baehr.de/pdp8e/pdp8e.html PDP-8/E Simulator] for Classic Macintosh and OS X.

20 I1=-1.0\I2=1.0\R1=-2.0\R2=1.0

30 S1=(R2-R1)/X1\S2=(I2-I1)/Y1

150 PRINT

160 NEXT Y

{{out}}

<pre>>>>>>>=====<<<<<<<<<<<<<<<;;;;;;:::96032:;;;;<<<<===========

==={{header|PureBasic}}===

PureBasic forum: [http://www.purebasic.fr/german/viewtopic.php?f=4&t=22107 discussion]

#Window1 = 0

Event = WaitWindowEvent()

Until Event = #PB_Event_CloseWindow

[[File:Mandelbrot-PureBasic.png]]

This is almost exactly the same as the pseudocode from [[wp:Mandelbrot set#For_programmers|the Wikipedia entry's "For programmers" section]] (which it's closely based on, of course). The image generated is very blocky ("low-res") due to the selected video mode, but it's fairly accurate.

WINDOW (-2, 1.5)-(2, -1.5)

FOR x0 = -2 TO 2 STEP .01

PSET (x0, y0), c + 32

NEXT

==={{header|Quite BASIC}}===

1000 REM Mandelbrot Set Project

1010 REM Quite BASIC Math Project

3090 LET P[8] = "white"

3100 RETURN

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

'Based on LibertyBasic solution

'copy the code and go to runbasic.com

print "All done, good bye."

end

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

Glacially slow, but does eventually produce a tolerable low-resolution image (screenshot [http://edmundgriffiths.com/zxmandelbrot.jpg here]). You can adjust the constants in lines 30 and 40 to zoom in on a particular area, if you like.

20 FOR J=43 TO 0 STEP -1

30 LET X=(I-52)/31

130 IF ITER=200 THEN PLOT I, J

140 NEXT J

==={{Header|SmileBASIC}}===

Generates the points at random, gradually building up the image.

Y = RNDF()*4-2@N

N = N+16

IF N < #L&&S*S+T*T < 4 GOTO @N

GPSET X*50+99, Y*50+99, RGB(99 XOR N,N,N)

Alternative, based on the QBasic and other BASIC samples.

<br>

The 3DS screen is 400 x 240 pixels. SmileBASIC doesn't have +=, -=, etc. but there are INC and DEC statements.

VAR XP, YP, X, Y, X0, Y0, X2, Y2

VAR NEXT_X, IT, C

GPSET XP + 200, YP + 120, RGB((C * 3) MOD 200 + 50, FLOOR(C * 1.2) + 20, C)

NEXT

==={{header|TI-Basic Color}}===

{{works with|TI-84 Plus CSE, TI-83 Premium CE, TI-84 Plus CE}}

ClrDraw

~2->Xmin:1->Xmax:~1->Ymin:1->Ymax

End

End

==={{header|Visual BASIC for Applications on Excel}}===

{{works with|Excel 2013}}

Based on the BBC BASIC version. Create a spreadsheet with -2 to 2 in row 1 and -2 to 2 in the A column (in steps of your choosing). In the cell B2, call the function with =mandel(B$1,$A2) and copy the cell to all others in the range. Conditionally format the cells to make the colours pleasing (eg based on values, 3-color scale, min value 2 [colour red], midpoint number 10 [green] and highest value black. Then format the cells with the custom type "";"";"" to remove the numbers.

Function mandel(xi As Double, yi As Double)

mandel = i

End Function

[[File:vbamandel.png]]

Edit: I don't seem to be able to upload the screenshot, so I've shared it here: https://goo.gl/photos/LkezpuQziJPAtdnd9

==={{header|Yabasic}}===

wid = 4

xcenter = -1: ycenter = 0

next ycoord

next xcoord

=={{header|Befunge}}==

X scale is (-2.0, 0.5); Y scale is (-1, 1); Max iterations 94 with the ASCII character set as the "palette".

@^+1g00,+55_v# !`\+*9<>4v$

@v30p20"?~^"< ^+1g10,+*8<$

>*%03 p58*:*/01g"3"* v>::^

\_^#!:-1\+-*2*:*85<^

{{out}}

=={{header|Brace}}==

This is a simple Mandelbrot plotter. A longer version based on this smooths colors, and avoids calculating the time-consuming black pixels: http://sam.ai.ki/brace/examples/mandelbrot.d/1

use b

w = w*w + c

*px++ = i < max_i ? rainbow(i*359 / rb_i % 360) : black

An example plot from the longer version:

=={{header|Brainf***}}==

A mandelbrot set fractal viewer in brainf*ck written by Erik Bosman

+++++++++++++[->++>>>+++++>++>+<<<<<<]>>>>>++++++>--->>>>>>>>>>+++++++++++++++[[

+[-[->>>>>>>>>+<<<<<<<<<]>>>>>>>>>]>>>>>->>>>>>>>>>>>>>>>>>>>>>>>>>>-<<<<<<[<<<<

<<<<<]]>>>]

{{out}}

===PPM non interactive===

Here is one file program. It directly creates ppm file.

c program:

--------------------------------

fclose(fp);

return 0;

===PPM Interactive===

{{libheader|GLUT}}

#include <stdlib.h>

#include <math.h>

glutMainLoop();

return 0;

===ASCII===

Not mine, found it on Ken Perlin's homepage, this deserves a place here to illustrate how awesome C can be:

main(k){float i,j,r,x,y=-16;while(puts(""),y++<15)for(x

=0;x++<84;putchar(" .:-;!/>)|&IH%*#"[k&15]))for(i=k=r=0;

j=r*r-i*i-2+x/25,i=2*r*i+y/10,j*j+i*i<11&&k++<111;r=j);}

There may be warnings on compiling but disregard them, the output will be produced nevertheless. Such programs are called obfuscated and C excels when it comes to writing such cryptic programs. Google IOCCC for more.

<pre>

===Fixed point 16 bit arithmetic===

/**

ascii Mandelbrot using 16 bits of fixed point integer maths with a selectable fractional precision in bits.

<pre>

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

using System.Drawing;

using System.Drawing.Imaging;

return Re * Re + Im * Im;

}

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

This generic function assumes that the image can be accessed like a two-dimensional array of colors. It may be passed a true array (in which case the Mandelbrot set will simply be drawn into that array, which then might be saved as image file), or a class which maps the subscript operator to the pixel drawing routine of some graphics library. In the latter case, there must be functions get_first_dimension and get_second_dimension defined for that type, to be found by argument dependent lookup. The code provides those functions for built-in arrays.

#include <complex>

}

Note this code has not been executed.

<br>

A Simple version in CPP. Definitely not as crazy good as the ASCII one in C above.

int f(float X, float Y, float x, float y, int n){

for(float i=-2, x; i<=.5; i+=.015, x=f(i, j, 0, 0, 0))

printf("%c%s", x<10?' ':x<20?'.':x<50?':':x<80?'*':'#', i>-2?" ":"\n");

=={{header|C3}}==

This program produces a BMP as output.

extern fn int atoi(char *s);

}

}

=={{header|Cixl}}==

Displays a zooming Mandelbrot using ANSI graphics.

use: cx;

#out show-cursor

normal-mode

=={{header|Clojure}}==

{{trans|Perl}}

(:refer-clojure :exclude [+ * <])

(:use (clojure.contrib complex-numbers)

(println (interpose \newline (map #(apply str %) (partition 80 (mandelbrot)))))

=={{header|COBOL}}==

EBCDIC art.

PROGRAM-ID. MANDELBROT-SET-PROGRAM.

DATA DIVISION.

ADD X-A-SQUARED TO Y-A-SQUARED GIVING SUM-OF-SQUARES.

MOVE FUNCTION SQRT (SUM-OF-SQUARES) TO ROOT.

{{out}}

<pre>

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

(:use #:cl))

for pixel = (round (* 255 (/ (- *iteration-max* iteration) *iteration-max*)))

do (setf (aref image y x) pixel)))

=={{header|Cowgol}}==

{{trans|B}}

const xmin := -8601;

print_nl();

cy := cy + dy;

{{out}}

<pre>!!!!!!!!!!!!!!!"""""""""""""####################################""""""""""""""""

===Textual Version===

This uses <code>std.complex</code> because D built-in complex numbers are deprecated.

import std.stdio, std.complex;

writeln;

}

{{out}}

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

===More Functional Textual Version===

The output is similar.

import std.stdio, std.complex, std.range, std.algorithm;

.recurrence!((a, n) => a[n - 1] ^^ 2 + complex(x, y))

.drop(100).front.abs < 2 ? '#' : '.').writeln;

===Graphical Version===

{{libheader|QD}} {{libheader|SDL}} {{libheader|Phobos}}

double lensqr(cdouble c) { return c.re * c.re + c.im * c.im; }

}

while (true) { flip; events; }

=={{header|Dart}}==

print(line);

}

=={{header|Dc}}==

This can be done in a more Dc-ish way, e.g. by moving the loop macros' definitions to the initialisations in the top instead of saving the macro definition of inner loops over and over again in outer loops.

0.7 sX # xmax = 0.7

l2 x # loop

] s2

{{out}}

<pre>

===PGM (P5) output===

This is a condensed version of the ASCII output variant modified to generate a PGM (P5) image.

32 sM

640 sW 480 sH

l2 x

] s2

=={{header|DWScript}}==

{{trans|D}}

var x, y, i : Integer;

end;

PrintLn('');

=={{header|EasyLang}}==

rect 0.4 0.4

.

=={{header|eC}}==

Drawing code:

{

int x, y;

}

}

Interactive class with Rubberband Zoom:

{

caption = $"Mandelbrot";

}

=={{header|EchoLisp}}==

(lib 'math) ;; fractal function

(lib 'plot)

;; result here [http://www.echolalie.org/echolisp/help.html#fractal]

=={{header|Elixir}}==

def set do

xsize = 59

end

{{out}}

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

===Text mode===

(setq mandel-size (cons 76 34))

(insert(format "%s" (mandel-iter (mandel-pos x y))))))))

{{output}}

<pre>----------------------------------------------------------------------------

===Graphical version===

With a few modifications (mandel-size, mandel-iter, string-to-image, mandel-pic), the code above can also render the Mandelbrot fractal to an XPM image and display it directly in the buffer. (You might have to scroll up in Emacs after the function has run to see its output.)

(setq mandel-size (cons 320 300))

(insert-image (string-to-image all)))

=={{header|Erlang}}==

[https://github.com/ghulette/mandelbrot-erlang Geoff Hulette's GitHub repository] provides two alternative implementations which are very interesting.

-module(mandelbrot).

% **************************************************

Output:

=={{header|ERRE}}==

PROGRAM MANDELBROT

END FOR

END PROGRAM

Note: This is a PC version which uses EGA 16-color 320x200. Graphic commands are taken from

PC.LIB library.

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

open System.Windows.Forms

type Complex =

let f = new Mandel()

=== Alternate version, applicable to text and GUI ===

''' Basic generation code '''

let getMandelbrotValues width height maxIter ((xMin,xMax),(yMin,yMax)) =

let mandIter (cr:float,ci:float) =

fun y x -> mandIter ((xMin + dx * float(x)), (yMin + dy * float(y)))

[0..height-1] |> List.map(fun y->[0..width-1] |> List.map (forPos y))

''' Text display '''

getMandelbrotValues 80 25 50 ((-2.0,1.0),(-1.0,1.0))

|> List.map(fun row-> row |> List.map (function | 0 ->" " |_->".") |> String.concat "")

|> List.iter (printfn "%s")

Results:

''' Graphics display '''

open System.Drawing

open System.Windows.Forms

showGraphic toColor 640 480 5000 ((-2.0,1.0),(-1.0,1.0))

=={{header|Factor}}==

! with ("::") or without (":") generalizations:

! : [a..b] ( steps a b -- a..b ) 2dup swap - 4 nrot 1 - / <range> ;

70 25 1000 mandel

{{out}}

=={{header|Fennel}}==

#!/usr/bin/env fennel

max (arg-def 3 1e5)]

(mandel width height max))

=={{header|FOCAL}}==

1.2 S MIT=30

1.3 F Y=1,24; D 2

5.1 S T=MIT; T "*"; R

{{output}}

<pre>

=={{header|Forth}}==

This uses [[grayscale image]] utilities.

: mandel ( gmp F: imin imax rmin rmax -- )

80 24 graymap

{{works with|4tH v3.64}}

This is a completely integer version without local variables, which uses 4tH's native graphics library.

640 pic_width ! \ width of the image

s" mandelbt.ppm" save_image \ done, save the image

dup gshow

=={{header|Fortran}}==

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

implicit none

close (10)

=={{header|Frink}}==

This draws a graphical Mandelbrot set using Frink's built-in graphics and complex arithmetic.

// Maximum levels for each pixel.

levels = 60

g.show[]

=={{header|Furor}}==

###sysinclude X.uh

$ff0000 sto szin

{ „XRES” }

{ „myscreen” }

Computes escapes for each pixel, but not the colour.

default(f32)

fun main(screenX: int, screenY: int, depth: int, xmin: f32, ymin: f32, xmax: f32, ymax: f32): [screenX][screenY]int =

mandelbrot(screenX, screenY, depth, (xmin, ymin, xmax, ymax))

=={{header|FutureBasic}}==

_xmin = -8601

_xmax = 2867

HandleEvents

{{output}}

<pre>

=={{header|GLSL}}==

Uses smooth coloring.

const int MaxIterations = 1000;

const vec2 Focus = vec2(-0.51, 0.54);

}

=={{header|gnuplot}}==

The output from gnuplot is controlled by setting the appropriate values for the options <code>terminal</code> and <code>output</code>.

The following script draws an image of the number of iterations it takes to escape the circle with radius <code>rmax</code> with a maximum of <code>nmax</code>.

nmax = 100

complex (x, y) = x * {1, 0} + y * {0, 1}

set pm3d map

set size square

{{out}}

[[File:mandelbrot.png]]

;Text

Prints an 80-char by 41-line depiction.

import "fmt"

fmt.Println("")

}

;Graphical

[[File:GoMandelbrot.png|thumb|right|.png image]]

import (

fmt.Println(err)

}

=={{header|Golfscript}}==

Código sacado de https://codegolf.stackexchange.com/

20/3$-@@*10/3$-..*2$.*+1600<}*}32*'

{{out}}

<pre>000000000000000000000000000000000000000010000000000000000000

=={{header|Hare}}==

{{trans|D}}

use math;

fn abs(z: complex) f64 = {

return math::sqrtf64(z.re*z.re + z.im*z.im);

{{out}}

<pre>

=={{header|Haskell}}==

{{trans|Ruby}}

import Data.Complex (Complex ((:+)), magnitude)

]

| y <- [1, 0.95 .. -1]

{{Out}}

<pre>

'''haskell one-liners :'''

-- first attempt

-- open GHCI > Copy and paste any of above one-liners > Hit enter

A legible variant of the first of the "one-liner" contributions above:

main =

putStrLn $

)

[".", "\'", ":", "!", "|", "}", "#", " "]

{{Out}}

<pre> #

and a legible variant of the last of the "one-liner" contributions above:

main =

mapM_

else ' '

]

=={{header|Haxe}}==

This version compiles for flash version 9 or greater.

The compilation command is

{

inline static var MAX_ITER = 255;

image.setPixel(x, y, color);

}

=={{header|Huginn}}==

exec huginn -E "${0}" "${@}"

#! huginn

columns -= 1;

return ( ( lines, columns ) );

{{out}}

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

procedure main()

procedure cAbs(x)

return sqrt(x.r*x.r+x.i*x.i)

{{libheader|Icon Programming Library}}

(free implementation: GDL - GNU Data Language

http://gnudatalanguage.sourceforge.net)

PRO Mandelbrot,xRange,yRange,xPixels,yPixels,iterations

END

from the command line:

GDL>.run mandelbrot

or

GDL> Mandelbrot,[-1.,2.3],[-1.3,1.3],640,512,200

=={{header|Inform 7}}==

{{libheader|Glimmr Drawing Commands by Erik Temple}}

{{works with|Glulx virtual machine}}