Merge pull request #48 from AlexEMG/edit-lotkavolterra

Rename Lokta to Lotka

Author: rgommers

ipython/CoupledSpringMassSystem.ipynb

@@ -16,7 +16,7 @@
       "\n",
       "This cookbook example shows how to solve a system of differential\n",
       "equations. (Other examples include the\n",
-      "[Lotka-Volterra Tutorial](LoktaVolterraTutorial.html), the\n",
+      "[Lotka-Volterra Tutorial](LotkaVolterraTutorial.html), the\n",
       "[Zombie Apocalypse](Zombie_Apocalypse_ODEINT.html) and the\n",
       "[KdV example](KdV.html).)\n",
       "\n",

ipython/LoktaVolterraTutorial.ipynb renamed to ipython/LotkaVolterraTutorial.ipynb

@@ -6,14 +6,14 @@
    "source": [
     "# Matplotlib: lotka volterra tutorial\n",
     "\n",
-    "1.  1.  page was renamed from LoktaVolterraTutorial\n",
+    "1.  1.  page was renamed from LotkaVolterraTutorial\n",
     "\n",
     "This example describes how to integrate ODEs with the scipy.integrate\n",
     "module, and how to use the matplotlib module to plot trajectories,\n",
     "direction fields and other information.\n",
     "\n",
     "You can get the source code for this tutorial here:\n",
-    "[tutorial_lokta-voltera_v4.py](files/attachments/LoktaVolterraTutorial/tutorial_lokta-voltera_v4.py).\n",
+    "[tutorial_lotka-voltera_v4.py](files/attachments/LotkaVolterraTutorial/tutorial_lotka-voltera_v4.py).\n",
     "\n",
     "Presentation of the Lotka-Volterra Model\n",
     "----------------------------------------\n",
@@ -254,7 +254,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "![](files/attachments/LoktaVolterraTutorial/rabbits_and_foxes_1v2.png)\n",
+    "![](files/attachments/LotkaVolterraTutorial/rabbits_and_foxes_1v2.png)\n",
     "\n",
     "The populations are indeed periodic, and their period is close to the\n",
     "value T\\_f1 that we computed.\n",
@@ -326,7 +326,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "![](files/attachments/LoktaVolterraTutorial/rabbits_and_foxes_2v3.png)\n",
+    "![](files/attachments/LotkaVolterraTutorial/rabbits_and_foxes_2v3.png)\n",
     "\n",
     "This graph shows us that changing either the fox or the rabbit\n",
     "population can have an unintuitive effect. If, in order to decrease the\n",
@@ -409,7 +409,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "![](files/attachments/LoktaVolterraTutorial/rabbits_and_foxes_3v2.png)"
+    "![](files/attachments/LotkaVolterraTutorial/rabbits_and_foxes_3v2.png)"
    ]
   }
  ],

ipython/attachments/LoktaVolterraTutorial/rabbits_and_foxes_1.png renamed to ipython/attachments/LotkaVolterraTutorial/rabbits_and_foxes_1.png

@@ -1,79 +1,79 @@
 # This example describe how to integrate ODEs with scipy.integrate module and how
 # to use the matplotlib module to plot trajectories, directions field and others
 # useful informations.
-# 
-# == Presentation of the Lokta-Volterra Model ==
-# 
-# 
-# We will have a look at the Lokta-Volterra model, laso known as the
+#
+# == Presentation of the Lotka-Volterra Model ==
+#
+#
+# We will have a look at the Lotka-Volterra model, laso known as the
 # predator-prey equations, re a pair of first order, non-linear, differential
 # equations frequently used to describe the dynamics of biological systems in
 # which two species interact, one a predator and one its prey. They were proposed
 # independently by Alfred J. Lotka in 1925 and Vito Volterra in 1926 :
 # du/dt =  a*u -   b*u*v
-# dv/dt = -c*v + d*b*u*v 
-# 
+# dv/dt = -c*v + d*b*u*v
+#
 # with the following notations :
-# 
+#
 # *  u : number of prey (for example rabbits)
-# 
-# *  v : number of predators (for example foxes)  
-#   
-# * a, b, c, d are constant parameters defining the behavior of the population :    
-# 
+#
+# *  v : number of predators (for example foxes)
+#
+# * a, b, c, d are constant parameters defining the behavior of the population :
+#
 #   + a is the natural growing rate of rabbits, when there's no foxes
-# 
+#
 #   + b is the natural dying rate of rabbits, due to predation
-# 
+#
 #   + c is the natural dying rate of foxes, when there's no rabbits
-# 
+#
 #   + d is the factor descibing how many catched rabbits let create new rabbits
-# 
-# 
+#
+#
 # We will use X=[u, v] to describe the state of both populations.
 # Definition of the equations:
-# 
+#
 from numpy import *
 import pylab as p
 
-# Parameters 
+# Parameters
 a = 1.
 b = 0.1
 c = 1.5
 d = 0.75
 
 def dX_dt(X, t=0):
     """ Return the growth rate of foxes and rabbits populations. """
-    return array([ a*X[0] -   b*X[0]*X[1] ,  
+    return array([ a*X[0] -   b*X[0]*X[1] ,
                   -c*X[1] + d*b*X[0]*X[1] ])
-# 
+#
 # === Population equilibrium ===
-# 
-# Before using scipy to integrate this system, we will have a closer look on 
+#
+# Before using scipy to integrate this system, we will have a closer look on
 # position equilibrium. Equilibrium occurs when the growth rate is equal to 0.
 # This gives two fixed points:
-# 
+#
 X_f0 = array([0., 0.])
 X_f1 = array([ c/(d*b), a/b])
-all(dX_dt(X_f0) == zeros(2) ) and all(dX_dt(X_f1) == zeros(2)) # => True 
-# 
+all(dX_dt(X_f0) == zeros(2) ) and all(dX_dt(X_f1) == zeros(2)) # => True
+#
 # === Stability of the fixed points ===
 # Near theses two points, the system can be linearized :
 # dX_dt = A_f*X where A is the Jacobian matrix evaluated at the corresponding point.
 # We have to define the Jacobian matrix:
-# 
+#
 def d2X_dt2(X, t=0):
     """ Return the jacobian matrix evaluated in X. """
     return array([[a -b*X[1],   -b*X[0]     ],
-                  [b*d*X[1] ,   -c +b*d*X[0]] ])  
-# 
+                  [b*d*X[1] ,   -c +b*d*X[0]] ])
+#
 # So, near X_f0, which represents the extinction of both species, we have:
 # A_f0 = d2X_dt2(X_f0)                    # >>> array([[ 1. , -0. ],
 #                                         #            [ 0. , -1.5]])
-# 
+#
 # Near X_f0, the number of rabbits increase and the population of foxes decrease.
 # X_f0 is a [http://en.wikipedia.org/wiki/Saddle_point saddle point].
-# 
+#
 # Near X_f1, we have :
 A_f1 = d2X_dt2(X_f1)                    # >>> array([[ 0.  , -2.  ],
                                         #            [ 0.75,  0.  ]])
@@ -84,25 +84,25 @@ def d2X_dt2(X, t=0):
 # They are imaginary number, so the fox and rabbit populations are periodic and
 # their period is given by :
 T_f1 = 2*pi/abs(lambda1)                # >>> 5.130199
-#         
+#
 # == Integrating the ODE using scipy.integate ==
-# 
+#
 # Now we will use the scipy.integrate module to integrate the ODE.
 # This module offers a  method named odeint, very easy to use to integrade ODE:
-# 
+#
 from scipy import integrate
 
 t = linspace(0, 15,  1000)              # time
-X0 = array([10, 5])                     # initials conditions: 10 rabbits and 5 foxes  
+X0 = array([10, 5])                     # initials conditions: 10 rabbits and 5 foxes
 
 X, infodict = integrate.odeint(dX_dt, X0, t, full_output=True)
 infodict['message']                     # >>> 'Integration successful.'
-# 
+#
 # `infodict` is optionnal, and you can omit the `full_output` argument if you don't want it.
 # type "info(odeint)" if you want more information about odeint inputs and outputs.
-# 
+#
 # We will use matplotlib to plot the evolution of both populations:
-# 
+#
 rabbits, foxes = X.T
 
 f1 = p.figure()
@@ -114,46 +114,46 @@ def d2X_dt2(X, t=0):
 p.ylabel('population')
 p.title('Evolution of fox and rabbit populations')
 f1.savefig('rabbits_and_foxes_1.png')
-# 
-# 
+#
+#
 # The populations are indeed periodic, and their period is near to the T_f1 we calculated.
-# 
+#
 # == Plotting directions field and trajectories in the phase plane ==
-# 
+#
 # We will plot some trajectories in a phase plane for different starting
 # points between X__f0 and X_f1.
-# 
+#
 # We will ue matplotlib's colormap to define colors for the trajectories.
 # These colormaps are very useful to make nice plots.
 # Have a look on ShowColormaps if you want more information.
-# 
+#
 values = linspace(0.3, 0.9, 5)                          # position of X0 between X_f0 and X_f1
 vcolors = p.cm.Greens(linspace(0.3, 1., len(values)))   # colors for each trajectory
 
 f2 = p.figure()
 
 #-------------------------------------------------------
 # plot trajectories
-for v, col in zip(values, vcolors): 
+for v, col in zip(values, vcolors):
     X0 = v * X_f1                               # starting point
     X = integrate.odeint( dX_dt, X0, t)         # we don't need infodict here
     p.plot( X[:,0], X[:,1], lw=3.5*v, color=col, label='X0=(%.f, %.f)' % ( X0[0], X0[1]) )
 
 #-------------------------------------------------------
 # define a grid and compute direction at each point
 ymax = p.ylim(ymin=0)[1]                        # get axis limits
-xmax = p.xlim(xmin=0)[1] 
-nb_points   = 20                      
+xmax = p.xlim(xmin=0)[1]
+nb_points   = 20
 
 x = linspace(0, xmax, nb_points)
 y = linspace(0, ymax, nb_points)
 
 X1 , Y1  = meshgrid(x, y)                       # create a grid
 DX1, DY1 = dX_dt([X1, Y1])                      # compute growth rate on the gridt
-M = (hypot(DX1, DY1))                           # Norm of the growth rate 
-M[ M == 0] = 1.                                 # Avoid zero division errors 
+M = (hypot(DX1, DY1))                           # Norm of the growth rate
+M[ M == 0] = 1.                                 # Avoid zero division errors
 DX1 /= M                                        # Normalize each arrows
-DY1 /= M                                  
+DY1 /= M
 
 #-------------------------------------------------------
 # Drow direction fields, using matplotlib 's quiver function
@@ -168,18 +168,18 @@ def d2X_dt2(X, t=0):
 p.xlim(0, xmax)
 p.ylim(0, ymax)
 f2.savefig('rabbits_and_foxes_2.png')
-# 
-# 
+#
+#
 # We can see on this graph that an intervention on fox or rabbit populations can
 # have non intuitive effects. If, in order to decrease the number of rabbits,
 # we introduce foxes, this can lead to an increase of rabbits in the long run,
 # if that intervention happens at a bad moment.
-# 
-# 
+#
+#
 # == Plotting contours ==
-# 
+#
 # We can verify that the fonction IF defined below remains constant along a trajectory:
-# 
+#
 def IF(X):
     u, v = X
     return u**(c/a) * v * exp( -(b/a)*(d*u+v) )
@@ -189,9 +189,9 @@ def IF2(X):
     return u**(c/a) * v * exp( -(b/a)*(d*u+v) )
 
 # We will verify that IF remains constant for differents trajectories
-for v in values: 
+for v in values:
     X0 = v * X_f1                               # starting point
-    X = integrate.odeint( dX_dt, X0, t)         
+    X = integrate.odeint( dX_dt, X0, t)
     I = IF(X.T)                                 # compute IF along the trajectory
     I_mean = I.mean()
     delta = 100 * (I.max()-I.min())/I_mean
@@ -202,15 +202,15 @@ def IF2(X):
 #     X0=(12, 6) => I ~ 55.7 |delta = 1.82E-05 %
 #     X0=(15, 8) => I ~ 66.8 |delta = 1.12E-05 %
 #     X0=(18, 9) => I ~ 72.4 |delta = 4.68E-06 %
-# 
+#
 # Potting iso-contours of IF can be a good representation of trajectories,
 # without having to integrate the ODE
-# 
+#
 #-------------------------------------------------------
 # plot iso contours
-nb_points = 80                              # grid size 
+nb_points = 80                              # grid size
 
-x = linspace(0, xmax, nb_points)    
+x = linspace(0, xmax, nb_points)
 y = linspace(0, ymax, nb_points)
 
 X2 , Y2  = meshgrid(x, y)                   # create the grid
@@ -228,6 +228,6 @@ def IF2(X):
 p.title('IF contours')
 f3.savefig('rabbits_and_foxes_3.png')
 p.show()
-# 
-# 
+#
+#
 # # vim: set et sts=4 sw=4: