Exemplo de aplicação

Um exemplo pouco explorado de aplicação utilizando os programas de GD é a introdução dos conceitos de algoritmo. Isso ocorre porque poucos são os programas de GD que dispõe de recursos para agrupar passos de construção na forma de uma função geométrica (que chamaremos de ``script'').

Informalmente, podemos dizer que um algoritmo é uma seqüência finita de passos que aplicada a um conjunto de dados de entrada produz um conjunto de dados de saída (ou resposta). Além disso, a menos de uma classe particular de algoritmos, um algoritmo deve ser determinístico, ou seja, sempre que for aplicado sobre um mesmo conjunto de entradas, deve produzir o mesmo conjunto de saídas. Observe que, se o conjunto de entrada for vazio, a saída do algoritmo será sempre a mesma.

Uma característica importante de um algoritmo é que ele resolve uma classe de problemas e não uma instância. Por exemplo, um algoritmo de ordenação para $N$ números inteiros (digamos com $N<10^{8}$), ordena qualquer conjunto com até $N$ inteiros, em qualquer configuração (isto é, qualquer que seja a permutação, dentre as $N!$ possíveis). A aplicação do algoritmo sobre um particular conjunto de inteiros, constitui a resolução de uma instância do problema.

Esta observação permite entendermos melhor a diferença entre a GD, que é do tipo 1-N e a geometria estática, tipo 1-1: uma solução geométrica implementada em GD, na prática constitui um algoritmo, enquanto a correspondente solução estática equivale a uma aplicação do algoritmo geométrico sobre um conjunto fixado de dados (estáticos e, portanto, único).

A caracterização de soluções geométricas como algoritmos, pode ser melhor percebida utilizando-se a GD, pois ao finalizar uma construção e testá-la com outras configurações (de entrada), fica claro que a mesma pode ser aplicada a qualquer outro conjunto de entradas (dentre os possíveis). Por outro lado, como observa (), as soluções obtidas pela geometria da régua e compasso são estáticas e particulares, pois não podem ser alteradas e nenhuma delas garante o significado genérico de sua definição (o desenho de um círculo, por exemplo, possui um centro e raio, ambos fixos, mas o conceito de círculo não depende de valores arbitrários).

Para introduzir o conceito de algoritmo geométrico, vamos examinar o exemplo , sobre a construção da mediatriz de dois pontos dados, A e B. Na tabela , apresentamos um esquema dos passos para obter a mediatriz $r$ de $A$ e $B$.

Tabela: Um algoritmo para construção da mediatriz

Mediatriz($A$,$B$):

$C0$ := Circ($A$,$B$);

$C1$ := Circ($B$,$A$);

$ln$ := Intersec($C0$,$C1$,$n$); //interseção Norte

$ls$ := Intersec($C0$,$C1$,$s$); //interseção Sul

$r$ := Reta($ln$,$ls$);

Resposta $r$;

Note que os passos descritos podem ser aplicados a quaisquer pares de pontos (não coincidentes) constituindo assim um algoritmo. Os comandos $Circ$, $Intersec$ e $Reta$ podem ser entendidos como primitivas (funções) geométricas: $Circ(X,Y)$ é a circunferência centrada em $X$ e passando pelo ponto $Y$; $Intersec(X,Y,p)$ é um dos pontos de interseção entre os objetos $X$ e $Y$ (podem existir dois, neste caso definidos por "norte", se $p=n$, ou "sul", se $p=s$); e $Reta(X,Y)$ é a reta que contém os pontos $X$ e $Y$ (se $X=Y$, a reta não será única).

Deste modo, é natural esperar que programas de GD permitam que construções geométricas sejam armazenadas explicitamente na forma de funções, como o fazem o iGeom, GSP e Cabri. Estas funções geométricas, por agruparem seqüências de comandos, recebem o nome de scripts (como nas versões atuais do iGeom e do GSP) ou macros (como no Cabri). Uma vez armazenada uma função, pode-se: (a) marcar os objetos de entrada (na ordem correta) e depois selecionar a função desejada (como no iGeom e GSP); ou (b) selecionar a função e depois marcar os objetos de entrada (Cabri). Como discutiremos posteriormente na seção , a primeira forma pode ser dita do tipo ``seleção+ação'' enquanto a segunda é do tipo ``ação+seleção''.

A possibilidade de armazenar algoritmos geométricos como funções é bastante útil do ponto de vista didático, pois permite que o aluno armazene em funções as construções que utiliza mais freqüentemente e com isso possa concentrar sua energia nas tarefas novas. Os programas já citados (iGeom, Cabri e GSP) permitem até que uma função, já armazenada, seja invocada durante a geração de uma nova função e com isso aproveitamos funções prontas para construir outras mais complexas.

Exemplo nos quais os usos das funções geométricas são muito úteis são aqueles com processo de repetição, nos quais é necessário aplicar várias vezes a mesma seqüência de passos, como no exemplo , apresentado por ().

Exemplo 2..3   Aquiles e a Tartaruga (ou "paradoxo de Zenão").
Aquiles e uma tartaruga apostam uma corrida, sendo que Aquiles tem o dobro da velocidade da tartaruga, e por isso, a tartaruga larga à frente.

Para simular geometricamente este exemplo (Figura ), definimos uma função dist_metade que obtém a próxima posição da tartaruga em relação a sua posição atual e a posição de aquiles (tabela ).

Tabela: Construção de uma função para o exemplo

dist_metade$(A, B)$
	Entrada: ponto $A$, ponto $B$.
	Saída: ponto $F$ tal que $F$ pertence semi-reta($A,B$) e d($B,F$)=d($A,B$)/2.
1.	$r$ := semi_reta($A,B$); semi-reta começando em $A$, passando por $B$
2.	$C0$ := circ($B,A$); circunferência centrada em B, passando por A
3.	$C1$ := circ($A,B$); circunferência centrada em A, passando por B
4.	$C$ := inters($C0,C1,n$); C é interseção "superior" (norte) entre as circunferências C0 e C1
5.	$D$ := inters($C0,C1,s$); D é interseção "inferior" (sul) entre as circunferências C0 e C1
6.	$S1$ := segm($C,D$); S1 é o segmento ligando C à D
7.	$E$ := inters($r,S1$); E é interseção entre r e S1
8.	$C2$ := circ($B,E$); circunferência centrada em B, passando por E
9.	$F$ := inters($C2,r,n$); F é interseção ``superior'' (norte) entre C2 e r

Figura: Representação gráfica para a função dist_metade

Utilizando a função dist_metade, podemos simular esta hipotética corrida a partir de eventos discretos, definindo duas sequências, uma de tempo $\{t_k\}_{k \in \mathbb{N}}$ e uma de posição $\{P_k\}_{k \in \mathbb{N}}$. Sendo $t_0$ o instante de largada e $P_0$ a posição inicial da tartaruga, podemos definir as sequências, para $k>0$, da seguinte forma:

$$\begin{array}{ll} t_k: & \hbox{ o instante em que Aquiles at... ...osição ocupada pela tartaruga no instante } t_{k}. \end{array}$$

Deste modo, a construção apresentada na Figura serve para gerar os pontos $P_k$, como esquematizado na tabela .

Tabela: Esquema para geração de respostas para o exemplo

Sendo $A$ e $B$ as posições iniciais, respectivamente, de Aquiles e da tartaruga, então:
1.	$P_0 = B$ é a posição inicial da tartaruga e $A$ é a posição inicial de Aquiles;
2.	$P_1 \leftarrow dist\_metade(A,P_0)$ quando Aquiles chegar à posição $P_0$ a tartaruga estará em $P_1$
$\left(\hbox{da cons\-trução, }P_1\in\vec{AP_0} \hbox{ e } d(P_0,P_1) = \frac{d(A,B)}{2}\right)$;
3.	$P_2 \leftarrow dist\_metade(P_0,P_1)$ quando Aquiles chegar à posição $P_1$ a tartaruga estará em $P_2$
$\left(P_2\in\vec{P_0P_1} \hbox{ e } d(P_1,P_2) = \frac{d(P_0,P_1)}{2} = \frac{d(A,B)}{2^2}\right)$
	e assim por diante.

Zenão argumentava que a metade de um número positivo (distância) é um número positivo e, deste modo, sendo o tempo e o espaço contínuos, Aquiles jamais alcançaria a tartaruga³. Como observado em (), o aparente paradoxo divulgado por Zenão ilustra a dificuldade que os matemáticos tinham, antes do surgimento do Cálculo Diferencial e Integral, com o conceito infinito e infinitésimo.

Note que o algoritmo geométrico apresentado na tabela possui um bloco de repetição (ou laço⁴), comum nas linguagens de programação usuais (como C, Pascal ou Java). O passo geral do algoritmo da tabela é:

$P_{k+1} \leftarrow dist\_metade(P_{k-1},P_k)$, para $k>1$, sendo $P_0 = B$ e $P_1=dist\_metade(A,B)$.

Assim, para efetuar a simulação utilizando dist_metade$(.,.)$ é necessário aplicá-la seguidas vezes. Entretanto, se na própria definição deste algoritmo incorporarmos uma chamada recorrente, a própria recorrência controla as múltiplas aplicações. Portanto, é natural imaginar que tal recurso também possa ser incorporado aos scripts na GD. A partir do script dist_metade podemos produzir um novo script, de nome aquiles, anotando a repetição através de uma recorrência (ou recursão). Usando a função dist_metade, o script aquiles é definido da seguinte forma:

Construção 2..4   $aquiles(A,B)$: ponto $A$, ponto $B$

1.	$F \leftarrow dist\_metade(A,B)$	de acordo com a construção da tabela
2.	$G \leftarrow aquiles(B,F)$	recorrência, aplicada aos pontos $B$ e $F$

A recorrência é caracterizada pela instrução na linha 2. Entretanto existe um problema com o pseudo-código da construção que é não indicar uma condição de parada. Nas linguagem de programação usuais, como C ou Pascal, utilizam-se um condicional para invocar a recorrência (e portanto, a recorrência é interrompida quando certa condição não é satisfeita). Em nosso caso, fazemos o controle definindo a priori o número de chamadas recorrentes. O número de vezes (conhecido como profundidade) que a recorrência será aplicada, , é definido na chamada da função pelo usuário. Por exemplo, a Figura mostra o uso do script aquiles com profundidade dois (poderia-se produzir

uma construção mais ``limpa'' examinando-se os objetos intermediários).

Figura: Aplicação do script recursivo aquiles com profundidade 2. Aplicações para os pares (A,B) = F, (B,F) = j, (F,j) = N.

Atualmente, conhecemos apenas dois programas de GD que permitem scripts recorrentes, o iGeom e o GSP. O uso de recorrência em scripts, nos programas de GD, permite uma elegante introdução ao conceito de algoritmo, sem a necessidade de explicar variáveis ou comandos do tipo ``for''. Além disso, o uso de recorrência agiliza a construção de fractais⁵ geométricos (, ,), com os quais podemos explorar conceitos de progressões geométricas, somatórios e até de convergência. O exemplo , da corrida entre Aquiles e a tartaruga, pode ser utilizado para iniciar tal atividade, seguindo-se de algum exemplo graficamente mais interessante, como o fractal baseado em circunferências apresentado na Figura .

Figura: Exemplo de fractal baseado em circunferências gerado no iGeom