@c English version: 2011-06-11
@menu
* Introducción a drawdf::
* Funciones y variables para drawdf::
@end menu

@node Introducción a drawdf, Funciones y variables para drawdf, drawdf, drawdf
@section Introducción a drawdf

La función @code{drawdf} dibuja el campo de direcciones de una ecuación
diferencial ordinaria de primer orden (EDO) o de un sistema de dos ecuaciones
autónomas de primer orden.

Puesto que @code{drawdf} es un paquete adicional, es necesario cargarlo en
memoria ejecutando previamente la instrucción @code{load(drawdf)}.
@code{drawdf} utiliza el paquete @code{draw}, que necesita como 
mínimo la versión 4.2 de Gnuplot.

Para dibujar el campo de direcciones de una EDO, ésta debe escribirse de la
forma
@ifnottex
@example
       dy
       -- = F(x,y)
       dx
@end example
@end ifnottex
@tex
$${{dy}\over{dx}} = F(x,y)$$
@end tex

y ser la función @var{F} la que se pase a @code{drawdf} como argumento.
Si las variables independiente y dependiente no son @var{x} e @var{y},
como en la ecuación anterior, entonces deben nombrarse de forma
explícita en una lista que se pasará a @code{drawdf}
(ver ejemplos más abajo).

Para dibujar el campo de direcciones de un conjunto de dos EDOs autónomas,
deben escribirse de la forma
@ifnottex
@example
       dx             dy
       -- = G(x,y)    -- = F(x,y) 
       dt             dt
@end example
@end ifnottex
@tex
$${{dx}\over{dt}} = G(x,y) \qquad {{dy}\over{dt}} = F(x,y)$$
@end tex

y será una lista con las dos funciones @var{G} y @var{F} la que
se pase a @code{drawdf} como argumento. El orden de las funciones es
importante; la primera será la derivada de la abscisa respecto del tiempo
y la segunda la derivada de la ordenada respecto del tiempo.
Si las variables no son las @var{x} e @var{y} habituales, el segundo
argumento que se pase a la función @code{drawdf} será una lista
con los nombres de ambas variables, primero la correspondiente a las
abscisas, seguida de la asociada a las ordenadas.

Si sólo se trata de una EDO, @code{drawdf} admitirá por defecto
que @code{x=t} y @code{G(x,y)=1}, transformanado la ecuación no
autónoma en un sistema de dos ecuaciones autónomas.




@node Funciones y variables para drawdf,  , Introducción a drawdf, drawdf
@section Funciones y variables para drawdf

@subsection Funciones

@deffn {Función} drawdf (@var{dydx}, ...options and objects...)
@deffnx {Función} drawdf (@var{dvdu}, @code{[}@var{u},@var{v}@code{]}, ...opciones y objetos...)
@deffnx {Función} drawdf (@var{dvdu}, @code{[}@var{u},@var{umin},@var{umax}@code{]}, @code{[}@var{v},@var{vmin},@var{vmax}@code{]}, ...opciones y objetos...)
@deffnx {Función} drawdf (@code{[}@var{dxdt},@var{dydt}@code{]}, ...opciones y objetos...)
@deffnx {Función} drawdf (@code{[}@var{dudt},@var{dvdt}@code{]}, @code{[}@var{u},@var{v}@code{]}, ...opciones y objetos...)
@deffnx {Función} drawdf (@code{[}@var{dudt},@var{dvdt}@code{]}, @code{[}@var{u},@var{umin},@var{umax}@code{]}, @code{[}@var{v},@var{vmin},@var{vmax}@code{]}, ...opciones y objetos...)

La función @code{drawdf} dibuja un campo de direcciones 2D, incluyendo
opcionalmente curvas asociadas a soluciones particulares, así
como otros objeto gráficos del paquete @code{draw}.

El primer argumento especifica la(s) derivada(s), el cual debe estar
formado por una expresión o una lista de dos expresiones. @var{dydx}, @var{dxdt} y
@var{dydt} son expresiones que dependen de @var{x} y @var{y}.
@var{dvdu}, @var{dudt} y @var{dvdt} son expresiones que dependen de
@var{u} y @var{v}.

Si las variables independiente y dependiente no son @var{x} e @var{y},
sus nombres deben especificarse a continuación de las derivadas,
bien como una lista de dos nombres,
@code{[}@var{u},@var{v}@code{]}, o como dos listas de la forma
@code{[}@var{u},@var{umin},@var{umax}@code{]} y
@code{[}@var{v},@var{vmin},@var{vmax}@code{]}.

El resto de argumentos son @i{opciones gráficas}, @i{objetos gráficos},
o listas conteniendo elementos de ambos tipos. El conjunto de opciones y
objetos gráficos soportados por @code{drawdf} incluye los soportados
por @code{draw2d} y @code{gr2d} del paquete @code{draw}.

Los argumentos se iterpretan secuencialmente: las @i{opciones gráficas}
afectan a todos los @i{objetos gráficos} que le siguen. Además,
los @i{objetos gráficos} se dibujan en el orden en el que se
especifican, pudiendo tapar otros gráficos dibujados con anterioridad.
Algunas @i{opciones gráficas} afectan al aspecto general de la escena.

Los nuevos @i{objetos gráficos} que se definen en @code{drawdf} son:
@code{solns_at}, @code{points_at}, @code{saddles_at}, @code{soln_at},
@code{point_at} y @code{saddle_at}.

Las nuevas @i{opciones gráficas} que se definen en @code{drawdf} son:
@code{field_degree}, @code{soln_arrows}, @code{field_arrows},
@code{field_grid}, @code{field_color}, @code{show_field},
@code{tstep}, @code{nsteps}, @code{duration}, @code{direction},
@code{field_tstep}, @code{field_nsteps} y @code{field_duration}.

@i{Objetos gráficos} que se heredan del paquete @code{draw} incluyen:
@code{explicit}, @code{implicit}, @code{parametric},
@code{polygon}, @code{points}, @code{vector}, @code{label} y cualesquiera
otros soportados por @code{draw2d} y @code{gr2d}.

@i{Opciones gráficas} que se heredan del paquete @code{draw} incluyen:
@code{points_joined}, @code{color},
@code{point_type}, @code{point_size}, @code{line_width},
@code{line_type}, @code{key}, @code{title}, @code{xlabel},
@code{ylabel}, @code{user_preamble}, @code{terminal},
@code{dimensions}, @code{file_name} y cualesquiera
otros soportados por @code{draw2d} y @code{gr2d}.

Véase también @code{draw2d}. 

Los usuarios de wxMaxima y Imaxima pueden hacer uso también @code{wxdrawdf},
que es idéntica a @code{drawdf}, pero que inserta el gráfico en el 
propio documento utilizando la función @code{wxdraw}.

Para hacer uso de esta función, ejecútese primero @code{load(drawdf)}.

Ejemplos:

@example
(%i1) load(drawdf)$
(%i2) drawdf(exp(-x)+y)$        /* default vars: x,y */
(%i3) drawdf(exp(-t)+y, [t,y])$ /* default range: [-10,10] */
(%i4) drawdf([y,-9*sin(x)-y/5], [x,1,5], [y,-2,2])$
@end example

A efectos de compatibilidad, @code{drawdf} acepta la mayor
parte de parámetros soportados por @code{plotdf}.

@example
(%i5) drawdf(2*cos(t)-1+y, [t,y], [t,-5,10], [y,-4,9],
             [trajectory_at,0,0])$
@end example

@code{soln_at} y @code{solns_at} dibujan soluciones particulares
que pasen por los puntos especificados, utilizando el integrador
numérico de Runge Kutta de cuarto orden.

@example
(%i6) drawdf(2*cos(t)-1+y, [t,-5,10], [y,-4,9],
             solns_at([0,0.1],[0,-0.1]),
             color=blue, soln_at(0,0))$
@end example

@code{field_degree=2} hace que el campo se componga de @i{splines}
cuadráticos basados en las derivadas de primer y segundo orden en
cada punto de la malla. 
@code{field_grid=[}@var{COLS},@var{ROWS}@code{]} 
especifica el número de columnas y filas a utilizar en la malla.

@example
(%i7) drawdf(2*cos(t)-1+y, [t,-5,10], [y,-4,9],
             field_degree=2, field_grid=[20,15],
             solns_at([0,0.1],[0,-0.1]),
             color=blue, soln_at(0,0))$
@end example

@code{soln_arrows=true} añade flechas a las soluciones particulares y,
por defecto, las borra. También cambia los colores por defecto para 
destacar las curvas de las soluciones particulares.

@example
(%i8) drawdf(2*cos(t)-1+y, [t,-5,10], [y,-4,9],
             soln_arrows=true,
             solns_at([0,0.1],[0,-0.1],[0,0]))$
@end example

@code{duration=40} especifica el intervalo temporal de la integración
numérica, cuyo valor por defecto es 10. La integración se detendrá
automáticamente si la solución se aparta mucho de la región a dibujar,
o si la derivada se vuelve compleja o infinita. Aquí también
hacemos @code{field_degree=2} para dibujar @i{splines} cuadráticos. Las
ecuaciones de este ejemplo modelizan un sistema depredador-presa.

@example
(%i9) drawdf([x*(1-x-y), y*(3/4-y-x/2)], [x,0,1.1], [y,0,1],
             field_degree=2, duration=40,
             soln_arrows=true, point_at(1/2,1/2),
             solns_at([0.1,0.2], [0.2,0.1], [1,0.8], [0.8,1],
                      [0.1,0.1], [0.6,0.05], [0.05,0.4],
                      [1,0.01], [0.01,0.75]))$
@end example

@code{field_degree='solns} hace que el campo se componga de muchas
pequeñas soluciones calculadas a partir del Runge Kutta
de cuarto orden.

@example
(%i10) drawdf([x*(1-x-y), y*(3/4-y-x/2)], [x,0,1.1], [y,0,1],
              field_degree='solns, duration=40,
              soln_arrows=true, point_at(1/2,1/2),
              solns_at([0.1,0.2], [0.2,0.1], [1,0.8],
                       [0.8,1], [0.1,0.1], [0.6,0.05],
                       [0.05,0.4], [1,0.01], [0.01,0.75]))$
@end example

@code{saddles_at} trata de linearizar automáticamente la ecuación
en cada punto de silla y dibujar la solución numérica correspondiente
a cada vector propio, incluyendo las separatrices. @code{tstep=0.05} establece
el salto temporal máximo para el integrador numérico, cuyo valor por
defecto es 0.1. Las siguientes ecuaciones modelizan un péndulo amortiguado.

@example
(%i11) drawdf([y,-9*sin(x)-y/5], tstep=0.05,
              soln_arrows=true, point_size=0.5,
              points_at([0,0], [2*%pi,0], [-2*%pi,0]),
              field_degree='solns,
              saddles_at([%pi,0], [-%pi,0]))$
@end example

@code{show_field=false} elimina el campo completamente.

@example
(%i12) drawdf([y,-9*sin(x)-y/5], tstep=0.05,
              show_field=false, soln_arrows=true,
              point_size=0.5,
              points_at([0,0], [2*%pi,0], [-2*%pi,0]),
              saddles_at([3*%pi,0], [-3*%pi,0],
                         [%pi,0], [-%pi,0]))$
@end example

@code{drawdf} pasa todos los parámetros que no reconoce a @code{draw2d}
o @code{gr2d}, permitiendo combinar la potencia del paquete @code{draw}
con @code{drawdf}.

@example
(%i13) drawdf(x^2+y^2, [x,-2,2], [y,-2,2], field_color=gray,
              key="soln 1", color=black, soln_at(0,0),
              key="soln 2", color=red, soln_at(0,1),
              key="isocline", color=green, line_width=2,
              nticks=100, parametric(cos(t),sin(t),t,0,2*%pi))$
@end example

@code{drawdf} acepta listas anidadas de opciones y objetos gráficos,
permitiendo el uso de @code{makelist} y otras funciones de forma más
flexible para generar gráficos.

@example
(%i14) colors : ['red,'blue,'purple,'orange,'green]$
(%i15) drawdf([x-x*y/2, (x*y - 3*y)/4],
              [x,2.5,3.5], [y,1.5,2.5],
              field_color = gray,
              makelist([ key   = concat("soln",k),
                         color = colors[k],
                         soln_at(3, 2 + k/20) ],
                       k,1,5))$
@end example

@end deffn


