Mathilde Meriem Lou.ipynb

Kernel: SageMath 9.7

$$x=cste \newline \frac{dx}{dt}=\alpha x-A(x) \newline \frac{dx}{dt}=(\alpha - A)x \newline \frac{1}{x} dx = (\alpha - A)dt \newline ln(x)=(\alpha - A)t+K \newline donc : \newline x=e^{(\alpha - A)t+K}$$

Problématique : Plan de lutte contre un espèce invasive les lapins en Australie

Utilisation du modèle proie- prédateur; on décide de lutter contre cette espèce invasive en important de renards en Australie

On prendra aussi en compte les paramètres anthropique de la chasse

Variables : suites ? nombres de prédateurs, traces des prédateurs (et pareil pour proie)

Limites/hypothèses :

1. On suppose que les prédateurs ne mangent que cette proie

2. La proie a de la nourriture en abondance (mange bien, se reproduit bien)

(facteur de mortalité)

Expressions : équation différentielle pour le prédateur & pour la proie

Equation proie :

$$\frac{dx(t)}{dt}=x(t)(\alpha-\beta y(t))$$

# avec x(t) l'effectif des proies en fonction du temps      => premiere variable
# y(t) l'efffectif des prédateurs en fonction du temps      => deuxième variable
#on prend t comme une constante (on étudie à un instant t)
# dx(t)/dt et dy(t)/dt = variation des populations au cours du temps
# alpha le taux de reproduction des proies (constante et indépendant de y)
# beta le taux de mortalité dû aux prédateurs
# gamma le taux de mortalité intraseque des prédateurs (constante)

Equation prédateur :

$$\frac{dy(t)}{dt}=y(t)(dx(t)-\gamma)$$

Résolution analytique

:

alpha, gamma, bêta, constants

#Solution générale


#x,y = var('x y t')

#solve([])

t = var('t')    # define a variable t
x = function('x')(t)
y = function('y')(t)

DE = diff(x, t) - x*(1-y)
desolve(DE, [x,t])

_C*e^(t - integrate(y(t), t))

#y constant
t,a,alpha = var('t a alpha')    # define a variable t
x = function('x')(t)
assume(a>0),assume(alpha>0)
DE_2 = diff(x, t) -alpha*x+a*x
k=desolve(DE_2, [x,t],show_method=True)
k

[_C*e^(-(a - alpha)*t), 'linear']

#x constant
t,c,gamma = var('t c gamma')    # define a variable t
y = function('y')(t)
assume(c>0),assume(gamma>0)
DE= diff(y, t) -c*y+gamma*y
q=desolve(DE, [y,t],show_method=True)
q

[_C*e^((c - gamma)*t), 'linear']

#Graphe analytique

#desolve_odeint( [ x, -x ], [ 1, 1], srange(0,1,.1), [ y, z ] )
x,y = var('x y')

a=1
b=0.1
c=1.5
d=0.75
#f=[x+a*x,y+2*y]
f=[a*x+b*x,c*y+d*y]

sol=desolve_odeint(f,[50,50],srange(0,30,0.1),[x,y]) #[50,50]=conditions initiales de proies et prédateurs
sol
p=line(zip(sol[:,0],sol[:,1]))
p.show()

#Lapins additionnels

#abcd= paramètres qui décrivent l'évolution des populations
#a= taux de croissance naturel  de la proie en l'abscence de prédateur
#b= taux de mortalité de la proie en présence de prédateur
#c= taux de mortalité  naturel du prédateur en l'absence de proie
#d= taux de croissance du prédateur en fonction du nombre de proies mangées

#Ce qu'on importe et définit :
import scipy; from scipy import integrate
import numpy as np
import matplotlib.pyplot as plt

a, b, c, d = 1., 0.1, 1.5, 0.75

#Définition de l'équation différentielle :
def dX_dt(X, t=0): # Renvoie l'augmentation des populations
    return [ a*X[0] - b*X[0]*X[1] ,
            -c*X[1] + d*b*X[0]*X[1] ]

# Définition de l'échelle de temps
t = srange(0, 24,0.1)

#Conditions initiales :
X0 = [10, 5] #10 lapins et 5 renards

lapins,renards = X.T # raccourcis de X.transpose()


#Résolution numérique
X = integrate.odeint(dX_dt, X0, t)


plt.plot(t,X), plt.xlabel("le temps"), plt.ylabel("population"), plt.grid(True), plt.title('Evolution des populations de renards et lapins au cours du temps')

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
/tmp/ipykernel_914/4075337158.py in <cell line: 20>()
     18 
     19 # Définition de l'échelle de temps
---> 20 t = srange(0, 24,0.1)
     21 
     22 #Conditions initiales :
NameError: name 'srange' is not defined

#étude de cas : https://www.facco.fr/chiffres-cles/les-chiffres-de-la-population-animale/

#abcd= paramètres qui décrivent l'évolution des populations
#a= taux de croissance naturel  de la proie en l'abscence de prédateur
#b= taux de mortalité de la proie en présence de prédateur
#c= taux de mortalité  naturel du prédateur en l'absence de proie
#d= taux de croissance du prédateur en fonction du nombre de proies mangées

#Ce qu'on importe et définit :
import scipy; from scipy import integrate
import numpy as np
import matplotlib.pyplot as plt

a, b, c, d = 1, 0.1, 1, 0.75



#Définition de l'équation différentielle :
def dX_dt(X, t=0): # Renvoie l'augmentation des populations
    return [ a*X[0] - b*X[0]*X[1] ,
            -c*X[1] + d*b*X[0]*X[1] ]

# Définition de l'échelle de temps
t = srange(0, 30,0.1)#en mois

#Conditions initiales :
X0 = [30,15] #nombre initial de lapins et de renards en 10^2 millions d'habitants

lapins,renards = X.T # raccourcis de X.transpose()

#Résolution numérique
X = integrate.odeint(dX_dt, X0, t)


plt.plot(t,X), plt.xlabel("temps( en mois) "), plt.ylabel("population (10^1 millions d'habitants)"), plt.grid(True), plt.title('Evolution des populations de renards et lapins au cours du temps')


list_plot(X, plotjoined=true, color='green', axes_labels=["Proies","Prédateurs"])

Problématique: Invasion de lapin en Australie
300 millions de lapin aujourd'hui
Solution importer des renards.
perturbation du système en enlevant 30% à chaque fois/ système à l'équilibre?

#ajout du paramètre de chasse
#abcd= paramètres qui décrivent l'évolution des populations
#a= taux de croissance naturel  de la proie en l'abscence de prédateur
#b= taux de mortalité de la proie en présence de prédateur
#c= taux de mortalité  naturel du prédateur en l'absence de proie
#d= taux de croissance du prédateur en fonction du nombre de proies mangées
#e= taux de nombre de proies chassée
#f= taux de nombre de prédateur chassées

#Ce qu'on importe et définit :
import scipy; from scipy import integrate
import numpy as np
import matplotlib.pyplot as plt

a1, b1, c1, d1, e1, f1  = 1., 0.1, 1, 0.75, 0, 3


#Définition de l'équation différentielle :
def dX_dt(X, t=0): # Renvoie l'augmentation des populations
    return [ a1*X[0] - b1*X[0]*X[1]-e1*X[0] ,
            -c1*X[1] + d1*b*X[0]*X[1]-f1*X[1] ]

# Définition de l'échelle de temps
t = srange(0, 30,0.1)#en mois

#Conditions initiales :
X0 = [30,50] #nombre initial de lapins et de renards

lapins,renards = X.T # raccourcis de X.transpose()

#Résolution numérique
H = integrate.odeint(dX_dt, X0, t)


list_plot(H, plotjoined=true, color='pink', axes_labels=["Proies","Prédateurs"])

#http://chuis.pas.ptite.free.fr/TIPE/TIPE%20Systeme%20Proie%20Predateur.pdf

list_plot(H, plotjoined=true, color='pink', axes_labels=["Proies","Prédateurs"])+list_plot(X, plotjoined=true,color='green', axes_labels=["Proies","Prédateurs"])

#abcd= paramètres qui décrivent l'évolution des populations
#a= taux de croissance naturel  de la proie en l'abscence de prédateur
#b= taux de mortalité de la proie en présence de prédateur
#c= taux de mortalité  naturel du prédateur en l'absence de proie
#d= taux de croissance du prédateur en fonction du nombre de proies mangées

#Ce qu'on importe et définit :
import scipy; from scipy import integrate
import numpy as np
import matplotlib.pyplot as plt

a, b, c, d = 1, 0.1, 1, 1



#Définition de l'équation différentielle :
def dX_dt(X, t=0): # Renvoie l'augmentation des populations
    return [ a*X[0] - b*X[0]*X[1] ,
            -c*X[1] + d*b*X[0]*X[1] ]

# Définition de l'échelle de temps
t = srange(0, 30,0.1)#en mois

#Conditions initiales :
X0 = [30,0] #nombre initial de lapins et de renards en 10^2 millions d'habitants

lapins,renards = X.T # raccourcis de X.transpose()

#Résolution numérique
X = integrate.odeint(dX_dt, X0, t)


plt.plot(t,X), plt.xlabel("temps( en mois) "), plt.ylabel("population (10^2 millions d'habitants)"), plt.grid(True), plt.title('Evolution des populations de renards et lapins au cours du temps')


list_plot(X, plotjoined=true, color='green', axes_labels=["Proies","Prédateurs"])