Árvore de Pitágoras bidimensional

               Yolanda Kioko Saito Furuya
               Departamento de Matemática
            Universidade Federal de São Carlos.

Apresentamos aos estudantes interessados um programa que gera o fractal 
chamado Árvore de Pitágoras. Temos aqui a versão bidimensional do fractal. 
Este programa pode ser executado no Maple V Release 4 e possivelmente 
em versões posteriores, e faz parte do Hipertexto Pitágoras, disponível na 
Internet a partir do endereço http://www.dm.ufscar.br Neste Hipertexto está 
também disponível um programa análogo para gerar a versão tridimensional 
do fractal. Nossa figura foi adaptada de um programa proposto por Harm Derksen   
no sítio http://www.maplesoft.com/ O programa de Derksen talvez não se encontre 
mais disponível neste sítio.

> restart:
> with(plots): with(linalg):

Definindo as proporções do triângulo base:

> cateto0:= 3: cateto1 := 4: hip0 := sqrt(cateto0^2+cateto1^2):
> tri0 := [[cateto0,0], [0,0], [0,cateto1]]:

Funções e definições auxiliares:

> pit0 := [[[cateto0,-cateto0],[0,-cateto0],[0,0],[cateto0,0]],
> [[-cateto1,0],[-cateto1,cateto1],[0,cateto1],[0,0]], tri0]:
> u := evalm(tri0[3]-tri0[1]): u2 := norm(u,2):
> mov := proc(X,v,P) local lambda, Q, x,y, v2, s;
>        v2 := norm(v,2): lambda := v2/u2;
>        s :=solve({x*u[1]-y*u[2] = u2*v[1]/v2, y*u[1]+x*u[2] =
> u2*v[2]/v2},{x,y}); assign(s): 
>        Q := convert(evalm(lambda*matrix(2,2,[x,-y, y,x])&*(X-tri0[1])+P), 'list');
>        RETURN(Q);
>        end:
> 
> movpit0 := proc(P,Q) local v; 
>     v:= evalm(Q-P); 
> [map(mov,pit0[1],v,P),map(mov,pit0[2],v,P),map(mov,pit0[3],v,P)] end:
> 
>   Ploti := proc(i) local fig00, fig01, fig02, movpit; 
>   movpit := Pit[i]; 
>   fig00 := polygonplot(movpit[1], color=yellow):
>   fig01 := polygonplot(movpit[2], color=green):
>   fig02 := polygonplot(movpit[3], color=red):
>   display({fig00, fig01, fig02}, scaling=constrained): 
>   end:

Início da sequência

> Pit[0] := [[0,0], [hip0,0], [hip0,-hip0], [0, -hip0]]:
> PitPlot[0] := polygonplot(Pit[0], scaling=constrained, axes=none,
> color=cyan): 
> Pit[1] := [op(movpit0(Pit[0][1], Pit[0][2]))]:
> PitPlot[1] := display( {PitPlot[0],Ploti(1)}): 
> epsilon :=0.3: Pare := false:
> Vale[1] := true: Vale[0] := true:
> n := 5: k := 1: # n é número de iterações e k a ordem inicial

O valor de n acima pode ser modificado para aumentar ou diminuir o número de iterações. 
Valores altos podem aumentar muito o tempo de computação. 

> while k <= n  do 
>   for i from 2^k to 2^(k+1)-1 do  
>      j1 := iquo(i,2): r1 := irem(i,2): 
>      if Vale[j1] = false then Vale[i] := false: PitPlot[i] :=
> PitPlot[i-1]: break 
>        elif r1 =0 then P:=Pit[j1][1][1]: Q:=Pit[j1][1][2]:  
>        else P:=Pit[j1][2][1]: Q:=Pit[j1][2][2]: fi:
>      Pit[i] :=movpit0(P,Q): 
>      PitPlot[i] :=  display( {PitPlot[i-1],Ploti(i)}):
>      if (norm(Q-P,infinity)<epsilon) then Vale[i] := false else
> Vale[i] := true: fi:
>      od: 
> k:= k+1: od:
> 

Desenhando o último estágio

> i: display(PitPlot[i-1]);

Animação da sequência de iterações

> a := floor((i-1)/10):
>  display([seq(PitPlot[a*k], k=0..10)], insequence=true);
>