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}}

 

The story headline is "A Non-Interactive Set".

[ fneg n; @bitxor n $80000000 n; return n; ];

#endif;

 

Newer Glulx interpreters provide 32-bit floating-point operations, but this solution also supports fixed-point math which is more widely supported and accurate enough for a zoomed-out view. Inform 6 inclusions are used for the low-level math functions in either case. The rendering process is extremely slow, since the graphics system is not optimized for pixel-by-pixel drawing, so this solution includes an optimization for vertical symmetry (as in the default view) and also includes extra logic to draw the lines in a more immediately useful order.

=={{header|J}}==

The characteristic function of the Mandelbrot can be defined as follows:

The Mandelbrot set can be drawn as follows:

 

load 'viewmat'

 

A smaller version, based on a black&white implementation of viewmat (and paraphrased, from html markup to wiki markup), is shown [[Mandelbrot_set/J/Output|here]] (The output is HTML-heavy and was split out to make editing this page easier):

 

 

=={{header|Java}}==

{{libheader|Swing}} {{libheader|AWT}}

import java.awt.image.BufferedImage;

import javax.swing.JFrame;

new Mandelbrot().setVisible(true);

}

=== Interactive ===

{{libheader|AWT}} {{libheader|Swing}}

import static java.awt.Color.black;

import static java.awt.event.KeyEvent.VK_BACK_SLASH;

;

}

 

=={{header|JavaScript}}==

The code can be run directly from the Javascript console in modern browsers by copying and pasting it.

 

var x = 0.0;

var y = 0.0;

document.body.insertBefore(canvas, document.body.childNodes[0]);

 

 

{{out}} with default parameters:

one for instance with the [https://mbebenita.github.io/WasmExplorer/ WebAssembly explorer]

 

fetch("./mandelIter.wasm")

.then(res => {

mandelbrot(canvas, -2, 1, -1, 1, 1000);

// ...

 

=={{header|jq}}==

 

'''Preliminaries'''

def svg(id; width; height):

"<svg width='\(width // "100%")' height='\(height // "100%") '

def u: if condition then . else (next|u) end;

u;

def Mandeliter( cx; cy; maxiter ):

# [i, x, y, x^2+y^2]

svg("mandelbrot"; "100%"; "100%"),

pixies,

'''Example''':

 

'''Execution:'''

 

Generates an ASCII representation:

z = 0

for i=1:50

end

println()

 

This generates a PNG image file:

 

@inline function hsv2rgb(h, s, v)

 

img = mandelbrot()

 

===Mandelbrot Set with Julia Animation===

This is an extension of the corresponding R section: e^(-|z|)-smoothing was added.

gr(aspect_ratio=:equal, legend=false, axis=false, ticks=false, dpi=100)

 

 

gif(animation, "Mandelbrot_animation.gif", fps=2)

 

===Normalized Counting, Distance Estimation, Mercator Maps and Perturbation Theory ===

This is an extension of the corresponding Python section to include higher precision calculations for larger zoom depths. The ''e^(-|z|)-smoothing'', ''normalized iteration count'' and ''exterior distance estimation'' algorithms are used.

gr(aspect_ratio=:equal, axis=true, ticks=true, legend=false, dpi=200)

 

 

heatmap(D .^ 0.1, c=:jet)

 

A small change in the code above creates Mercator maps and zoom images of the Mandelbrot set. The abs2 function is used to speed up the calculations inside the loop. See also the album [https://www.flickr.com/photos/arenamontanus/albums/72157615740829949 Mercator Mandelbrot Maps] by Anders Sandberg.

gr(aspect_ratio=:equal, axis=true, ticks=true, legend=false, dpi=200)

 

p4 = scatter(X[4*z+1:4*z+c,:], Y[4*z+1:4*z+c,:], markersize=R[1:c,:], marker_z=D[4*z+1:4*z+c,:].^0.2, c=:nipy_spectral)

plot(p1, p2, p3, p4, layout=(2, 2))

 

For deep zoom images it is sufficient to calculate a single point with high accuracy. A good approximation can then be found for all other points by means of a perturbation calculation with standard accuracy. Placing the iteration in a separate function speeds up the calculation. See [https://en.wikipedia.org/wiki/Plotting_algorithms_for_the_Mandelbrot_set#Perturbation_theory_and_series_approximation Perturbation theory] (Wikipedia) and [https://gbillotey.github.io/Fractalshades-doc/math.html Mathematical background] (Fractalshades) for more details.

gr(aspect_ratio=:equal, axis=true, ticks=true, legend=false, dpi=200)

 

 

heatmap(D .^ 0.25, c=:nipy_spectral)

 

Of course, deep Mercator maps can also be created. See also the image [https://www.flickr.com/photos/arenamontanus/3430921497/in/album-72157615740829949/ Deeper Mercator Mandelbrot] by Anders Sandberg. To reduce glitches, an additional reference sequence for the derivation (dS) is recorded with high precision.

gr(aspect_ratio=:equal, axis=true, ticks=true, legend=false, dpi=200)

 

 

heatmap(D' .^ 0.025, c=:nipy_spectral)

 

Due to abs(z - epsilon) < 2 and the second reference sequence, Z and dZ can be calculated after the loop. This massively reduces the computing time.

D, I = zeros(size(C)), ones(Int64, size(C))

 

 

N = abs.(Z) .> 2 # exterior distance estimation

 

Another approach to reducing glitches is rebasing. See [https://gbillotey.github.io/Fractalshades-doc/math.html#avoiding-loss-of-precision Avoiding loss of precision] (Fractalshades) and [https://fractalforums.org/fractal-mathematics-and-new-theories/28/another-solution-to-perturbation-glitches/4360 Another solution to perturbation glitches] (Fractalforums) for details.

D, I, J = zeros(size(C)), ones(Int64, size(C)), ones(Int64, size(C))

 

 

N = abs.(Z) .> 2 # exterior distance estimation

 

The rebasing condition abs(z) < abs(epsilon) does not define a circular area but a half-plane. If you insert a factor, the condition abs(z) < gamma * abs(epsilon) for 0 < gamma < 1 defines a circular area containing the origin. For example, if the reference point is at S(1, 0), the equation abs(z) = abs(epsilon) defines the set of all points that are equidistant from O(0, 0) and S(1, 0). This is exactly the perpendicular bisector x = 1/2. Considering instead the equation abs(z) = 1/2 * abs(epsilon), one finds all points half as far from O(0, 0) as from S(1, 0). All these points lie on a circle, which has center M(-1/3, 0) and radius R = 2/3. If you choose a factor gamma > 1, you get corresponding circles containing the reference point S. However, the condition abs(z) < abs(epsilon) is optimal because it keeps the differences epsilon to the reference sequence as small as possible. Rebasing occurs if and only if the distance abs(epsilon) to the reference sequence becomes smaller as a result. You can only rebase to the beginning of the reference sequence. If you want to rebase to the reference point S[m], the difference epsilon = z - S[m] must be calculated. With this subtraction, however, the entire precision is lost due to cancellation. Only at the first reference point there is no cancellation due to S[1] = 0, because epsilon = z - S[1] = z - 0 = z. The images can be verified by a (slow) calculation with BigFloats.

gr(aspect_ratio=:equal, axis=true, ticks=true, legend=false, dpi=200)

 

 

heatmap(D' .^ 0.025, c=:nipy_spectral)

 

=={{header|Kotlin}}==

{{trans|Java}}

 

import java.awt.Graphics

fun main(args: Array<String>) {

Mandelbrot().isVisible = true

 

=={{header|LabVIEW}}==

 

=={{header|Lang5}}==

: d2c(*,*) 2 compress 'c dress ; # Make a complex number.

 

 

iterate abs int 5 min 'print_line apply # Compute & print

 

=={{header|Lambdatalk}}==

Here we show a pure lambdatalk code, a slow but minimalistic and easy to understand version without the burden of any canvas. We just compute if a point is inside or outside the mandelbrot set and just write "o" or "." directly in the wiki page.

 

{def mandel

 

{S.serie 0 40}} // y resolution

 

 

<pre>

 

=={{header|Lasso}}==

define mandelbrotBailout => 16

define mandelbrotMaxIterations => 1000

 

mandelbrotTest

{{out}}

<small>

=={{header|LIL}}==

From the source distribution. Produces a PBM, not shown here.

# A mandelbrot generator that outputs a PBM file. This can be used to measure

# performance differences between LIL versions and measure performance

}}

}

 

=={{header|Logo}}==

{{works with|UCB Logo}}

cs setpensize [1 1]

make "inc :side/:size

end

 

 

=={{header|Lua}}==

===Graphical===

Needs L&Ouml;VE 2D Engine<br />Zoom in: drag the mouse; zoom out: right click

local maxIterations = 250

local minX, maxX, minY, maxY = -2.5, 2.5, -2.5, 2.5

love.graphics.draw( canvas )

end

===ASCII===

local charmap = { [0]=" ", ".", ":", "-", "=", "+", "*", "#", "%", "@" }

for y = -1.3, 1.3, 0.1 do

end

print()

{{out}}

<pre>...............::::::::::::::::::---------------::::::::::::::::::::::::::::::::

Console is a bitmap so we can plot on it. A subroutine plot different size of pixels so we get Mandelbrot image at final same size for 32X26 for a big pixel of 16x16 pixels to 512x416 for a 1:1 pixel. Iterations for each pixel set to 25. Module can get left top corner as twips, and the size factor from 1 to 16 (size of output is 512x416 pixels for any factor).

 

Module Mandelbrot(x=0&,y=0&,z=1&) {

If z<1 then z=1

}

 

 

Version 2 without Subroutine. Also there is a screen refresh every 2 seconds.

Module Mandelbrot(x=0&,y=0&,z=1&) {

If z<1 then z=1

Mandelbrot 250*twipsx,100*twipsy, array(i)

}

 

=={{header|Maple}}==

 

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

The implementation could be better. But this is a start...

 

DistributeDefinitions[eTime];

mesh = ParallelTable[eTime[x + I*y, 1000], {y, 1.2, -1.2, -0.01}, {x, -1.72, 1, 0.01}];

Faster version:

mandel = Block[{z = #, c = #},

Catch@Do[If[Abs[z] > 2, Throw@i]; z = z^2 + c, {i, 100}]] &

Compile[{},Table[mandel[y + x I], {x, -1, 1, 0.005}, {y, -2, 0.5, 0.005}]]

];

Built-in function:

 

==Mathmap ==

This solution uses the escape time algorithm to determine the coloring of the coordinates on the complex plane. The code can be reduced to a single line via vectorization after the Escape Time Algorithm function definition, but the code becomes unnecessarily obfuscated. Also, this code uses a lot of memory. You will need a computer with a lot of memory to compute the set with high resolution.

 

 

%Define the escape time algorithm

shading flat;

 

To use this function you must specify the:

 

Sample usage:

 

=={{header|Metapost}}==

outputtemplate:="%j-%c.svg";

outputformat:="svg";

endfig;

 

 

Sample usage:

 

=={{header|MiniScript}}==

MAX_ITER = 40

gfx.clear color.black

end if

end for

 

(Will upload an output image as soon as image uploading is fixed.)

 

=={{header|Modula-3}}==

 

IMPORT Wr, Stdio, Fmt, Word;

END;

END;

 

=={{header|MySQL}}==

See http://arbitraryscrawl.blogspot.co.uk/2012/06/fractsql.html for an explanation.

 

-- Table to contain all the data points

CREATE TABLE points (

INTO OUTFILE '/tmp/image.ppm'

FROM points;

 

=={{header|Nim}}==

{{trans|Python}}

 

 

proc inMandelbrotSet(c: Complex, maxEscapeIterations = 50): bool =

result.add('\n')

 

 

{{out}}

{{trans|Julia}}

{{libheader|imageman}}

import imageman

 

img[x - 1, y - 1] = ColorRGBF64(color)

 

 

=={{header|OCaml}}==

 

 

let mandelbrot xMin xMax yMin yMax xPixels yPixels maxIter =

done;;

 

=={{header|Octave}}==

This code runs rather slowly and produces coloured Mandelbrot set by accident ([[Media:Mandel-Octave.jpg|output image]]).

 

global width = 200;

global height = 200;

endfor

 

 

A bit faster than the above implementation

 

function z = mandelbrot()

% to view the image call "image(mandelbrot())"

z = abs(z);

end

 

=={{header|Ol}}==

(define x-size 59)

(define y-size 21)

(print)))

(iota y-size))

 

Output:

 

=={{header|OpenEdge/Progress}}==

DEFINE VARIABLE X1 AS DECIMAL NO-UNDO INIT 50.

DEFINE VARIABLE Y1 AS DECIMAL NO-UNDO INIT 21.

MESSAGE print_str.

OUTPUT CLOSE.

 

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

Define function mandelbrot():

{

forstep(y=-1, 1, 0.05,

print1(((c)->my(z=c);for(i=1,20,z=z*z+c;if(abs(z)>2,return(" ")));"#")(x+y*I)));

print());

 

Output:<pre>gp > mandelbrot()

=={{header|Pascal}}==

{{trans|C}}

{$IFDEF FPC}

close(outfile);

 

=={{header|Perl}}==

translation / optimization of the ruby solution

 

sub mandelbrot {

{print mandelbrot($x + $y * i) ? ' ' : '#'}

print "\n"

 

=={{header|Phix}}==

;Ascii

This is included in the distribution (with some extra validation) as demo\mandle.exw

-- Mandlebrot set in ascii art demo.

--

puts(1,b[remainder(k,16)+1])

end for

;Graphical

This is included in the distribution as demo\arwendemo\mandel.exw

include ..\arwen\dib256.ew

 

 

WinMain(Main,SW_NORMAL)

 

=={{header|PHP}}==

[[File:Mandel-php.png|thumb|right|Sample output]]

 

$max_x=1;

$min_y=-1;

imagepng($im);

imagedestroy($im);

 

=={{header|Picat}}==

{{trans|Unicon}}

Picat has not support for fancy graphics so it's plain 0/1 ASCII. Also, there's no built-in support for complex numbers.

 

Width = 90,

c_add(X,Y) = complex(X[1]+Y[1],X[2]+Y[2]).

c_mul(X,Y) = complex(X[1]*Y[1]-X[2]*Y[2],X[1]*Y[2]+X[2]*Y[1]).

 

{{out}}

 

=={{header|PicoLisp}}==

 

(let Ppm (make (do 300 (link (need 400))))

(prinl 400 " " 300)

(prinl 255)

 

=={{header|PostScript}}==

%%BoundingBox: 0 0 300 200

%%EndComments

showpage

origstate restore

 

=={{header|PowerShell}}==

$x = $y = $i = $j = $r = -16

$colors = [Enum]::GetValues([System.ConsoleColor])

Write-Host

}

 

=={{header|Processing}}==

Click on an area to zoom in. Choose areas with multiple colors for interesting zooming.

double zmx1, zmx2, zmy1, zmy2, f, di, dj;

double fn1, fn2, fn3, re, gr, bl, xt, yt, i, j;

i = 0;

j = 0;

 

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

Click on an area to zoom in.

Choose areas with multiple colors for interesting zooming.

fn1, fn2, fn3 = random(20), random(20), random(20)

f = 10

zmy2 = zmy2 * (1. / f)

di, dj = di * f, dj * f

 

=={{header|Prolog}}==

SWI-Prolog has a graphic interface XPCE :

 

mandelbrot :-

compute_RGB(CX, CY, Tmp, ZY1, Iter1, IterF).

 

[[FILE:Mandelbrot.jpg]]

 

=={{header|Python}}==

Translation of the ruby solution

try:

from functools import reduce

 

print("\n".join("".join(row) for row in rows))

 

A more "Pythonic" version of the code:

import math

 

for y in [a * 0.05 for a in range(-20, 20)]])

)

 

Finally, we can also use Matplotlib to visualize the Mandelbrot set with Python:

{{libheader|matplotlib}}

{{libheader|NumPy}}

from numpy import NaN

 

ylabel("Im(c)")

savefig("mandelbrot_python.svg")

 

Another Numpy version using masks to avoid (explicit) nested loops.

Runs about 16x faster for the same resolution.

import numpy as np

 

cmap=plt.cm.prism,

extent=(X.min(), X.max(), Y.min(), Y.max()))

 

===Normalized Counting, Distance Estimation, Mercator Maps and Deep Zoom===

The Mandelbrot set is printed with smooth colors.

The ''e^(-|z|)-smoothing'', ''normalized iteration count'' and ''exterior distance estimation'' algorithms are used with NumPy and complex matrices (see Javier Barrallo & Damien M. Jones: [http://www.mi.sanu.ac.rs/vismath/javier/index.html ''Coloring Algorithms for Dynamical Systems in the Complex Plane''] and Mikael Hvidtfeldt Christensen: [http://blog.hvidtfeldts.net/index.php/2011/09/distance-estimated-3d-fractals-v-the-mandelbulb-different-de-approximations ''Distance Estimated 3D Fractals (V): The Mandelbulb & Different DE Approximations'']).

import matplotlib.pyplot as plt

 

 

plt.imshow(D ** 0.1, cmap=plt.cm.twilight_shifted)

 

A small change in the code above creates Mercator maps of the Mandelbrot set (see David Madore: [http://www.madore.org/~david/math/mandelbrot.html ''Mandelbrot set images and videos''] and Anders Sandberg: [https://www.flickr.com/photos/arenamontanus/sets/72157615740829949 ''Mercator Mandelbrot Maps'']).

With the same pixel density and the same maximum magnification, the difference in height between the maps is only about 10 percent.

By misusing a scatter plot, it is possible to create zoom images of the Mandelbrot set.

import matplotlib.pyplot as plt

 

ax[1, 0].scatter(X[3*z:3*z+c], Y[3*z:3*z+c], s=R[0:c]**2, c=D[3*z:3*z+c]**0.3, cmap=plt.cm.nipy_spectral)

ax[1, 1].scatter(X[4*z:4*z+c], Y[4*z:4*z+c], s=R[0:c]**2, c=D[4*z:4*z+c]**0.2, cmap=plt.cm.nipy_spectral)

 

For deep zoom images it is sufficient to calculate a single point with high accuracy. A good approximation can then be found for all other points by means of a perturbation calculation with standard accuracy. See [https://en.wikipedia.org/wiki/Plotting_algorithms_for_the_Mandelbrot_set#Perturbation_theory_and_series_approximation Perturbation theory] (Wikipedia) and [https://gbillotey.github.io/Fractalshades-doc/math.html Mathematical background] (Fractalshades) for more details. Placing the iteration in a separate function speeds up the calculation slightly.

import matplotlib.pyplot as plt

 

 

plt.imshow(D ** 0.25, cmap=plt.cm.nipy_spectral)

 

Of course, deep Mercator maps can also be created. See also the image [https://www.flickr.com/photos/arenamontanus/3430921497/in/album-72157615740829949/ Deeper Mercator Mandelbrot] by Anders Sandberg. To reduce glitches, an additional reference sequence for the derivation (dS) is recorded with high precision. Compare the corresponding program examples for the Julia language for more details.

import matplotlib.pyplot as plt

 

 

plt.imshow(D.T ** 0.025, cmap=plt.cm.nipy_spectral)

 

===Python - "One liner"===

print(

'\n'.join(

for y in range(-50,50)

))

 

=={{header|R}}==

#we iterate all active points in the same array operation,

#and keeping track of which points are still iterating.

function(z,c)z^2+c, function(z)abs(z) <= 2,

max=100)

 

===Mandelbrot Set with R Animation===

Modified Mandelbrot set animation by Jarek Tuszynski, PhD. (see: [https://en.wikipedia.org/wiki/R_(programming_language)#Mandelbrot_set Wikipedia: R (programming_language)] and [https://rtricks.blogspot.com/2007/04/mandelbrot-set-with-r-animation.html R Tricks: Mandelbrot Set with R Animation])

library(caTools) # external package providing write.gif function

jet.colors <- colorRampPalette(c("red", "blue", "#007FFF", "cyan", "#7FFF7F",

X[, , k] <- exp(-abs(Z)) # capture results

}

 

=={{header|Racket}}==

#lang racket

 

 

(mandelbrot 300 200)

 

=={{header|Raku}}==

Converted to a .png file for display here.

 

000000 0000fc 4000fc 7c00fc bc00fc fc00fc fc00bc fc007c fc0040 fc0000 fc4000

fc7c00 fcbc00 fcfc00 bcfc00 7cfc00 40fc00 00fc00 00fc40 00fc7c 00fcbc 00fcfc

put @color_map[|.reverse, |.[1..*]][^$width] given

my @ = map &mandelbrot.assuming(0i, *), $re «+« @im;

 

Alternately, a more modern, faster version.

 

 

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

} ).map: ((*+$m) * 255).Int]

}

See [https://github.com/thundergnat/rc/blob/master/img/Mandelbrot-set-perl6.png Mandelbrot-set-perl6.png] (offsite .png image)

 

{{trans|AWK}}

This REXX version doesn't depend on the ASCII sequence of glyphs; &nbsp; an internal character string was used that mimics a part of the ASCII glyph sequence.

@ = '>=<;:9876543210/.-,+*)(''&%$#"!' /*the characters used in the display. */

Xsize = 59; minRE = -2; maxRE = +1; stepX = (maxRE-minRE) / Xsize

end /*x*/

say $ /*display a line of character output.*/

'''output''' &nbsp; using the internal defaults:

<pre>

===version 2===

This REXX version uses glyphs that are "darker" (with a white background) around the output's peripheral.

@ = '█▓▒░@9876543210=.-,+*)(·&%$#"!' /*the characters used in the display. */

Xsize = 59; minRE = -2; maxRE = +1; stepX = (maxRE-minRE) / Xsize

end /*x*/

say $ /*display a line of character output.*/

'''output''' &nbsp; using the internal defaults:

<pre>

===version 3===

This REXX version produces a larger output &nbsp; (it uses the full width of the terminal screen (less one), &nbsp; and the height is one-half of the width.

@ = '█▓▒░@9876543210=.-,+*)(·&%$#"!' /*the characters used in the display. */

parse arg Xsize Ysize . /*obtain optional arguments from the CL*/

end /*x*/

say $ /*display a line of character output.*/

'''output''' &nbsp; using the internal defaults:

<pre>

 

=={{header|Ring}}==

load "guilib.ring"

 

}

label1 { setpicture(p1) show() }

 

Output:

=={{header|Ruby}}==

Text only, prints an 80-char by 41-line depiction. Found [http://www.xcombinator.com/2008/02/22/ruby-inject-and-the-mandelbrot-set/ here].

 

def mandelbrot(a)

end

puts

 

{{trans|Tcl}}

 

Uses [[Raster graphics operations/Ruby]]

 

require_relative 'raster_graphics'

end

 

 

{{libheader|RubyGems}}

{{libheader|JRubyArt}}

JRubyArt is a port of processing to ruby

# frozen_string_literal: true

 

size(900, 600)

end

 

=={{header|Rust}}==

Dependencies: image, num-complex

extern crate num_complex;

 

// Save image

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

 

=={{header|Sass/SCSS}}==

$canvasWidth: 200;

$canvasHeight: 200;

}

 

 

=={{header|Scala}}==

Uses RgbBitmap from [[Basic_bitmap_storage#Scala|Basic Bitmap Storage]] task and Complex number class from [[Arithmetic/Complex#Scala|this]]

programming task.

import java.awt.Color

 

else new Color(255, 255, (255*(c-2)).toInt)

}

Read–eval–print loop

import javax.swing.ImageIcon

val imgMandel=Mandelbrot.generate()

val mainframe=new MainFrame(){title="Test"; visible=true

contents=new Label(){icon=new ImageIcon(imgMandel.image)}

 

=={{header|Scheme}}==

This implementation writes an image of the Mandelbrot set to a plain pgm file. The set itself is drawn in white, while the exterior is drawn in black.

(define y-centre 0.0)

(define width 4.0)

(begin (display (pixel i j)) (newline))))))))

 

 

=={{header|Scratch}}==

 

=={{header|SenseTalk}}==

put 0 into oImag # Imaginary origin

put 0.5 into mag # Magnification

 

close file myFile

 

=={{header|SequenceL}}==

'''SequenceL Code for Computing and Coloring:'''<br>

import <Utilities/Sequence.sl>;

import <Utilities/Math.sl>;

linearInterpolate(v0(0), v1(0), t(0)) := (1 - t) * v0 + t * v1;

 

 

'''C++ Driver Code:'''<br>

{{libheader|CImg}}

#include "../../../ThirdParty/CImg/CImg.h"

 

 

return 0;

 

{{out}}

 

=={{header|Sidef}}==

var c = z

{ z = (z*z + c)

}

print "\n"

 

 

=={{header|Simula}}==

{{trans|Scheme}}

REAL XCENTRE, YCENTRE, WIDTH, RMAX, XOFFSET, YOFFSET, PIXELSIZE;

INTEGER N, IMAX, JMAX, COLOURMAX;

 

PLOT;

 

=={{header|Spin}}==

{{works with|HomeSpun}}

{{works with|OpenSpin}}

_clkmode = xtal1+pll16x

_clkfreq = 80_000_000

 

waitcnt(_clkfreq+cnt)

 

{{out}}

 

=={{header|SPL}}==

sfx = -2.5; sfy = -2*h/w; fs = 4/w

#.aaoff()

? n=maxn, <= 0,0,0

<= #.hsv2rgb(n/maxn*360,1,1):3

 

 

Using the Swift Numerics package, as well as the C library Quick 'N Dirty BMP imported in Swift.

 

import Numerics

import QDBMP

}

 

 

=={{header|Tcl}}==

{{libheader|Tk}}

This code makes extensive use of Tk's built-in photo image system, which provides a 32-bit RGBA plotting surface that can be then quickly drawn in any number of places in the application. It uses a computational color scheme that was easy to code...

 

proc mandelIters {cx cy} {

update

}

 

=={{header|TeX}}==

The <code>pst-fractal</code> package includes a Mandelbrot set drawn by emitting [[PostScript]] code (using [[PSTricks]]), so the actual work done in the printer or PostScript interpreter.

 

\psfractal[type=Mandel,xWidth=14cm,yWidth=12cm,maxIter=30,dIter=20] (-2.5,-1.5)(1,1.5)

 

The coordinates are a rectangle in the complex plane to draw, scaled up to <code>xWidth,yWidth</code>.

In PGF 3.0 the calculations are done in [[PostScript]] code emitted, so the output size is small but it only does 10 iterations so is very low resolution.

 

\usepackage{tikz}

\usetikzlibrary{shadings}

\shade[shading=Mandelbrot set] (0,0) rectangle (4,4);

\end{tikzpicture}

 

=={{header|LuaTeX}}==

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

Based on the [[Mandelbrot_set#BASIC|BASIC Version]]. Due to the TI-83's lack of power, it takes around 2 hours to complete at 16 iterations.

:Input "ITER. ",D

:For(A,Xmin,Xmax,ΔX)

:End

:End

 

=={{header|TXR}}==

Creates same <code>mandelbrot.pgm</code> file.

 

(defvar y-centre 0.0)

(defvar width 4.0)

(put-line "" *stdout*))))

 

 

=={{header|uBasic/4tH}}==

56 Print "8"; : Return

57 Print "9"; : Return

Output:

<pre>1111111111111111111111122222222222222222222222222222222222222222222222222222222222222222222222222211111

=={{header|UNIX Shell}}==

{{works with|Bourne Again SHell|4}}

((xmax=2867)) # int( 0.7*4096)

done

echo

 

{{out}}

=={{header|VBScript}}==

VBScript does'nt have access to Windows graphics. I made a class allowing to create a bmp in an array, save it to BMP format and call the default application to view it.

option explicit

 

Set X = Nothing

 

=={{header|Vedit macro language}}==

Vedit macro language does not support floating point calculations, so fixed point arithmetic is used, with Value 10000 representing 1.0.

The Mandelbrot image is drawn using ASCII characters 1-9 to show number of iterations. Iteration count 10 or more is represented with '@'.

To compensate the aspect ratio of the font, step sizes in x and y directions are different.

#2 = 15000 // right edge = 1.5

#3 = 15000 // top edge = 1.5

}

BOF

{{out}}

<small>

{{trans|Kotlin}}

{{libheader|DOME}}

import "dome" for Window

 

}

 

 

=={{header|XPL0}}==

int X, Y, \screen coordinates of current point

Cnt; \iteration counter

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

SetVid($03); \restore normal text display

{{out}}

[[File:MandelXPL0.png]]

{{omit from|M4}}

 

<?xml version="1.0" encoding="UTF-8"?>

<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

</xsl:stylesheet>

 

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

;

; Compute a Mandelbrot set on a simple Z80 computer.

ld d, a

ret

{{out}}

<pre>

{{trans|XPL0}}

[[File:Mandelbrot.zkl.jpg|300px|thumb|right]]

bitmap:=PPM(640,480);

foreach y,x in ([0..479],[0..639]){

}

bitmap.write(File("foo.ppm","wb"));