Mandelbrotmengden

mandelbrot_gjenta.blogspot.com.py

Egil Brevik, egilbr@online.no, 18.02.2018

https://www.youtube.com/watch?v=56gzV0od6DU
(Sørg for å starte videoen ovenfor helt fra begynnelsen.)

#00

Mandelbrotplanet er mest interessant i området fra -2.0 til 2.0 i x- og y-retning.

Variabler for valg av nytt sentrum (p,q) i planet , f eks. (p,q) = (-0.75, 0.0)

Radius fra nytt sentrum : r. Radius = 1.5 kan passe.:

Koordinatene som er interessante for oss, ligger for nære origo for å vises direkte på

skjermen. Alle koordinater må derfor multipliseres med samme faktor, f eks. zoom = 100.

Programmet nedenfor bruker kanskje ett minutt på å tegne et bilde dersom hver pixel skal brukes.

Ved å bruke annenhver pixel, tetthet = 2, reduseres tiden betraktelig. Ulempen blir at bildet blir blast og fargeløst. Dette kan igjen rettes opp ved å øke punktstørrelsen fra punktstorrelse= 2 til 3 eller 4.

En nøkkelfunksjon i programmet er ei sløyfe som kan gjentas opptil en forhåndsvalgt verdi, f eks. Maxitr = 101.

#01

Først defineres de fire hjørnekoordinatene for den valgte mandelbrotmatrisen.

Så kommer noen utskrifter.

Deretter: En for-løkke for å behandle hver linje i pixelmatrisen.( fra -q_nord * zoom til -q_syd*zoom)

Før behandling av hver linje initieres en punkt-teller, i, til den østligste pixelen.

En verdi ,itr, som har med fargeleggingen av et valgt punkt å gjøre, initialiseres tilfeldig til null

Ved hjelp av: i = i + tetthet , vil whileløkka behandle hvert valgte pixel på linja.

Tilordningen: «itr = tell_antall(i/zoom,j/zoom, maxitr)»:

Sentral «funksjonsmaskin» i def tell_antall(a, b, maxitr):

Funksjonsmaskinen ovenfor har seks lagerplasser som heter a , b, x, y , x_ny og y_ny.
Maskinen er bygd for å kunne bruke kun to faste funksjonsforskrifter når den skal regne med tallene: x_ny = x*x - y*y + a og y_ny = 2*x*y + b.
I en åpning putter vi først inn et tilfeldig tallpar (a,b) = (0.2, 0,3), som vi kaller parameter.
 I neste åpning putter vi såkornet. Når vi kjører programmet nedenfor skal såkornet hele tiden være (x,y) = (0,0).
Deretter setter vi maskinen i arbeid:
Først beregner den verdien av x*x - y*y + a og putter svaret i lagerplass x_ny
Så beregner den 2*x*y + b og putter svaret i lagerplass y_ny.
(Som elev ville du her skrevet ned de to svarene og satt to streker under, men da ville vi ikke fått de fraktalene som Benoit Mandelbrot gjorde kjent for oss. Nei, maskinen er laget for å kunne bruke svaret på en smart måte:)
Maskinen tar de to svarene og putter de inn igjen i lagerplassene x og y.
Så regner den en gang til. (Utdata blir til inndata.), Så regner den en gang til. (Utdata blir til inndata.)....osv......

Hvis x*x+y*y blir større enn 4, stoppes gjentagelsen. Ellers gjentas beregningen helt til i får verdien maxitr-1.

Antall gjentagelser, i, returneres fra funksjonen: def tell_antall(a, b, maxitr).

def behandle(i,j,itr, maxitr):

Det aktuelle pixelpunktet (i, j) gis her farge. Fargen bestemmes av den forhåndsvalgte «maxitr» og av den aktuelle «itr-verdien» som ble returnert fra funksjonsmaskinen.

Ved å bruke (i-int(p*zoom) , j+int(q*zoom)), i stedet for bare (i , j), får vi alltid bildet til sentrum av python-vinduet .

from turtle import*
import time
colormode(255)
#02
def tell_antall(a, b, maxitr):
    x , y = 0 , 0
    for i in range(maxitr):
        x_ny = x*x - y*y + a
        y_ny = 2*x*y + b
        x = x_ny
        y = y_ny
        if x*x + y*y >4:
            break
    return(i)
#02
def behandle(i,j,itr, maxitr):
    trio = (abs(itr-maxitr)*8%255 , abs(itr-maxitr)*14%255,abs(itr-maxitr)*70%255 )
    color(trio)
    pu()
    setpos(i-int(p*zoom) , j+int(q*zoom))
    dot(punktstorrelse)   
#01
#def matrise_rundt_punktet():
def matrise_rundt_punktet(p, q, radius, zoom, tetthet,punktstorrelse,maxitr):
    p_vest = p - radius
    p_ost = p +radius
    q_nord = q +radius
    q_syd = q-radius
    print("vest, midt, øst:")
    print(p_vest,p,p_ost)
    print("nord:",q_nord,"midt:",q,"syd:",q_syd)
    for j in range(-int(q_nord * zoom), -int(q_syd * zoom)+1 , tetthet):
        i = int(p_vest *zoom)
        itr = 0
        while i < int(p_ost *zoom):         
            behandle(i,j,itr, maxitr)#02
            i = i + tetthet
            itr = tell_antall(i/zoom,j/zoom, maxitr)#02               
#00
t1=time.time()  
tracer(0,0)
p=-0.75
q=0
radius=1.5
zoom=50*2
tetthet = 2
punktstorrelse = 3
maxitr=101
#Skal videre-utvikes:
matrise_rundt_punktet(p, q, radius, zoom, tetthet,punktstorrelse, maxitr)
write(".   DEL AV MANDELBROTPLAN")
update()
print("Tid",time.time()-t1)