Árvore de Pitágoras tridimensional

                  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 tridimensional 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 
bidimensional 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):

Definições iniciais

> cilindro := proc( poligono:list, h) local n, N, u, v, i,
> poligono2,ret, uv;
>   n := nops(poligono): # no. de vértices >2
>   u := evalm(poligono[2]-poligono[1]):
>   v := evalm(poligono[3]-poligono[1]):
>   uv := crossprod(u,v):
>   N := evalm(h*normalize(uv)):
>   poligono2 := map(convert,map(matadd,poligono,N),'list'):
>   for i from 1 to (n-1) do
>     ret[i] := [poligono[i], poligono[i+1],poligono2[i+1],
> poligono2[i]]:
>     od:
>   ret[n] := [poligono[n],poligono[1], poligono2[1],poligono2[n]]:
>   RETURN(poligono, poligono2,seq(ret[i],i=1..n)):
> end:
> 

Utilizamos triângulos retângulos isósceles, o que possibilita a
execução do programa  em máquinas mais lentas e para acertar a profundidade w
do bloco básico de forma a colar com torção. Utilizamos w como sendo a
média geométrica entre a hipotenusa e o cateto. Em vez de quadrados construímos 
retângulos sobre os lados dos triângulos.

> H := 2:
> Hhip := H*hip: 
> w2 := evalf(surd(2,4)):  # um valor a ser utilizado diversas vezes
>  hip := 1: w := hip/w2: triqhip0 := [[0,0,0],
> [0,0,-Hhip],[hip,0,-Hhip],[hip,0,0],[hip/2,0,hip/2]]: 

Medida da hipotenusa, da profundidade, e a definição do pentágono que é a
justaposição do triângulo com o "quadrado" da hipotenusa

> bloco[1] :=[cilindro(triqhip0,w)]: # bloco inicial básico
> fig[1]:=polygonplot3d(bloco[1],scaling=constrained,
> color=COLOR('RGB',1,0,0)): display(fig[1], style=patch, title=`Bloco
> básico`);
> 

Definindo agora a movimentação do bloco básico para colagem com o bloco anterior.

> mov0 := proc(X,P,Q,R) local u,v,N,u2,v2, M;
>   u2:=evalf(norm(evalm(Q-P),2)): v2 :=evalf(norm(evalm(P-R),2)):
>   u := evalm((Q-P)/u2): v:= evalm((P-R)/v2): N := crossprod(u,v):
>   M := evalm(u2*concat(u,v,N)):
>   convert(evalm(M&*(X-[0,0,-Hhip]) + P),'list'):
> end:  # função movimento (movimento rígido + homotetia)
> movbloco := proc(P,Q,R) local w,triqhip;
>   w := evalf(norm( evalm(Q-P),2)/w2):
>   triqhip :=cilindro(map(mov0,triqhip0,P,Q,R),w):
>  RETURN([triqhip]) end: # movimento aplicado no bloco

Processo iterativo para obtenção da árvore

> num := 9: k:=1: j:=2: # inicialização

Construímos o loop  while a seguir de modo que o usuário possa 
interrompê-lo no momento que desejar  (por exemplo, usando o ícone STOP) 
e em seqüência dar prosseguimento ao programa:

> while k<num do
>   cor :=COLOR('RGB',1-k/num, k/num,0):
>   while j<2^(k+1) do
>     j1 := iquo(j,2): r1 := irem(j,2):
>     if r1=0 then 
>        bloco[j] :=movbloco(bloco[j1][6][1],bloco[j1][6][4],
> bloco[j1][6][2]) 
>        else bloco[j] :=movbloco(bloco[j1][7][1],bloco[j1][7][4],
> bloco[j1][7][2]) fi:
>     fig[j]:= polygonplot3d(bloco[j], scaling=constrained,
> style=patchnogrid,color=cor): # print(k,j): 
>     j:=j+1: od: 
>   k:=k+1: od:

           Interrompa a interação quando desejar, usando o ícone STOP


Mostrando o desenho do fractal e o número de iterações calculadas até a interrupção: 

> display([seq(fig[i],i=1..(j-1))],scaling=constrained,
> style=patchnogrid, title=`Árvore de `.(j-1).` galhos`,
> lightmodel=light2);
>