Fraktalok a Mapleben

Capitolul 1: Noţiuni introductive

1.1 Ce este un fractal?Definiţie: Un fractal este un obiect matematic, care are o structură detaliată

la orice scară. Dacă privim mai atent structura unui fractal, observăm că

fiecare părticică este asemănătoare cu fractalul întreg. O definiţie este dată

de Alexander F. Walz:

Definiţie: Un fractal este o schemă copiată de o infinitate de ori intr-un

spaţiu finit.

Vom da ca exemplu următoarea mulţime Mandelbrot (vom detalia

acest tip de fractal în capitolul 3), dat prin formula

.

Am mărit o parte a fractalului de mai multe ori şi putem vedea că partea

mărită este la fel ca şi fractalul iniţial.

Putem privi fractalii şi ca fiind o parte a haosului, deoarece se

comportă la fel ca şi haosul, sunt la fel de complecşi, chiar şi formulele lor

de creare sunt asemănătoare. Legătura dintre fractali şi haos poate fi descrisă

astfel: “Orice mişcare haotică poate fi descrisă printr-o structură fractală şi

elementele unui fractal sunt asezate în plan în ordine haotică.”

1.1 Cum să creăm un fractal?Algoritmii care crează un fractal in Maple sunt simpli, de exemplu

următorul fractal a fost creat în MapleV:> lambdafn := proc(x, y)> local z, m, p1;> z := evalf(x+I*y);> for m from 0 to 50 while abs(z) < 4 do> z := sin(z)*1+I*0.4> od;> m> end:

> plot3d(0, -1.5 .. 1.5, -1.1 .. 1.1, color=lambdafn, [...]);

In acest algoritm am folosit formula de creare sin(z)*p cu p=1+I*0.4,

în loc de formula clasică a mulţimii Mandelbrot .

Capitolul 2: Fractali linii

-fractali create prin iteraţie

Aceşti fractali sunt creaţi prin iteraţie,prin repetarea unui algoritm.

Mai sunt numiţi şi fractali IFS Iterated Function System.

2.1 Curba Koch (snowflake) Cel mai cunoscut fractal şi cel mai simplu fractal este curba Koch, care

mai este numit şi Snowflake, deoarece seamănă cu un fulg de nea.

Se crează după următorul algoritm:

- desenăm un segment;

- împărţim segmentul în trei părţi egale;

- pe segmentul din mijloc desenăm un triunghi echilateral şi ştergem

segmentul din mijloc;

- repetetăm pe fiecare segment acest procedeu.

În continuare voi arăta cum să creăm o curbă Koch cu ajutorul

programului Maple:

> koch := proc(p: numeric)> # SNOWFLAKE> # algorithm taken from 'Algorithmen fuer Chaos und Fraktale'> # by Dietmar Herrmann, Addison-Wesley> # original program written in BASIC

> # ported to Maple V. modified and optimized by Alexander F. Walz> # Version 1.0 - July 27, 1996> # Version 1.1 - May 23, 1999, twice as fast as v 1.0> local m, n, k, l, s, h, x, y, pts, t, i;> h := 3^(-p);> pts := table([]): # [0, 0];> x := 0; y := 0;> for n from 0 to (4^p-1) do> m := n;> s := 0;> for l from 0 to p-1 do> t := irem(m, 4);> m := iquo(m, 4);> s := s+irem((t+1), 3) - 1> od; # end of for l> x := evalhf(x+cos(Pi*s/3)*h);> y := evalhf(y+sin(Pi*s/3)*h);> pts[n] := [x, y];> od; # end of for n> [seq(pts[i], i=0 .. n-1)];> end:

> plot(koch(1), scaling=constrained, style=LINE, axes=NONE);






2.2 Triunghiul SierpinskiPe acest fractal se vede cel mai bine că oricare parte am lua acesta este

identic cu fractalul întreg original.Acest fractal a fost conceput de matematicianul polonez Waclaw Sierpinski (1882-1969) şi publicat pentru prima dată în 1916. Se crează tot prin iteraţie, după următorul algoritm:

-desenăm un triunghi ecilateral;

-legăm punctele de mijloc a laturilor;

-şi din triunghiurile astfel create, ştergem triunghiul din mijloc;

-repetăm acest procedeu şi în triunghiurile mici create.> chaos:=proc(x1, y1, x2, y2, x3, y3, maxiter, seed1, seed2)> # original procedure written by Tom Williams and modified by John Oprea> local randi, x, y, sx, sy, ir, i, j;> randi:=rand(1 .. 3):> x:=[x1, x2, x3]:> y:=[y1, y2, y3]:> sx:=seed1:> sy:=seed2:> ir:=[sx, sy]:> for i from 1 to maxiter do > j:=randi(): > sx:=(sx+x[j])/2.:> sy:=(sy+y[j])/2.:> ir:=[op(ir), sx, sy] > od: # concatonates sx and sy onto list ir> plot(ir, style=point, symbol=POINT, scaling=constrained);> end:> chaos(0, 0, .5, 1, 1, 0, 7000, .5, .5);

> chaos(0, 0, -4, 7, 6, 2, 3000, 1, .5);

2.3 Alţi fractali de tip IFSIn acest paragraf vom prezenta un procedeu prin care poate fi creat un

fractal care se găseşte şi în natură, şi acesta este feriga. Programul a fost

găsit în cartea Bausteine des Chaos - Fraktale scris de Heinz-Otto

Peitgen, Hartmut Juergens şi Dietmar Saupe şi a fost puţin modificat pt

MapleV. Să vedem programul:> restart:> ifsmaple:=proc(imax)> # Iterated Functions Systems> # Originalprogramm 'Chaos-Spiel fuer ein Farnblatt' geschrieben> # in BASIC, ver"ffentlicht in: 'Bausteine des Chaos - Fraktale',> # Springer Verlag/Klett-Cotta, S. 415 von denselben Autoren> local e1, e2, e3, e4, f1, f2, f3, f4, x, y, xn, yn, z, pts;> pts:=NULL;> e1:=0.5; e2:=0.57; e3:=0.408; e4:=0.1075;> f1:=0; f2:=-0.036; f3:=0.0893; f4:=0.27;> x:=e1;> y:=0;> to imax do> z:=rand()/1e12;> if z<=0.02 then > xn:=e1;> yn:=0.27*y+f1> elif z<=0.17 then > xn:=-0.139*x+0.263*y+e2;> yn:=0.246*x+0.224*y+f2> elif z<=0.3 then > xn:=0.17*x-0.215*y+e3;> yn:=0.222*x+0.176*y+f3> else> xn:=0.781*x+0.034*y+e4;> yn:=-0.032*x+0.739*y+f4> fi;> pts:=pts, [xn, yn];> x:=xn;> y:=yn;> od;> [pts]> end:

> plot(ifsmaple(12500), axes=NONE, style=point, symbol=POINT, scaling=constrained);

Următoarele proceduri crează diferite fractali-linii, multe dintre ei se

găsesc şi în natură (fractali care reprezintă un cristal , o frunză, un arbore) şi

aceste proceduri au fost scrise de francezul Alain Schauber, Forbach.> transforme_point := proc(t, p) > [t[1]*p[1]+t[2]*p[2]+t[5], t[3]*p[1]+t[4]*p[2]+t[6]]> end:

> transforme_triangle := proc(t, triangle) > local i; > [seq(transforme_point(t, triangle[i]), i=1 .. 3)]> end:

> IFS := proc(n, liste_de_transformations)> local i, j, k, s, sequence_de_triangles:> options `Copyright by Alain Schauber, 1996`;> sequence_de_triangles := [[0, 0], [1, 0], [0.5, 1]];> for j to n do> s := NULL;> for i to nops(liste_de_transformations) do

> s := s, > seq(transforme_triangle(liste_de_transformations[i],> op(k, [sequence_de_triangles])),> k=1 .. nops([sequence_de_triangles])) > od;> sequence_de_triangles := s> od;> plots[polygonplot]([sequence_de_triangles], axes=none,> color=black, scaling=constrained)> end:

> tamis_de_Sierpinski:=> [[0.5,0,0,0.5,0,0],[0.5,0,0,0.5,0.5,0],[0.5,0,0,0.5,0.25,0.5]]:

> arbre_de_Noel_double:=> [[0,-.5,.5,0,.5,0],[0,.5,-.5,0,.5,.5],[.5,0,0,.5,.25,.5]]:

> labyrinthe_de_Sierpinski:=> [[evalf(1/3),0,0,evalf(1/3),evalf(1/3),evalf(2/3)],> [0,evalf(1/3),1,0,evalf(2/3),0],> [0,-evalf(1/3),1,0,evalf(1/3),0]]:

> rameau:=> [[.387,.430,.430,-.387,.2560,.5220],> [.441,-.091,-.009,-.322,.4219,.5059],> [-.468,.020,-.113,.015,.4,.4]]:

> cristal:=> [[.255,0,0,.255,.3726,.6714],[.255,0,0,.255,.1146,.2232],> [.255,0,0,.255,.6306,.2232],[.37,-.642,.642,.37,.6356,-.0061]]:

> mecano:=> [[.382,0,0,.382,.3072,.619],[.382,0,0,.382,.6033,.4044],> [.382,0,0,.382,.0139,.4044],[.382,0,0,.382,.1253,.0595],> [.382,0,0,.382,.492,.0595]]:

> feu:=> [[evalf(1/3),0,0,evalf(1/3),0,0],> [evalf(1/6),evalf(-sqrt(3)/6),evalf(sqrt(3)/6),evalf(1/6),evalf(1/3),0],> [evalf(-1/6),evalf(-sqrt(3)/6),evalf(sqrt(3)/6),evalf(-1/6),> evalf(2/3),0],[evalf(1/3),0,0,evalf(1/3),evalf(2/3),0]]:

> arbre:=> [[.195,-.488,.344,.443,.4431,.2452],[.462,.414,-.252,.361,.2511,.5692],> [-.058,-.07,.453,-.11,.5976,.0969],[-.035,.07,-.469,-.022,.4884,.5069],> [-.637,0,0,.501,.8562,.2513]]:

> maple := > [[0.29, 0.4, -0.4, 0.3, 0.28, 0.44],> [0.33, -0.34, 0.39, 0.4, 0.41, 0],> [0.42, 0, 0, 0.63, 0.29, 0.36],> [0.61, 0, 0, 0.61, 0.19, 0.23],> [0.01, 0, 0, 0.29, 0.5, 0.13]]:

> tab15 := > [[-0.04, 0, -0.23, -0.65, -0.08, 0.26],> [0.61, 0, 0, 0.31, 0.07, 2.5],> [0.65, 0.29, -0.3, 0.48, 0.54, 0.39],> [0.64, -0.3, 0.16, 0.56, -0.56, 0.4]]:

> koch:=> [[evalf(1/3), 0, 0, evalf(1/3), 0, 0],> [evalf(1/3), 0, 0, evalf(1/3), evalf(2/3),0],> [evalf(1/6),evalf(-sqrt(3)/6),evalf(sqrt(3)/6),evalf(1/6),evalf(1/3),0],> [-evalf(1/6),evalf(sqrt(3)/6),evalf(sqrt(3)/6),evalf(1/6),evalf(2/3),0]]:

> tab21 := > [[0, 0, 0, 0.5, 0, 0],> [0.4, -0.4, 0.4, 0.4, 0, 0.2],> [0.4, 0.4, -0.4, 0.4, 0, 0.2]]:

> IFS(8,tamis_de_Sierpinski);

> IFS(7,arbre_de_Noel_double);

> IFS(6,labyrinthe_de_Sierpinski);

> IFS(7,rameau);

> IFS(5,cristal);

> IFS(4,mecano);

> IFS(5,feu);

> IFS(5,arbre);

> IFS(5, maple);

> IFS(6, tab15);

> IFS(8, tab21);

2.3 Dimensiunea unui fractal IFS

În cazul fractalilor nu putem vorbi despre dimensiune ca fiind un număr

natural, ci este un număr fracţional între 1 şi 2. Vom vorbi despre

dimensiune în trei sensuri, ca:

-dimensiunea unui spaţiu Euclidian (D=1,2 sau 3);

-numărul de variabile într-un sistem dinamic;

-dimensiunea fractalilor sau dimensiunea Hausdorff.

Vom folosi notaţiile:

- cu r vom nota proporţia micşorării ( de exemplu în cazul curbei Koch este

1/3, deoarece fiecare segment nou este o treime din segmentul iniţial);

-cu N notăm numărul corpurilor necesare pentru acoperirea corpului iniţial

(de exemplu în cazul curbei Koch este 4, pentru că la fiecare pas figura este

formată din 4 treimi).

Logaritmizând această formulă obţinem formula dimensiunii unui fractal

IFS:

log(N) = D log(r) , adică

D=log(N)/log(r)Dimensiunea curbei Koch este :

r= N=4 =>

Dimensiunea triunghiului Sierpinski este :

N=3 =>

Putem deduce o definiţie a fractalilor:

Definiţie: Un fractal este o figură geometrică, a cărei dimensiune nu este un

număr natural.

Lungimea curbei Koch:

Să vedem pas cu pas cum se crează curba Koch: iniţial are dimensiunea 1

la al doilea pas este 4/3, la pasul al treilea este 16/9 si forma finală are

lungimea 64/27.

Capitolul 3:Fractali “Escape-time”

3.1 Fractalul Mandelbrot şi mul ţ imea Julia

Aceşti fractali au aceeaşi formulă de creare ( într-un fel mulţimea Julia este un caz particular a mulţimii Mandelbrot). Transcriem fiecare punct al planului sub formă de număr complex z0 şi aplicăm formula de creare:

Formula de creare

Valoarea iniţială z0

Valoarea iniţială c

Mulţimea Mandelbrot

zn+1:=zn2+c z0:=a+bi c= z0 variabil

Mulţimea Julia zn+1:=zn2+c z0:=a+bi c:=a+bi ,

a,bR fixat

Din tabel se observă foarte bine că singura diferenţă dintre mulţimea Mandelbrot şi mulţimea Julia este, că în cazul mulţimii Mandelbrot c poate fi orice punct din plan, dar în cazul mulţimii Julia acesta este fixat (din această cauză în unele cărţi apare că mulţimea Julia este un caz particular).

În continuare vom prezenta mulţimea Mandelbrot. În Maple nu există posibilitatea de a desena doar un punct pe ecran (mulţimea Mandelbrot este format din puncte ale planului, care satisfac ecuaţia de creare a fractalului) şi de aceea vom folosi următoarea procedură:

# The Mandelbrot set ## 2D display coding by John Oprea, [email protected]

> restart: with(plots):

> mandelbrot := proc(x, y)> local c, z, m;

> c := evalf(x+y*I);> z := c;> for m from 0 to 30 while abs(z) < 2 do> z := z^2+c> od;> m> end:

> plot3d(0, -2 .. 0.7, -1.2 .. 1.2, orientation=[-90,0], grid=[250, 250], > style=patchnogrid, scaling=constrained, color=mandelbrot);

> plot3d(0, -0.83561 .. -0.78523, 0.15559 .. 0.19343, orientation=[-90,0], > grid=[250, 250], style=patchnogrid, scaling=constrained, color=mandelbrot);

Schimbând valorile parametrilor grid în comanda plot3d obţinem grafice cu o rezoluţie mai bună, dar se va scimba şi timpul în care se afişează fractalul. Tot prin modificarea comenzii plot3d (adăugăm un al treilea parametru şi schimbăm al doilea parametru) putem afişa doar o parte a fractalului. Comanda style=patchnogrid desenează suprafaţa fractalului prin bucăţi rectangulare (această opţiune este cea mai indicată, cea mai bună).Procedura mandelbrot returnează valoarea parametrului m, care este probabilitatea ca punctul (x,y) să aparţină mulţimii Mandelbrot. M depinde de numărul de iteraţii, care în cazul nostru este 30. Este posibil ca un punct să satisfacă condiţia abs(z) < 2 după n iteraţii, dar să nu mai satisfacă ecuaţia după iteraţia n+1. Astfel ca să fim siguri că punctul aparţine mulţimii trebuie să avem o infinitate de iteraţii.

Variabila m este utilizată în opţiunea 'color=mandelbrot' pentru vizualizarea mulţimii: partea roşie- “lacul” Mandelbrot - este mulţimea Mandelbrot (totuşi marginea roşie nu aparţine mulţimii).

În continuare vom vedea o procedură numită MandelbrotFast, care este o versiune mai rapidă după cum ne arată şi numele procedurii, şi afişează o mulţime Mandelbrot 3-dimensional:

> restart:

> mandelbrot := proc(x, y)> local z, c, m;> z := evalf(x+y*I);> for m from 0 to 25 while abs(z) < 2 do> z := z^2 + c> od;

> m> end:> plot3d(mandelbrot, -2 .. 0.5, -1.2 .. 1.2, grid=[200, 200],> style=patchnogrid, shading=zhue, orientation=[45, 35]);

In continuare vom prezenta programe pentru reprezentarea fractalilor Julia.

> restart; with(plots):

# Julia sets

> julia := proc(c,x, y)> local z, m;> z := evalf(x+y*I);> for m from 0 to 30 while abs(z) < 3 do> z := z^2 + c> od;> m> end:

> J := proc(d)> global phonyvar;> phonyvar := d;> (x, y) -> julia(phonyvar, x, y)

> end:

> plot3d(0, -2 .. 2, -1.3 ..1.3, style=patchnogrid, > orientation=[-90,0], grid=[250, 250], > scaling=constrained, color=J(-1.25));

O modalitate de a crea noi fractali (cazuri particulare a mulţimilor

Mandelbrot şi Julia) este schimbarea valorilor iniţiale (schimbăm partea

imaginară sau partea reală a numărului c) sau prin schimbarea formulelor de

creare.

De exemplu următorul program numit biomorfism şi creat de M.B. Monagan, K.O. Geddes, G. Labahn and S. Vorkoetter, Springer Verlag, şi modificat de John Oprea, afişează un caz particular a mulţimii Mandelbrot cu formula de creare 'z:=cos(z)*z^2+c'.

> # BIOMORPH2> # Based on a Maple V algorithm taken from the book > # 'Maple V - Programming Guide' by M.B. Monagan,

> # K.O. Geddes, G. Labahn and S. Vorkoetter, > # Springer Verlag, modified by John Oprea> #> # modification of initialization and iteration by Alexander F. Walz> # May 22, 1996> #> biomorph2:=proc(x, y)> local z, m, c;> z:=evalf(x+y*I);> c:=z;> m:=0;> to 100 while abs(z) < 4 do> z:=cos(z)*z^2+c;> m:=m+1;> od;> m;> end:

> plot3d(0, -2 .. 2, -1.5 .. 1.5, orientation=[-90,0], grid=[250, 250],> style=patchnogrid, scaling=constrained, color=biomorph2);

3.2 Eroarea lui AlexCând Alexander F. Walz a încercat pentru prima oară programul

mulţimii Mandelbrot a comis următoarea greşeală: în loc de punctul original (x0, y0) a cărei valoare abolută este mai mică decât 2, programul a returnat valorile lui xn şi yn, care conţin valorile originii după al n-lea iteraţie. Astfel a obţinut un altfel de mulţime Mandelbrot. Şi acum să vedem programul:

> restart: with(plots):

> alexerror:=proc(x, iter)> # written by Alexander F. Walz> # May 29, 1996> # March 02, 1997> local n, pts, xn, xnold, yn, y;> pts:=[0, 0]; > for y from 0 to 1.1 by 0.01 do> xn := x;> yn := y;> for n to iter while evalhf(xn^2+yn^2) < 4 do> xnold:=xn;> xn := evalhf(xn^2-yn^2+x); > yn := evalhf(2*xnold*yn+y)> od;> if n >= iter then pts := pts, [xn, yn], [xn, -yn] fi;> # as a variant try: > # "if n >= iter then pts := pts, [x, y] fi;" > # for the Mandelbrot set > od; > pts > end:

> i:='i':

> PLOT(seq(POINTS(alexerror(i/100)), i=-200 .. 70), SYMBOL(POINT));

Pentru a putea face comparaţia mai uşoară să vedem şi o mulţime

Mandelbrot:

Si acum vom vedea contopirea mulţimii Mandelbrot şi a erorii Alex după

100 de iteraţii:

3.3 Jufn and Zsqrd Acest fractal a fost descoperit de Clifford A. Pickover. Este un caz

particular a mulţimii Julia obţinut prin schimbarea formulei de creare, prin

adăugarea unei noi funcţii. Programul cu care afişăm acest deosebit, dar

frumos fractal este următoarea :

> restart:> julfn_zsqrd:=proc(x, y)> # Based on a Maple V algorithm taken from the book > # 'Maple V - Programming Guide' by M.B. Monagan, > # K.O. Geddes, G. Labahn and S. Vorkoetter, > # Springer Verlag, modified by John Oprea> # modification of initialization and iteration by Alexander F. Walz> # May 26, 1996> local c, z, m;> c := evalf(-0.5 + 0.5*I);> z := evalf(x + y*I);> for m from 0 to 30 while abs(z) < 3 do> z := sin(z) + z^2 + c;> od;> m> end:

> plot3d(0, -1.91 .. 1.37, -1.24 ..1.21, style=patchnogrid, > orientation=[-90,0], grid=[250, 250], scaling=constrained, > color=julfn_zsqrd);

Capitolul 4: Utilizarea fractalilor în viaţa de zi cu zi

În capitolul 2 s-a văzut că fractalii se găsesc şi în natură, în mediul care ne înconjoară, copacii, frunzele, feriga, fulgul de nea,etc. toate au o structură fractală.

Majoritatea fenomenelor naturii sunt haotice şi mişcările haotice pornesc de la o structură fractală. Cu ajutorul fractalilor putem reprezenta dispersia energiei rezultate din incendiul unei păduri. Acest model a fost creat de Mandelbrot şi un model asemănător este folosit şi pentru prezicerea cutremurelor. În desenul de mai jos copacii sunt desenate cu verde, focul cu galben, şi terenurile goale cu negru, presupunem că copacii noi cresc pe terenurile goale cu o probabilitate de 1/32 pe minut.

Generăm un număr de copaci pe un teren rectangular. Reactualizăm

desenul cu toate schimbările în fiecare moment t în felul următor:

(1) cresc copaci noi cu probabilitatea p pe terenurile goale într-un timp t-1;

(2) copacii care sunt înflăcări la timpul t-1 şi mor, şi dispar în momentul t;

(3) un copac a cărui învecinat este în flăcări în momentul t-1, izbucneşte şi

el în flăcări în momentul t.

În desenul de mai sus sistemul ajunge la punctul critic din punct de vedere a

arderii. Drossel şi Schwabl au extins modelul prin adăugarea unei mici

probabilităţi f de a arde copaci noi la fiecare pas. Daca f/p0 numărul de

copaci în flăcări este s şi probabilitatea va fi

cu r≈3.

Un alt domeniu care utilizează fractalii este informatica. O metodă nu

prea cunoscută este arhivarea cu ajutorul fractalilor; pozele, fişierele pot fi

micşorate de 100 de ori. Lexiconul Encarta a fost arhivat cu aceasta metodă.

La crearea animaţiilor tot fractalii sunt folosiţi, sau la crearea desenelor

animate pe calaculator.

Un alt domeniu care foloseşte fractalii este chimia. Structura

polimerelor, nylonului, poliesterului, se bazează tot pe o structură fractala.

KEP În ultimii ani s-a descoperit că unele sisteme biologice nu au

caracteristicile cum ar fi: lungime, sau nu depind de timp, ci ei au

proprietăţile unui fractal, sau mai general, au proprietatea că orice parte a lor

mărit este identic cu întregul. Aceste proprietăţi de fractali diferă de la un

sistem biologic la altul, uneori aceste proprietăţi sunt ascunse, apar doar dacă

studiem sistemul ca o funcţie ce depinde de timp sau sub forma grafică.

De exemplu în reprezentarea lanţului de mai jos se vede foarte bine că orice

parte mărită va semăna perfect cu lanţul întreg.

Tot fractalii sunt folosiţi şi în reprezentarea de mai jos a unui neuron din

nervul optic:

Biologii cu ajutorul fractalilor studiază diferenţa dintre diferite lanţuri ADN

Din desenele de mai jos putem chiar şi noi laicii să observăm mai bine

lucrurile. În aceste desene sunt reprezentate lanţurile ADN a omului şi a

unor animale sau plante cum ar fi drojdia, amiba, drosofila, găina. In părţile

haşurate sunt presentate genele codificate.

La fel ca şi lanţul ADN, şi căile respiratorii pot fi reprezentate prin

fractali. Ei au aspectul unui copac cu crengi, trunchi, rădăcină răsfirată.

Mecanismul dinamic al respiraţiei, atrage după sine o “ avalanşă” de aer de

orice volum, care are o distribuţie exponenţială. Prima cauză a acestei

distribuţii, care nu depinde de volum, este faptul că fiecare parte a căilor

respiratorii: traheea, bronhiile principale, bronşiolele şi alveolele pulmonare

au propriul lor prag de dilataţie, sub care nu pătrunde aerul in ele. Diagrama

de mai jos prezintă dezvoltarea acestei “avalanşe” cu ocazia fiecărei

respiraţii.

Prima dată aproape toate căile respiratorii, notate cu roşu, a căror

prag de presiune este mai mic decât valoarea presiunii externe, sunt închise.

După ce creşte presiunea de deschidere din căile respiratorii până la al doilea

prag de deschidere se deschid şi alte căi respiratorii, notate în desen cu

verde. Presiunea de deschidere a căilor respiratorii creşte în mod continuu

până la al treilea, al patrulea, al cincilea prag, cu deschiderea succesivă a

următoarelor segmente ale căilor respiratorii, notate în desen cu galben,

maro şi albastru. După ce presiunea depăşeşte ultimul prag de deschidere a

căilor respiratorii, desenat cu violet în desen, în această etapă se utilizează

25% din volumul total pulmonar.

Chiar şi ritmul sinusal poate fi reprezentat prin fractali, în următorul

desen vom vedea cum poate fi descrisă ritmul sinusal cu fractali.

Vom nota intervalul dintre două bătăi cu BL(n).

La punctul (a) se înregistrează bătăile cardiace a unui individ sănătos,

iar la punctul (b) se înregistrează bătăile cardiace a unui bolnav care suferă

de o boala cardică severă, cardiomiopatie dilatativă. Seria în timp a ritmului

cardiac normal are mai multe fluctuaţii complexe în comparaţie cu ritmul

cardiac a unui bolnav. Diagrama (c) conţine reprezentarea simplificată a

ritmului cardiac în funcţie de timpul dintre două bătăi şi numărul bătăilor,

pentru a observa mai uşor diferenţa dintre un ritm normal şi unul patologic.

Revenim din nou la reprezentarea lanţului ADN, dar desenul de mai

jos reprezintă lanţul ADN a unui

(a) β-cardiac-miosin uman cu secvenţe de lanţuri de gene grele, unde

regiunile codificate sunt reprezentate cu linii verticale galbene;

(b) se prezintă regiunile codificate de la punctul (a) puse cap la cap;

(c) este reprezentat ADN-ul lambda a bacteriofagului care conţine doar

secvenţe codificate.

Acest procedeu poate fi utilizat doar pentru reprezentare grafică, dar nu şi

pentru calcule analitice.

Cu ajutorul fractalilor putem crea şi muzică, de exemplu cu ajutorul

programului “chaosmusic” de pe discheta alăturată. Muzica fractală este

folosită şi în medicină. Medicii au transcris ritmul bătăilor cardiace sub

formă de muzică, şi din desenul de mai jos se poate observa ce diferenţă

mare este între o “muzica” unei inimi sănătoase şi cea a unei inimi bolnave.

Bătăile cardiace care au fost prelucrate şi transcrise în muzică, au fost

înregistrate pe o durată de 24 de ore şi conţin aproximativ 106 bătăi cardiace

cu o fluctuaţie mai >0.05 (bătai-1). Fluctuţia în prima parte este mult mai

complexă decăt în a doua parte.

Documents

Fraktalok a Mapleben