Grafični prikaz gibanja satelita okrog Zemlje

V poljubno verzijo Pythona dodamo katero od grafičnih knjižnic. Prav preprosta je graphic.py . Namestimo jo na disk tako, da postane Pythonu vidna, preberemo še navodila na začetku knjižnice in lahko začnemo s programiranjem grafike. Tako recimo koda

from math import *
from graphics import *
def delay(m):
    for i in range(1000*m):
            continue
def main():
    mx=600    # širina in višina okna
    my=400
    win=GraphWin("Moj Krog",mx,my,autoflush=False)
    p=Rectangle(Point(0,0),Point(mx,my))
    p.setFill("white")
    c=Circle(Point(mx/2,my/2),10)      #Zemlja je modri krogec
    c.setFill("blue")
    p.draw(win)
    c.draw(win)
    dt=10                  #interval med računi leg
    x=mx/3                 #začetna lega
    y=0
    vx=0                   # začetna hitrost
    vy=0.04                # to komponento malo spremeni 
    while True:
        r=sqrt(x*x+y*y)   # račun razdalje satelit-Zemlja
        ax=-x/(r*r*r)     # pospešek satelita sledi iz 
        ay=-y/(r*r*r)     # gravitacijskeg azakona
        vx=vx+ax*dt       # račun nove hitrosti
        vy=vy+ay*dt       
        x=x+vx*dt         #račun nove lege satelita 
        y=y+vy*dt
        t=Point(mx/2+x,my/2-y)     # risanje satelita
        t.setFill("red")
        t.draw(win)
        delay(100)
        #t.setFill("white")
        #t.draw(win)
        update()
    win.getMouse()
    win.close()
main()

spravimo v gibanje satelit okrog Zemlje.

Otok zajcev in lisic

V začetku 80.let  so tudi k nam z Otoka pljusnile Mavrice – črna škatlica s smešno gumijasto tipkovnico  (Mirko tipka na radirko) je bila v bistvu eden  prvih osebnih računalnikov in  v njem je bilo junaško srce – procesor Zilog80.  Spomina je imela mrcina celih 64kb, od tega 16kb ROMa in 48kb RAMa. Za zunanjo spominsko enoto so Mavrice imele kar kaseto, ki smo jo poganjali na z računalnikom povezanim kasetnikom, namesto monitorja pa je služil kar TV sprejemnik – če je bil barvni, ste imeli  tudi barve. Srečni kupec je poleg Mavrice dobil še kaseto s programi in eden od teh programov je bil tudi Otok zajcev in lisic.

Torej, na otoku živijo zajci in lisice. Število zajcev se s časom veča zato, ker se zajci razmnožujejo, in pada zato, ker jih lisice lovijo. Število lisic pa se prav tako spreminja – veča, ker se množijo, in manjša, ko jim zmanjka hrane.  Označimo z z trenutno število zajcev, za l trenutno število lisic, dz in dl pa naj bosta prirastka zajcev in lisic v časovnem intervalu dt.  Število  tako zajcev kot lisic lahko opišemo z diferencialnima enačbama:

\[ dz=(az-bz\cdot l)dt, \]

\[ dl=(cl-d\frac{l}{z})dt. \]

Da je prirastek zajcev odvisen od njihovega trenutnega števila, ne preseneti, daj je to značilno za naravno rast. Upad števila (negativni predznak!) pa je odvisen od števila srečanj zajcev in lisic, to število pa je premo sorazmerno tako s številom zajcev kot s številom lisic.  Umiranje lisic zaradi lakote pa je premo sorazmerno s številom lisic in obratno sorazmerno s številom zajcev. Pri tem sta a in c konstanti, ki nekaj povesta o plodnosti zajklje oziroma lisice, b je v zvezi z verjetnostjo, da ob srečanju lisica-zajec slednji izdahne, d pa, da lisica od lakote umre.

Imamo torej sistem dveh nelinearnih diferencialnih enačb 1. reda, zato  rešitev ni preprosta. A spreminjanje obeh populacij s časom se je dalo spremljati že na tej Mavrici, danes pa lahko to počnemo v preglednicah ali nalogo sprogramiramo v kakem programskem jeziku.  V programu najprej določimo časovni interval ter začetno število zajcev in lisic, nato pa računamo prirastke iz diferencialnih enačb.

Kaj pričakujemo? Najbolj verjeten izid je, da bo na otoku najprej  zmanjkalo zajcev, nato pa še lisic in otok bo opustel.  Ob skrbno izbranih konstantah in začetni populaciji pa se nam lahko zgodi tole:

Rdeče so zajci, modro pa lisice. Grafa nista v merilu, zajcev je  5000 krat več kot lisic. Opazimo, da se populaciji spreminjata ciklično, da je vrh populacije lisic zamaknjen glede zajce in da je manjšanje populacije pri lisicah hitrejše kot pri zajcih.

Program je pisan v Pythonu, konstante se vidijo v kodi:

from Tkinter import *
from math import sin,pi
root = Tk()
("symbol",8)
root.title("Zajci in lisice -V. Petruna, januar 2010")
can = Canvas(root, width = 1010, height = 1000, background = "white")
can.create_line(10,500,1000,500, width = 1, fill = "black")
can.create_line(10,500,10,10, width = 1, fill = "black")
z=100
l=10
a=6.
b=1
c=4.
d=3000
dt=0.001
for t in range(10000):
    z=z+(a*z-b*z*l)*dt
    l=l+(c*l-d*l/z)*dt
    can.create_line(10+t*dt*100,500-z/1000,11+t*dt*100,500-z/1000, width = 2, fill = "red")
    can.create_line(10+t*dt*100,500-l*5,11+t*dt*100,500-l*5, width = 2, fill = "blue")
can.pack(side = BOTTOM)
root.mainloop()

Naloga: Določi  konstante ali začetno število v obeh populacijah tako, da so nihanja v populaciji čim manjša.  Dosežeš lahko takle

ali še boljši graf. Vse to lahko storiš že s srednješolskim znanjem. (Namig: Če se količini ne spreminjata, kakšna je leva stran enačb?)

Več o tej tematiki lahko najdeš tu.