Introduction to drawdf
======================

The function drawdf draws the direction field of a first-order Ordinary Differential Equation (ODE) or a system of two autonomous first-order ODE's.

Since this is an additional package, in order to use it you must first load it with load("drawdf").  Drawdf is built upon the draw package, which requires Gnuplot 4.2.

To plot the direction field of a single ODE, the ODE must be written in the form:

            dy
            -- = F(x,y)
            dx

and the function F should be given as the argument for drawdf. If the independent and dependent variables are not X, and Y, as in the equation above, then those two variables should be named explicitly in a list given as an argument to the drawdf command (see the examples).

To plot the direction field of a set of two autonomous ODE's, they must be written in the form

            dx             dy
            -- = G(x,y)    -- = F(x,y)
            dt             dt

and the argument for drawdf should be a list with the two functions G and F, in that order; namely, the first expression in the list will be taken to be the time derivative of the variable represented on the horizontal axis, and the second expression will be the time derivative of the variable represented on the vertical axis. Those two variables do not have to be X and Y, but if they are not, then the second argument given to drawdf must be another list naming the two variables, first the one on the horizontal axis and then the one on the vertical axis.

If only one ODE is given, drawdf will implicitly admit x=t, and G(x,y)=1, transforming the non-autonomous equation into a system of two autonomous equations.

Categories: Differential equations Plotting Share packages Package drawdf Package draw

Functions and Variables for drawdf
==================================

Functions
---------

 -- Function: drawdf
     drawdf (DYDX, ...options and objects...)
     drawdf (DVDU, [U,V], ...options and objects...)
     drawdf (DVDU, [U,UMIN,UMAX], [V,VMIN,VMAX], ...options and objects...)
     drawdf ([DXDT,DYDT], ...options and objects...)
     drawdf ([DUDT,DVDT], [U,V], ...options and objects...)
     drawdf ([DUDT,DVDT], [U,UMIN,UMAX], [V,VMIN,VMAX], ...options and objects...)

     Function drawdf draws a 2D direction field with optional solution curves and other graphics using the draw package.

     The first argument specifies the derivative(s), and must be either an expression or a list of two expressions.  DYDX, DXDT and DYDT are expressions that depend on X and Y. DVDU, DUDT and DVDT are expressions that depend on U and V.

     If the independent and dependent variables are not X and Y, then their names must be specified immediately following the derivative(s), either as a list of two names [U,V], or as two lists of the form [U,UMIN,UMAX] and [V,VMIN,VMAX].

     The remaining arguments are graphic options, graphic objects, or lists containing graphic options and objects, nested to arbitrary depth.  The set of graphic options and objects supported by drawdf is a superset of those supported by draw2d and gr2d from the draw package.

     The arguments are interpreted sequentially: graphic options affect all following graphic objects.  Furthermore, graphic objects are drawn on the canvas in order specified, and may obscure graphics drawn earlier.  Some graphic options affect the global appearance of the scene.

     The additional graphic objects supported by drawdf include: solns_at, points_at, saddles_at, soln_at, point_at, and saddle_at.

     The additional graphic options supported by drawdf include: field_degree, soln_arrows, field_arrows, field_grid, field_color, show_field, tstep, nsteps, duration, direction, field_tstep, field_nsteps, and field_duration.

     Commonly used graphic objects inherited from the draw package include: explicit, implicit, parametric, polygon, points, vector, label, and all others supported by draw2d and gr2d.

     Commonly used graphic options inherited from the draw package include:

     points_joined, color, point_type, point_size, line_width, line_type, key, title, xlabel, ylabel, user_preamble, terminal, dimensions, file_name, and all others supported by draw2d and gr2d.

     See also draw2d rk desolve and ode2

     Users of wxMaxima or Imaxima may optionally use wxdrawdf, which is identical to drawdf except that the graphics are drawn within the notebook using wxdraw.

     To make use of this function, write first load("drawdf").

     Examples:

          (%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])$

     For backward compatibility, drawdf accepts most of the parameters supported by plotdf.

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

     soln_at and solns_at draw solution curves passing through the specified points, using a slightly enhanced 4th-order Runge Kutta numerical integrator.

          (%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))$

     field_degree=2 causes the field to be composed of quadratic splines, based on the first and second derivatives at each grid point. field_grid=[COLS,ROWS] specifies the number of columns and rows in the grid.

          (%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))$

     soln_arrows=true adds arrows to the solution curves, and (by default) removes them from the direction field.  It also changes the default colors to emphasize the solution curves.

          (%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]))$

     duration=40 specifies the time duration of numerical integration (default 10).  Integration will also stop automatically if the solution moves too far away from the plotted region, or if the derivative becomes complex or infinite.  Here we also specify field_degree=2 to plot quadratic splines.  The equations below model a predator-prey system.

          (%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]))$

     field_degree='solns causes the field to be composed of many small solution curves computed by 4th-order Runge Kutta, with better results in this case.

          (%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]))$

     saddles_at attempts to automatically linearize the equation at each saddle, and to plot a numerical solution corresponding to each eigenvector, including the separatrices.  tstep=0.05 specifies the maximum time step for the numerical integrator (the default is 0.1).  Note that smaller time steps will sometimes be used in order to keep the x and y steps small.  The equations below model a damped pendulum.

          (%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]))$

     show_field=false suppresses the field entirely.

          (%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]))$

     drawdf passes all unrecognized parameters to draw2d or gr2d, allowing you to combine the full power of the draw package with drawdf.

          (%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))$

     drawdf accepts nested lists of graphic options and objects, allowing convenient use of makelist and other function calls to generate graphics.

          (%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))$

     Categories: Package drawdf