Scipy Odeint

Denne artikkelen er designet rundt Odeint -funksjonen til Scipy Library. I denne guiden lærer vi hvordan du løser differensialligningene ved å bruke Odeint -funksjonen levert av Pythons Scipy Library. Python -programmeringsspråk har mange enkle og nyttige funksjoner som gjør livet til programmerere ukompliserte og enkle. Utviklerne blir eksperter innen programmering ved å bruke de innebygde funksjonene og gratis bibliotekene til Python-programmeringsspråket. I denne artikkelen vil vi utforske Odeint -funksjonen til Scipy -biblioteket for å hjelpe deg med å lære å implementere Odeint -funksjonen i et Python -program.

Hva er Odeint?

Odeint er forkortelsen av den vanlige differensialligningsintegrasjonen og brukes til å løse de forskjellige typene differensialligninger. Det er en komplett pakke som inneholder en samling av avanserte numeriske algoritmer som brukes til å løse de vanlige differensialligningene og innledende verdiproblemer. Det refererer til å løse differensialligninger som involverer derivater uten delvis derivat.

I denne opplæringen vil vi ringe Scipy -biblioteket for å bruke Odeint -funksjonen og vil få deg til å lære og forstå hvordan du implementerer Odeint -funksjonen i et Python -program. La oss forstå syntaksen til Odeint -funksjonen først. Deretter vil vi gå videre til eksempeldelen og lære å implementere Odeint -funksjonen.

Syntaks av Odeint -funksjonen

Odeint -funksjonen integrerer og løser systemet med vanlige differensialligninger ved bruk av Fortrans Odepack Library -pakke, ISODA. Syntaksen til Odeint -funksjonen er som følger:

Odeint -funksjonen tar tre nødvendige parametere og en liste over valgfrie parametere. Y- og T -funksjonene er de nødvendige parametrene som må leveres for å implementere ODEint -funksjonen for den gitte funksjonen. *Args representerer listen over valgfrie parametere som kan gis og brukes i henhold til brukerens krav.

Imidlertid brukes "funksjon" -parameteren til å kalle funksjonen som beregner derivatet av "YO" -parameteren på "T" -parameteren. "YO" -parameteren er typen matrise som definerer den opprinnelige tilstanden til "y" -arrayen. "T" -parameteren brukes til å definere sekvensen av tidspunkter i matrisen som brukes til å løse for "y" -arrayen.

Odeint -funksjonen returnerer matrisen som inneholder verdien av “y” om gangen “T” med den opprinnelige verdien av “yo” til å begynne med. Den returnerer også en ordbok som inneholder tilleggsinformasjonsinformasjonen. La oss nå demonstrere noen eksempler for å vise deg hvordan du implementerer Odeint -funksjonen i et Python -program.

Eksempel 1:

La oss starte med et enkelt og veldig grunnleggende eksempel. Her vil vi veilede deg om hvordan du kan bruke Odeint -funksjonen i et Python -program og passere de nødvendige parametrene. Tenk på følgende gitt prøvekode for din forståelse:

Importer numpy som NP
Fra scipy.Integrer import Odeint
def dydt (y, t):
dy = y + 2*t
Return Dy
y0 = 4
t = np.Linspace (0,4)
y = odeint (dydt, y0, t)
trykk (y)

Vi bruker de to bibliotekene i dette programmet - Numpy og Scipy Libraries. Numpy -biblioteket lar oss bruke Linspace () -funksjonen. Scipy lar oss bruke Odeint () -funksjonen. Når vi har kalt alle bibliotekene, erklærer vi "DYDT" -funksjonen som brukes til å finne derivatet til funksjonen med Odeint () -funksjonen. Den opprinnelige verdien er satt til Y0 = 4 og tiden er satt til Linspace (0, 4). Ved å sende alle disse verdiene og funksjonsnavnene til Odeint () -funksjonen, implementerer vi Odeint -funksjonen i et Python -program. Utgangen er som følger:

Eksempel 2:

For å demonstrere Odeint -funksjonens utgang og for å forklare hvordan den fungerer i en Python -applikasjon, har vi tidligere skrevet ut hele matrisen. La oss nå tegne en graf over de samme dataene for å gi deg et klart bilde av hvordan utgangen fra Odeint -funksjonen ser ut. Tenk på følgende prøvekode som viser utgangen fra ODEINT -funksjonen i en graf:

Importer numpy som NP
Importer matplotlib.Pyplot som Plt
Fra scipy.Integrer import Odeint
def dydt (y, t):
dy = y + 2*t
Return Dy
y0 = 4
t = np.Linspace (0,4)
y = odeint (dydt, y0, t)
plt.plot (t, y)
plt.xlabel ("tid")
plt.ylabel ("y")
plt.forestilling()

Programmet er nøyaktig det samme som brukes i forrige eksempel. Bare koden for å plotte utdataene i grafen er lagt til her. Matplotlib -biblioteket brukes til å vise utgangen i en graf. Plottfunksjonen til matplotlib -biblioteket brukes til å generere grafen til dataene. Den resulterende grafen over Odeint -funksjonen er som følger:

Eksempel 3:

Vi lærte nå hvordan Odeint -funksjonen implementeres i et Python -program og hvordan det er plottet i en graf. La oss se et annet eksempel på Odeint -funksjonen og løse en annen differensialligning med den. Vurder følgende prøvekode. Her bruker vi følgende differensialligning:

Denne ligningen løses av Odeint -funksjonen i følgende eksempel:

Importer numpy som NP
Importer matplotlib.Pyplot som Plt
Fra scipy.Integrer import Odeint
def dydt (y, t):
dy = 2*np.exp (t) - 13*y
Return Dy
y0 = 2
t = np.Linspace (0,4)
y = odeint (dydt, y0, t)
plt.plot (t, y)
plt.xlabel ("tid")
plt.ylabel ("y")
plt.forestilling()

Igjen kalles tre biblioteker i programmet - Scipy, Numpy og Matplotlib - for å importere henholdsvis Odeint (), Linspace () og plot (). DYDT -funksjonen er erklært ved å gi den differensialligningen som er nevnt tidligere. Startverdien og tilhørende tid for hvert element er definert. Alle de definerte parametrene sendes til Odeint () -funksjonen. Ved hjelp av PLT -modulen fra Matplotlib -biblioteket er resultatet av Odeint () -funksjonen plottet i grafen. La oss se den grafiske representasjonen her:

Eksempel 4:

La oss demonstrere litt av et komplekst praktisk eksempel for å vise at ODEINT enkelt kan håndtere de forskjellige typer data. I forrige eksempel erklærte vi bare en startverdi for funksjonen. Her bruker vi flere innledende forhold for differensialligningen. Det er for å hjelpe deg å lære å håndtere en differensialligning når den har flere innledende forhold. Tenk på følgende prøvekode:

Importer numpy som NP
Importer matplotlib.Pyplot som Plt
Fra scipy.Integrer import Odeint
def dydt (y, t):
dy = ((1.1 - y) / (1.45 - y)) - (y / (0.02 + y))
Return Dy
y0 = [1, 2, 4]
t = np.Linspace (1, 10)
y = odeint (dydt, y0, t)
plt.plot (t, y)
plt.xlabel ("tid")
plt.ylabel ("y")
plt.forestilling()

Legg merke til at bibliotekene og annen dataerklæringsprosess er de samme som i de forrige eksemplene, bare de opprinnelige forholdene er gitt som en matrise. Utgangsgrafen til Odeint -funksjonen med flere innledende forhold er som følger:

Konklusjon

Denne guiden hadde som mål å forklare hva Odeint er og hvordan den kan implementeres i et Python -program. Odeint står for vanlig differensialligningsintegrasjon. Det brukes først og fremst for å løse differensialligningene. Eksempelprogrammene demonstrerte hvordan man implementerer Odeint -funksjonen og hvordan du plotter resultatet av Odeint -funksjonen i en graf. Dessuten demonstrerte eksemplene også hvordan man løser differensialligningen med flere innledende forhold.