@c Language: Portuguese
@c Source: dynamics.texi (en) 1.10
@menu
* O pacote dynamics::
* Análise gráfica de sistemas dinâmicos discretos::
* Visualização usando VTK::
@end menu

@node O pacote dynamics, Análise gráfica de sistemas dinâmicos discretos, dynamics, dynamics
@section O pacote dynamics

O pacote adicional @code{dynamics} inclui várias
funções para criar diversas
representações gráficas de sistemas dinâmicos e
fractais, para além duma implementaçõ do método
numérico de Runge-Kutta de quarta ordem, para resolver sistemas de
equações diferenciais.

Para usar as funções neste pacote será necessário
primeiro que tudo carregá-lo com @code{load("dynamics")}; as
funções que criam gráficos precisam que o Xmaxima
esteja instalado.

@node Análise gráfica de sistemas dinâmicos discretos, Visualização usando VTK, O pacote dynamics, dynamics
@section Análise gráfica de sistemas dinâmicos discretos

@deffn {Função} chaosgame (@code{[[}@var{x1}, @var{y1}@code{]}...@code{[}@var{xm}, @var{ym}@code{]]}, @code{[}@var{x0}, @var{y0}@code{]}, @var{b}, @var{n}, ...opções...);

Usa o método designado de @emph{jogo do caos}, para produzir fractais:
desenha-se um ponto inicial (@var{x0}, @var{y0}) e logo escolhe-se
aleatoriamente um dos @var{m} pontos @code{[}@var{x1},
@var{y1}@code{]}...@code{[}@var{xm}, @var{ym}@code{]}. A seguir,
desenha-se um novo ponto que estará no segmento entre o último ponto
desenhado e o ponto que se acabou de seleccionar aleatoriamente, a uma
distância do ponto seleccionado que será @var{b} vezes o comprimento
do segmento. O processo repete-se @var{n} vezes.

@end deffn

@deffn {Função} evolution (@var{F}, @var{y0}, @var{n},...opções...);

Desenha @var{n+1} pontos num gráfico bidimensional (série de tempo),
onde as coordenadas horizontais dos pontos são os números inteiros
0, 1, 2, ..., @var{n}, e as coordenadas verticais são os valores
@var{y(n)} correspondentes, obtidos a partir da relação
de recorrência
@ifnottex
@example
        y(n+1) = F(y(n))
@end example
@end ifnottex
@tex
$$y_{n+1} = F(y_n)$$
@end tex

Com valor inicial @var{y(0)} igual a @var{y0}. @var{F} deverá ser uma
expressão que dependa unicamente da variável @var{y} (e não de @var{n}),
@var{y0} deverá ser um número real e @var{n} um número inteiro positivo.

@end deffn

@deffn {Função} evolution2d (@code{[}@var{F}, @var{G}@code{]}, @code{[}@var{x0}, @var{y0}@code{]}, @var{n}, ...opções...);

Mostra, num gráfico bidimensional, os primeiros @var{n+1} pontos da
sucessão definida a partir do sistema dinâmico discreto com
relações de recorrência:
@ifnottex 
@example
        x(n+1) = F(x(n), y(n))    y(n+1) = G(x(n), y(n))
@end example
@end ifnottex
@tex
$$\cases{x_{n+1} = F(x_n, y_n) &\cr y_{n+1} = G(x_n, y_n)}$$
@end tex

Com valores iniciais @var{x0} e @var{y0}. @var{F} e @var{G} deverão
ser duas expressões que dependam unicamente de @var{x} e @var{y}.

@end deffn

@deffn {Função} ifs (@code{[}@var{r1},...,@var{rm}@code{]},@code{[}@var{A1},...,@var{Am}@code{]}, @code{[[}@var{x1},@var{y1}@code{]}...@code{[}@var{xm}, @var{ym}@code{]]}, @code{[}@var{x0},@var{y0}@code{]},
@var{n}, ...opções...);

Usa o método do Sistema de Funções Iteradas (IFS, em
inglês @emph{Iterated Function System}). Esse método é semelhante
ao método descrito na função @code{chaosgame}, mas em
vez de aproximar o último ponto para ponto seleccionado
aleatoriamente, as duas coordenadas do último ponto multiplicam-se por
uma matriz 2 por 2 @var{Ai} correspondente ao ponto que tenha sido
escolhido aleatoriamente.

A selecção aleatória de um dos @var{m} pontos
atractivos pode se realizada com uma função de
probabilidade não uniforme, definida com os pesos
@var{r1},...,@var{rm}. Pesos esses que deverão ser dados em forma
acumulada; por exemplo, se quiser usar 3 pontos com probabilidades
0.2, 0.5 e 0.3, os pesos @var{r1}, @var{r2} e @var{r3} poderiam ser 2, 7
e 10, ou qualquer outro grupo de números que estejam na mesma
proporção.

@end deffn


@deffn {Função} orbits (@var{F}, @var{y0}, @var{n1}, @var{n2}, [@var{x}, @var{x0}, @var{xf}, @var{xstep}], ...opções...);

Desenha o diagrama de órbitas duma família de sistemas
dinâmicos discretos unidimensionais, com um parâmetro @var{x}; esse
tipo de diagrama usa-se para mostrar as bifurcações dum
sistema discreto unidimensional.

A função @var{F(y)} define uma sequência que
começa com um valor inicial @var{y0}, igual que no caso da
função @code{evolution}, mas neste caso a
função também dependerá do parâmetro @var{x}, o
qual terá valores compreendidos no intervalo de @var{x0} a @var{xf},
com incrementos @var{xstep}. Cada valor usado para o parâmetro @var{x}
apresenta-se no eixo horizontal. No eixo vertical apresentam-se @var{n2}
valores da sucessão @var{y(n1+1)},..., @var{y(n1+n2+1)}, obtidos
após deixá-la evoluir durante @var{n1} iterações
iniciais.

@end deffn

@deffn {Função} rk (EDO, var, inicial, dominio)
@deffnx {Função} rk ([EDO1,...,EDOm], [v1,...,vm], [inic1,...,inicm], domínio)

A primeira forma usa-se para resolver numericamente uma
equação diferencial ordinária de primeira ordem (EDO),
e a segunda forma resolve numericamente um sistema de @var{m} dessas
equações, usando o método de Runge-Kutta de quarta
ordem. @var{var} representa a variável dependente.  EDO deverá ser
uma expressão que dependa unicamente das variáveis independente e
dependente, e define a derivada da variável dependente em
função da variável independente.

A variável independente representa-se com @var{domínio},
que deverá ser uma lista com quatro elementos, como, por exemplo:
@example
[t, 0, 10, 0.1]
@end example
o primeiro elemento da lista identifica a variável independente, os
segundo e terceiro elementos são os valores inicial e final para essa
variável, e o último elemento dá o valor dos incrementos que
deverão ser usados dentro desse intervalo.

Se se estiverem a resolver @var{m} equações, deverá
haver @var{m} variáveis dependentes @var{v1}, @var{v2}, ...,
@var{vm}. Os valores iniciais para essas variáveis serão
@var{inic1}, @var{inic2}, ..., @var{inicm}. Continuará existindo
apenas uma variável independente, definida pela lista @var{domain},
tal como no caso anterior. @var{EDO1}, ..., @var{EDOm} são as
expressões que definem as derivadas de cada uma das variáveis
dependentes, em função da variável independente. As
únicas variáveis que podem aparecer em cada uma dessas expressões
são a variável independente e qualquer uma das variáveis
dependentes. É importante que as derivadas @var{EDO1}, ..., @var{EDOm}
sejam colocadas na lista na mesma ordem em que forem agrupadas as
variáveis dependentes; por exemplo, o terceiro elemento da lista
será interpretado como a derivada da terceira variável dependente.

O programa tenta integrar as equações desde o valor
inicial da variável independente, até o valor final, usando
incrementos fixos. Se em algum passo uma das variáveis dependentes
atingir um valor absoluto muito elevado, a integração
será interrompida nesse ponto. O resultado será uma lista com um
número de elementos igual ao número de iterações
realizadas. Cada elemento na lista de resultados é também uma lista
com @var{m}+1 elementos: o valor da variável independente, seguido dos
valores das variáveis dependentes nesse ponto.

@end deffn

@deffn {Função} staircase (@var{F}, @var{y0}, @var{n}, ...opções...);

Desenha um diagrama de degraus (ou diagrama de teia de aranha) para a
sucessão definida pela equação de recorrência
@ifnottex
@example
        y(n+1) = F(y(n))
@end example
@end ifnottex
@tex
$$y_{n+1} = F(y_n)$$
@end tex

A interpretação e valores permitidos dos parâmetros de
entrada é igual que para a função @code{evolution}. Um
diagrama de degraus consiste num gráfico da função
@var{F(y)}, junto com a recta @var{G(y)} @code{=}
@var{y}. Começa-se por desenhar um segmento vertical desde
o ponto (@var{y0}, @var{y0}) na recta, até o ponto de
intersecção com a função @var{F}. A
seguir, desde esse ponto desenha-se um segmento horizontal até o ponto
de intersecção com a recta, (@var{y1}, @var{y1}); o
processo repete-se @var{n} vezes até alcançar o ponto
(@var{yn}, @var{yn}).

@end deffn

@b{Opções}

Cada opção é uma lista com dois ou mais elementos. O
primeiro elemento na lista é o nome da opção e os
restantes são os argumentos para essa opção.

As opções aceites pelas funções
evolution, evolution2, staircase, orbits, ifs e chaosgame são as
seguintes:

@itemize @bullet
@item
@dfn{domain} especifica os valores mínimo y máximo da
variável independente para o gráfico da função @var{F}
representada por @code{staircase}.

@item
@dfn{pointsize} define o raio de cada ponto desenhado, em unidades de
pontos. O valor por omissão é 1.

@item
@dfn{xaxislabel} é o nome que será dado ao eixo horizontal.

@item
@dfn{xcenter} é a coordenada x do ponto que deverá aparecer no
centro do gráfico. Esta opção não é usada pela
função @code{orbits}.

@item
@dfn{xradius} é metade do comprimento do intervalo de valores de x que
serão representados. Esta opção não é usada pela
função @code{orbits}.

@item
@dfn{yaxislabel} é o nome que será dado ao eixo vertical.

@item
@dfn{ycenter} é a coordenada y do ponto que deverá aparecer no
centro do gráfico.

@item
@dfn{yradius} é metade do comprimento do intervalo de valores de y que
serão representados.

@end itemize

As opções aceites pelos programas juli
@b{Exemplos}

Representação gráfica e diagrama de degraus da sequência:
2, cos(2), cos(cos(2)),...

@example
(%i1) load("dynamics")$
(%i2) evolution(cos(y), 2, 11, [yaxislabel, "y"], [xaxislabel,"n"]);
(%i3) staircase(cos(y), 1, 11, [domain, 0, 1.2]);
@end example

@ifnotinfo
@figure{dynamics1}
@figure{dynamics2}
@end ifnotinfo

Se o seu processador for lento, terá que reduzir o número de
iterações usado nos exemplos seguintes. E o valor de
@var{pointsize} que dá os melhores resultados dependerá do monitor e
da resolução usada. Terá que experimentar com
diferentes valores.

Diagrama de órbitas para o mapa quadrático
@ifnottex
@example
        y(n+1) = x + y(n)^2
@end example
@end ifnottex
@tex
$$y_{n+1} = x + y_n^2$$
@end tex

@example
(%i4) orbits(y^2+x, 0, 50, 200, [x, -2, 0.25, 0.01], [pointsize, 0.9]);
@end example

@ifnotinfo
@figure{dynamics3}
@end ifnotinfo

Para ampliar a região à volta da bifurcação na parte de
baixo, perto de x @code{=} -1.25, use o comando:
@example
(%i5) orbits(x+y^2, 0, 100, 400, [x,-1,-1.53,-0.001], [pointsize,0.9],
             [ycenter,-1.2], [yradius,0.4]);
@end example

@ifnotinfo
@figure{dynamics4}
@end ifnotinfo

Evolução dum sistema em duas dimensões, que conduz a
um fractal:

@example
(%i6) f: 0.6*x*(1+2*x)+0.8*y*(x-1)-y^2-0.9$
(%i7) g: 0.1*x*(1-6*x+4*y)+0.1*y*(1+9*y)-0.4$
(%i8) evolution2d([f,g],[-0.5,0],50000,[pointsize,0.7]);
@end example

@ifnotinfo
@figure{dynamics5}
@end ifnotinfo

E uma ampliação de uma pequena região no fractal:

@example
(%i9) evolution2d([f,g],[-0.5,0],300000,[pointsize,0.7], [xcenter,-0.7],
                  [ycenter,-0.3],[xradius,0.1],[yradius,0.1]);
@end example

@ifnotinfo
@figure{dynamics6}
@end ifnotinfo

Um gráfico do triângulo de Sierpinsky, obtido com o jogo do caos:

@example
(%i9) chaosgame([[0, 0], [1, 0], [0.5, sqrt(3)/2]], [0.1, 0.1], 1/2,
                 30000, [pointsize,0.7]);
@end example

@ifnotinfo
@figure{dynamics7}
@end ifnotinfo

O feto de Barnsley, obtido com o Sistema de Funções
Iteradas:

@example
(%i10) a1: matrix([0.85,0.04],[-0.04,0.85])$
(%i11) a2: matrix([0.2,-0.26],[0.23,0.22])$
(%i12) a3: matrix([-0.15,0.28],[0.26,0.24])$
(%i13) a4: matrix([0,0],[0,0.16])$
(%i14) p1: [0,1.6]$
(%i15) p2: [0,1.6]$
(%i16) p3: [0,0.44]$
(%i17) p4: [0,0]$
(%i18) w: [85,92,99,100]$
(%i19) ifs(w,[a1,a2,a3,a4],[p1,p2,p3,p4],[5,0],50000,[pointsize,0.9]);
@end example

@ifnotinfo
@figure{dynamics8}
@end ifnotinfo

Para resolver numericamente a equação diferencial

@ifnottex
@example
          dx/dt = t - x^2
@end example
@end ifnottex
@tex
$${{dx}\over{dt}} = t - x^2$$ 
@end tex

Com valor inicial x(t=0) = 1, no intervalo de t desde 0 até 8, e
com incrementos de 0.1, usa-se:

@example
(%i20) resultados: rk(t-x^2,x,1,[t,0,8,0.1])$
@end example

os resultados ficarão armazenados na lista resultados.

Para resolver numericamente o sistema:

@ifnottex
@example
        dx/dt = 4-x^2-4*y^2     dy/dt = y^2-x^2+1
@end example
@end ifnottex
@tex
$$\cases{{\displaystyle{dx}\over\displaystyle{dt}} = 4-x^2-4y^2 &\cr &\cr {\displaystyle{dy}\over\displaystyle{dt}} = y^2-x^2+1}$$
@end tex

para t entre 0 e 4, com valores iniciais -1.25 e 0.75 para (x, y) em t=0:

@example
(%i21) sol: rk([4-x^2-4*y^2,y^2-x^2+1],[x,y],[-1.25,0.75],[t,0,4,0.02])$
@end example

@node Visualização usando VTK,  , Análise gráfica de sistemas dinâmicos discretos, dynamics
@section Visualização usando VTK

A função scene cria imagens a três dimensões e animações, usando o
software @emph{Visualization ToolKit} (VTK). Para poder usar essa função
é necessário ter Xmaxima e VTK instalados no sistema (incluindo a
libraria para utilizar VTK desde TCL, que pode vir num pacote separado
em alguns sistemas). 
