Julia set: Difference between revisions

=={{header|Ada}}==

{{libheader|SDLAda}}

 

with SDL.Video.Windows.Makers;

Window.Finalize;

SDL.Finalise;

 

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

<br>

Uses the Algol 68G specific argc and argv procedures. Note argv( 1 ) is the path of the Algol 68G interpreter and argv( 2 ) is the source being executed.

REAL c real, c imaginary;

STRING real and imaginary := IF argc < 3 THEN "-0.8" ELSE argv( 3 ) FI

print( ( newline ) )

OD

{{out}}

<pre>

The generated file is binary, and the graph can be made with Matlab's "imshow" function.

 

#!/usr/bin/hopper

 

{julia,"julia.dat"}save

exit(0)

 

=={{header|AWK}}==

{{trans|COBOL}}

# syntax: GAWK -f JULIA_SET.AWK [real imaginary]

BEGIN {

exit(0)

}

{{out}}

<pre>

==={{header|QBasic}}===

{{works with|QBasic}}

zeroX = 160

zeroY = 100

NEXT y

NEXT x

 

==={{header|True BASIC}}===

{{trans|QBasic}}

 

LET escala = 1/81

NEXT y

NEXT x

 

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

zeroX = 320

zeroY = 240

next y

next x

 

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

20 ZEROY = 100 : MAXIT = 32

30 CR# = -.798 : CI# = .1618

160 PSET (X, Y), 1 + (I MOD 3)

170 NEXT Y

 

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

 

Adapted from the Mandelbrot Locomotive Basic program. 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|Sinclair ZX81 BASIC}}===

 

You can try changing lines 10 and 20 to run the program with different values of the complex constant <tt>C</tt>+<tt>D</tt><math>i</math>, or lines 50 and 60 to zoom in.

20 LET D=.156

30 FOR V=43 TO 0 STEP -1

140 PLOT H,V

150 NEXT H

 

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

{{trans|Sinclair ZX81 BASIC}}

Higher resolution is obtainable, if you have the time to wait for it.

20 LET cimag=0.156

30 FOR v=-16 TO 16

140 PLOT h+100,150-v

150 NEXT h

{{out}}

Screenshot [http://edmundgriffiths.com/spectrumjulia.jpg here].

</pre>

Prints out usage on incorrect invocation. Requires the [http://www.cs.colorado.edu/~main/bgi/cs1300/ WinBGIm] library.

#include<graphics.h>

#include<stdlib.h>

return 0;

}

 

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

{{trans|Python}}

// Note: You have to add the System.Drawing assembly

// (right-click "references," Add Reference, Assemblies, Framework,

}

}

 

C# also makes it relatively easy to do a multi-threaded version, which should run faster than the above:

 

public struct CalculatedPoint

{

bitmap.SetPixel(cp.x, cp.y, colors[cp.i]);

bitmap.Save("julia-set-multi.png");

 

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

[[File:JuliaSetCpp.png|200px|thumb|right]]

#include <windows.h>

#include <string>

julia j; j.draw( c ); return 0;

}

 

=={{header|COBOL}}==

Plots—in ASCII or EBCDIC art—a Julia set for the function <i>f</i>(<i>z</i>) = <i>z</i>² + <i>c</i>, based on a value of <i>c</i> input by the user (real part then imaginary part, pressing the carriage return key after each). The sample output is for the inputs <tt>-0.8</tt> and <tt>0.156</tt>.

PROGRAM-ID. JULIA-SET-PROGRAM.

DATA DIVISION.

MOVE SPACE TO WS-PLOT-CHARACTER.

MOVE Z-REAL TO X.

{{out}}

<pre>

=={{header|Crystal}}==

{{trans|Ruby}}

 

def julia(c_real, c_imag)

julia(-0.8, 0.156)

{{out}}

<pre>

{{libheader| Vcl.Graphics}}

{{Trans|C#}}

program Julia_set;

 

bitmap.Free;

end.

=={{header|EasyLang}}==

 

[https://easylang.online/apps/julia-set.html Run it]

 

cy = 0.27015

for y range 300

rect 0.4 0.4

.

 

=={{header|Elixir}}==

{{trans|AWK}}

def set(c_real, c_imag) do

IO.puts "#{c_real}, #{c_imag}"

c_real = if r=Enum.at(System.argv, 0), do: Float.parse(r) |> elem(0), else: -0.8

c_imag = if c=Enum.at(System.argv, 1), do: Float.parse(c) |> elem(0), else: 0.156

 

{{out}}

 

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

 

(setq julia-size (cons 300 200))

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

 

 

=={{header|F_Sharp|F#}}==

''' Basic generation code '''

let getJuliaValues width height centerX centerY zoom maxIter =

let initzx x = 1.5 * float(x - width/2) / (0.5 * zoom * float(width))

loop 0 (initzx x) (initzy y)

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

 

''' Text display '''

getJuliaValues 80 25 -0.7 0.27015 1.0 50

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

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

{{out}}

<pre>

 

''' Graphic Display '''

open System.Drawing

open System.Windows.Forms

 

showGraphic toColor 640 480 -0.7 0.27015 1.0 5000

 

=={{header|Fortran}}==

The procedure calls, on lines 12 and 13, control the display window on the complex plane.

 

PROGRAM JULIA

C ------------------------------------------------------------------

10 CONTINUE

RETURN

{{out}}

<pre>

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

[[File:Julia-set-gray.png|480px|thumb|right]]

module julia_mod

! ----------------------------------------------------------------------------

call juliaPGM( DEF_FSPC, NUM_ROWS, NUM_COLS, DEF_UL, DEF_LR, DEF_SEED )

 

 

=={{header|FreeBASIC}}==

#define pix 1./120

#define zero_x 320

while inkey=""

wend

 

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

=={{header|Go}}==

Using the Goroutines results in a performance improvement of about three times on my four-core machine.

 

import (

log.Fatal(err)

}

=={{header|Haskell}}==

{{trans|AWK}}

 

plotChar :: Int -> Float -> Float -> Float -> Float -> Char

mapM_ putStrLn $ [-100,-96..100] >>= \y ->

[[-280,-276..280] >>= \x -> [plotChar 50 cReal cImag (y/100) (x/200)]]

{{out}}

<pre style="font-size: 50%;">

</pre>

{{trans|F#}}

 

getJuliaValues :: Float -> Float -> Float -> Float -> Float -> Int -> [[Int]]

 

main :: IO ()

{{out}}

<pre style="font-size: 50%;">

=={{header|J}}==

[[File:example-j-julia.png|200px|thumb|right]]

pal2=: 255,~0,<.(254$1 0.8 0.6)*Hue 5r6*(i.%<:)254

g=: [: %: 0.3746j0.102863 0.132565j0.389103 _0.373935j_0.353777 1&p.

 

See also: [http://webbox.lafayette.edu/~reiterc/j/fvj4/index.html Fractals Visualization and J, 4th edition, Part 1] (by Clifford A. Reiter), Chapter 6

[[File:julia_set_java.png|200px|thumb|right]]

{{works with|Java|8}}

import java.awt.*;

import java.awt.image.BufferedImage;

});

}

To multi-thread, simply swap the for loop for a parallel IntStream.

import javax.swing.*;

import java.awt.*;

}

}

 

=={{header|JavaScript}}==

take a look [http://paulo-jorente.de/tests/juliaset/ here].

var maxIterations = 450, minX = -.5, maxX = .5,

minY = -.5, maxY = .5, wid, hei, ctx,

drawFractal();

}

 

=={{header|jq}}==

{{trans|awk}}

 

# $re : -0.8

# $im : 0.156

else .x = .z_real | .y = .z_imag

end )

 

With the above program in a file called julia.jq, the following invocation of jq 1.5 produces the same output as shown in the awk entry on this page:

The following code creates the fractal as a ppm file named julia.ppm. There is no need of an external library to create this image since the ppm format is straightforward to generate.

 

function iter(z,c)

n = 0

writedlm(out, [f(width,height,a,b,i,j) for j = 1:height, i = 1:width], '\n')

end

 

We can then produce a 600x300 ppm image of the Julia set associated to the parameter ''-0.786+0.147i'' as follows.

 

[[File:JuliaSet_julia.png|250px|thumb|right]]

 

@inline function hsv2rgb(h, s, v)

end

 

 

=={{header|Kotlin}}==

import java.awt.*

import java.awt.image.BufferedImage

isVisible = true

}

 

=={{header|Lua}}==

for y = -1.0, 1.0, 0.05 do

for x = -1.5, 1.5, 0.025 do

end

print()

{{out}}

<pre style="font-size: 50%;">

Mathematica provides built-in functions for Julia sets.

Generate the set of points for the -0.77 +0.22 I Julia set with step sizes of 0.01

Visualize the same Julia set

 

=={{header|Nim}}==

{{trans|C#}}

{{libheader|imageman}}

import imageman

 

 

# Save into a PNG file.

 

=={{header|Perl}}==

[[File:JuliaSet.perl.png|250px|thumb|right]]

 

my($w, $h, $zoom) = (800, 600, 1);

}

 

 

=={{header|Phix}}==

{{libheader|Phix/pGUI}}

Interactive gui (zoom/pan incomplete).

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

-- demo\rosetta\Julia_set.exw

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

 

=={{header|PHP}}==

[https://drive.google.com/file/d/1DYfWyRBW_prZPcTNgfe29kCmRZKzgGDw/view?usp=sharing Click here to see a sample image created using this script.]

set_time_limit(300);

header("Content-Type: image/png");

 

Julia::start();

 

=={{header|Processing}}==

float cX = -0.7;

float cY = 0.27015;

noLoop();

}

 

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

{{trans|Processing}}

 

 

cX = -0.7

colorMode(HSB)

c = color(i / maxIter * 255, 255, 255 if i > 1 else 0)

noLoop()

 

{{trans|zkl}}

 

 

if __name__ == "__main__":

pix[x][y] = (i << 21) + (i << 10) + i*8

 

===Vectorized===

 

[https://imgur.com/a/o3j9Zzn Example output.]

Solution from:

https://codereview.stackexchange.com/questions/210271/generating-julia-set

origin='lower')

plt.show()

 

=={{header|Racket}}==

[[File:JuliaSet_racket.png|250px|thumb|right]]

;; Based on Mandelbrot code (GPL) from:

;; https://github.com/hebr3/Mandelbrot-Set-Racket/blob/master/Mandelbrot.v6.rkt

 

(save-image M-Image "julias.png")

 

=={{header|Raku}}==

{{works with|Rakudo|2016.03}}

[[File:Julia-set-perl6.png|250px|thumb|right]]

 

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

when 5/6..1 { $c, 0, $x }

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

 

=={{header|REXX}}==

:::: which is a

{{trans|COBOL}}

parse arg real imag fine . /*obtain optional arguments from the CL*/

if real=='' | real=="," then real= -0.8 /*Not specified? Then use the default.*/

end /*h*/

if $\='' then say strip($, 'T') /*only display a plot line if non-blank*/

This REXX program makes use of &nbsp; '''scrsize''' &nbsp; REXX program (or BIF) which is used to determine the screen size of the terminal (console),

<br>and the plot size is adjusted according.

 

=={{header|Ring}}==

# Project : Julia Set

 

}

label1 { setpicture(p1) show() }

 

=={{header|Ruby}}==

{{trans|AWK}}

puts Complex(c_real, c_imag)

-1.0.step(1.0, 0.04) do |v|

end

 

 

{{out}}

{{libheader|JRubyArt}}

JRubyArt is a port of Processing to the ruby language, here we target same Julia Set as Processing for comparison, produces a colored output

# frozen_string_literal: true

 

no_loop

end

 

=={{header|Rust}}==

 

use image::{ImageBuffer, Pixel, Rgb};

let _ = img.save("output.png");

 

 

=={{header|Scala}}==

===Java Swing Interoperability===

import java.awt.image.BufferedImage

 

)

 

 

=={{header|Sidef}}==

[[File:JuliaSet_sidef.png|250px|thumb|right]]

 

var (w, h) = (640, 480)

}

 

 

This version generates an ASCII representation:

 

var maxIter = 40

}

print "\n"

{{out}}

<pre style="font-size: 50%;"> ##

=={{header|Wren}}==

{{libheader|DOME}}

import "dome" for Window

 

}

 

 

=={{header|zkl}}==

{{trans|Java}}

[[File:JuliaSet.zkl.jpg|250px|thumb|right]]

w,h,zoom:=800,600, 1;

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

 

bitmap.writeJPGFile("juliaSet.jpg",True);