Hur man gör ett numeriskt integrationsprogram i Python: 10 steg

2024 Författare: John Day | [email protected]. Senast ändrad: 2024-01-30 12:46

Detta är en handledning om hur du skapar och kör ett program som kommer att utvärdera bestämda integraler med hjälp av en numerisk integrationsalgoritm. Jag har delat upp stegen i tre avsnitt: förstå algoritmen som ska användas för att göra programmet, kodning av programmet med programmeringsspråket Python och körning av programmet. Denna handledning är avsedd för någon som kan behöva snabbt göra en miniräknare för att utvärdera bestämda integraler, eller kanske behöver algoritmen för användning i ett större program. Grundläggande kalkylkunskaper förväntas, men relevant matematisk information granskas. Kunskap om programmering förväntas inte, men är användbart eftersom jag bara kort beskriver hur programmeringen faktiskt fungerar.

Vad du kommer att behöva:

En persondator med tillgång till internet

Steg 1: Förstå algoritmen Del 1: Definite Integral och dess användning

Jag antar att du vet lite om vad en integral är i samband med grundläggande kalkyl. Integraler är viktiga eftersom de låter dig summera en rad värden multiplicerade med en oändlig längd; detta är användbart inom många områden inom finans, talteori, fysik, kemi, liksom många andra områden. Med detta program kan du emellertid bara beräkna ytan under en kurva för ett begränsat intervall, eller med andra ord, det utvärderar inte antirivat-en mycket kraftfullare algoritm är nödvändig för det. Denna algoritm är användbar om du behöver utvärdera en bestämd integral i ett större program specificerat mot något annat, eller om du vill kontrollera ditt svar för några bestämda integraler som görs för hand.

En grundläggande bestämd integral representerar området under en kurva definierad av en funktion t.ex. f (x). För en bestämd integral söker vi området mellan två punkter (märkt a respektive b). På bilden är det turkosa området det område jag syftar på, och ekvationen för att bestämma detta visas också i den regionen. Funktionen som visas på bilden är godtycklig.

Steg 2: Förstå algoritmen Del 2: Numerisk approximation

En dator behöver en bred uppsättning instruktioner för att beräkna det området under en godtycklig funktion som fungerar för alla funktioner, så analysmetoder du kanske känner till är inte till nytta eftersom de är för speciella. En metod för att beräkna integraler ungefär, som en dator faktiskt kan hantera, görs genom att fylla intresseområdet med en användardefinierad mängd rektanglar med samma bredd och variabel höjd och sedan summera alla rektangelns ytor. De stela egenskaperna hos rektanglar kommer att lämna en del av den totala ytan orörd, varför detta anses vara en approximation; Men ju fler rektanglar du kan klämma in mellan gränserna (a och b), desto mer exakt blir approximationen eftersom de orörda områdena blir glesare. Eftersom en dator kommer att utföra uppgiften kan du ställa in antalet rektanglar i önskad region till ett mycket stort antal, vilket gör approximationen extremt exakt. Föreställ dig i den stödjande bilden att varje rektangel i det angivna området är lika bred. Jag gjorde mitt bästa för att göra dem lika breda i Microsoft Paint, men gjorde inte det bästa jobbet.

Steg 3: Förstå algoritmen Del 3: Mittpunktsregeln

Denna regel anger hur rektanglarna görs och används i approximationen. Varje rektangel ur "N" rektanglar måste ha samma bredd, Δx, men varje n: e rektangel kan inte vara exakt densamma: den varierande faktorn är höjden som varierar beroende på vilken funktion som utvärderas vid en viss punkt. Mittpunktsregeln får sitt namn från det faktum att du utvärderar höjden på varje rektangel som f (x_n), där "x_n" är respektive mittpunkt för varje rektangel, till vänster eller höger om rektangeln. Att använda mittpunkten är som att implementera ett genomsnitt som gör approximationen mer exakt än om du skulle använda höger eller vänster. Stödbilden för detta steg sammanfattar hur mittpunktsregeln definieras matematiskt.

Steg 4: Skapa programmet Del 1: Ladda ner en Python Compiler/Editor

Nu när du förstår algoritmen som måste implementeras gäller det att få en dator att utföra beräkningen åt dig. Det första steget för att berätta för en dator vad de ska göra är att få verktygen för att göra det. Denna algoritm kan kodas på alla språk; För enkelhetens skull kommer detta program att kodas på Python -språket. För att beordra din dator att utföra operationer med Python behöver du en redigerare som tar instruktioner skrivna på det språket som sedan kommer att sammanställas till maskinspråk som din dator kan förstå så att den kan utföra de uppgifter du säger att den ska göra. I dag är en redaktör och kompilator vanligtvis integrerad, men det är inte alltid fallet. Du kan använda vilken redigerare/kompilator som helst som du är bekväm med, men jag visar dig hur du får min personliga favorit för Python: Canopy. Om du redan har en redigerare/kompilator kan du hoppa över dessa steg.

1. Gå till
2. Klicka på Download Canopy

3. Klicka på nedladdningsknappen som motsvarar ditt operativsystem

   Nedladdningen startar automatiskt

4. Följ instruktionerna för instillation när du har startat körningsfilen
5. Kör programmet
6. Klicka på "Editor" från programmets huvudmeny
7. Klicka på "skapa en ny fil" i mitten av skärmen

Från denna punkt bör du se ett tomt vitt fönster med en markör som liknar ett grundläggande ordbehandlingsdokument. Du är nu redo att börja koda den numeriska integrationsalgoritmen för att lösa bestämda integraler. De pågående stegen kommer att ha ett kodavsnitt som du kommer att kopiera och en förklaring av vad det här avsnittet gör för programmet som helhet.

Steg 5: Skapa programmet Del 2: Importera funktioner och definiera variabler

Kopiera koden på bilden.

Det finns variabler för alla program som du kan koda. En variabel är ett namn som ges till ett värde som kommer att användas och som kan ändras. På de flesta programmeringsspråk (om inte alla) måste du initiera en variabel innan programmet kan göra ändringar i den. När det gäller detta program har jag namngett variablerna "N", "a" och "b". Dessa värden representerar antalet iterationer (AKA -antal rektanglar), nedre gräns respektive övre gräns. Du kan namnge dessa vad du vill, men för att matcha formlerna som ges i "Förstå algoritmen del 3: Mittpunktsregeln" är det bäst att hålla dem desamma. Lägg märke till att de inte bara är inställda på ett visst värde. Detta beror på att de gör inmatningar som, när programmet körs, kan användaren av programmet definiera vad värdet kommer att vara. Texten med citattecken, efter inmatningskommandot, visas när du kör programmet och berättar vilken typ av värde du vill skriva in. Du kommer också att märka att "int" och "float" används före inmatningsbeteckningarna. Dessa termer berättar för datorn vilken typ av variabel detta värde kommer att vara. Ett "int" är ett heltal och ett "float" är ett flytande värde (dvs en decimal). Det bör vara klart varför dessa betecknas som sådana.

Varje text som finns efter ett "#" är en kommentar som låter programmeraren följa koden på ett humanistiskt sätt; Jag har gjort vissa kommentarer i min kod som du kommer att kopiera, men lägg gärna till kommentarer som hjälper dig specifikt. Programmet kommer inte att läsa något med ett "#" före det som ett kommando.

Den del av koden som läser "från matematisk import *" säger till programmet att importera en rad matematiska funktioner som kan användas utan att behöva programmera dem i dig själv. "*" Betyder bara "allt". Läs den här delen av koden som: från mattebiblioteket importera alla funktioner. Detta låter dig använda matematiska funktioner som sinus, cosinus, log, exp, etc. Dessa funktioner kan matematiskt integreras i koden.

Steg 6: Skapa programmet Del 3: Skapa en funktion för integration

Kopiera koden på bilden nedanför föregående kod.

VARNING: Det här avsnittet är tätt, och jag vill klargöra några saker som kan vara förvirrande. När man talar om programmering dyker ordet "funktion" upp mycket. Denna term dyker också upp mycket när du pratar om matte. Så, från och med nu, när jag talar om en funktion i programmerings bemärkelse, kommer jag att skriva "Python -funktion", och när jag talar om den matematiska funktionen kommer jag att säga "matematisk funktion". Någon gång kommer vi att använda en Python -funktion som representation för den matematiska funktionen i fråga.

Detta nästa kodavsnitt är programmets hjärta. Här definieras en Python -funktion som utför algoritmen för numerisk integration med hjälp av mittpunktsregeln. "def Integrate (N, a, b)" läser som: definiera en funktion som kallas "Integrate" som accepterar variablerna "N", "a" och "b" och returnerar området under kurvan (den matematiska funktionen) som också definieras inom "Integrera" Python -funktionen. Du kan kalla denna Python -funktion vad som helst när du gör kodningen, men det är vettigt att kalla det integrera eftersom det är en funktion som verkligen integrerar en matematisk funktion.

Vid denna tidpunkt är det värt att kommentera hur Python segregerar kodblock. Ett kodblock är en hel sektion som utför en viss uppgift. Olika programmeringsspråk kommer att ha särskilda sätt att skilja dessa "block". För Python kännetecknas ett block av indragningar: varje uppgiftsutförande sektion har sin egen indragning, och det kan finnas indragna block inom andra indragna block. Detta representerar uppgifter inom uppgifter och berättar i huvudsak i vilken ordning koden måste köras. När det gäller den definierade Python -funktionen "Integrera" är allt inom den funktionen indraget i ett block, vilket skiljer de uppgifter som kommer att utföras inom den funktionen. Det finns indragna delar inom denna Python -funktion som också utför sina egna uppgifter. Det går så här: ett kommando (uppgift) anges, ett kolon följer kommandot och vad kommandot gör är indraget nedanför.

Omedelbart efter att du har definierat "integrera" Python -funktionen kommer du att definiera en annan Python -funktion som heter f (x). Detta representerar den matematiska funktion som kommer att integreras. För varje matematisk funktion du vill integrera måste du gå till denna programrad för att ändra den (till skillnad från de variabler som definieras när programmet körs). Varje Python -funktion kommer att ha ett returvärde, det är vad funktionen returnerar när du kastar ett värde. I det här fallet är inkastningsvärdet "x" och denna "x" -term kommer att ta värdet av vad du än kastar det-det är ett tillfälligt värde.

Därefter fungerar en for-loop som den summering som definieras i formlerna i avsnittet "Förstå algoritmen" i den här självstudien. Denna summering kräver ytterligare ett par variabler, varav en fungerar som returvärde för hela "Integrera" Python -funktionen. Innan for-loop har jag betecknat dessa variabler som "värde" och "värde2". för-loopens uppgift är att iterera över ett intervall av värden för en angiven variabel, som bekvämt kan definieras inom for-loop-kommandot; i detta fall är variabeln "n". Intervallet för vilket iterationen sker är 1 till N+1. Du bör märka att summeringen som definieras i de ovannämnda formlerna bara sträcker sig från 1 till N. Vi definierar det på detta sätt eftersom Python -språket räknar varje itererat värde som börjar från noll, så vi måste väsentligen flytta intervallet för värdena för att passa vårt önskade räckvidd. For-loopen möjliggör sedan summering av alla rektangelns höjder tillsammans och lagrar det värdet i variabeln som jag kallade "värde". Detta ses i koden som visas som: värde += f (a +((n- (1/2))*((b-a)/N))).

Därifrån använder nästa bit av koden variabeln som kallas "värde2" som sedan tilldelas summan av alla höjder i varje rektangel multiplicerad med den standardiserade bredden på varje rektangel-detta är vårt slutliga svar som vi vill ha visas av vårt program, och är således returvärdet för "Integrera" Python -funktionen.

Steg 7: Skapa programmet Del 4: Visa svaret

Kopiera koden på bilden nedanför föregående kod.

Nu när svaret kan erhållas via "Integrera" Python -funktionen, vill vi kunna visa det. Det här är bara att sätta de värden som användaren matade in ("N", "a" och "b") i "Integrera" Python -funktionen och skriva ut den på skärmen. Det här kommandot visas på rad 21 och är egentligen allt du behöver göra för att slutföra detta steg. Koden på rad 19 och 20 är bara där för att "finjustera" utmatningen av hela programmet. "print (" ……………………… " skrivs ut efter den textraden.

Steg 8: Köra programmet Del 1: Köra programmet som det är

Om du inte använder Canopy behöver du förmodligen inte ens följa det här steget alls och att köra programmet kan kräva olika procedurer. I Canopy, innan du kan köra programmet, måste du spara det. Filtypen för ett Python-program är en.py-fil-den sparas automatiskt som detta. Välj var du vill att filen ska sparas, så kommer du att kunna köra programmet.

Kör programmet:

1. Tryck på den gröna knappen som ser ut som en "uppspelningsknapp" som finns i verktygsfältet precis ovanför där ditt filnamn visas (se bild).
2. Programmet körs sedan på den nedre skärmen i redigeraren som kallas Canopy-dataanalysmiljön. Om du antar att du kopierade uppmaningarna som jag skrev dem, bör du se meddelandet längst ned i Canopy-dataanalysmiljön: "Ange hur många gånger du vill summera (fler gånger = mer exakt):." (se bild)
3. Ange ett värde för hur många gånger du vill göra iterationen dvs 10000 (hur många rektanglar du vill skjuta in i ditt område) och tryck sedan på enter.
4. Fler uppmaningar kommer att visas med uttalanden som borde vara de välbekanta inmatningsfrågorna du kodade in i programmet i steg 5. Fyll i dem på lämpligt sätt precis som i nummer 3 ovan.
5. Integralen bör utvärderas och ett resultat ska visas.

Om du kodade programmet som visas på föregående bilder har du precis integrerat f (x) = x^2 över vissa gränser. Integralen av x^2 är lätt att utvärdera för hand, därför bör du kontrollera och se till att programmet gav ett mycket nära svar på det korrekta analytiska värdet som bestäms för hand. När jag kör programmet med värdena N = 10000, a = 0 och b = 10 får jag svaret 333.33333249999964. Det korrekta analytiska svaret är 333.333. Detta är otroligt korrekt och snabbt. Du har i princip pressat 10 000 rektanglar mellan 0 och 10 på x -axeln och använt dem för att approximera området under kurvan x^2!

Steg 9: Köra programmet Del 2: Integrering av andra matematiska funktioner

I det föregående steget, om du har följt troget, integrerade du f (x) = x^2. Det är inte den enda matematiska funktionen som detta program kan integrera. Kom ihåg från steg 5 att du importerade matematikbiblioteket med Python -funktioner till programmet. Detta gör att du kan använda mer komplicerade matematiska funktioner som kan integreras. Låt oss ge en chans. Självklart kan du använda vilken funktion du vill, men jag kommer att visa ytterligare noggrannheten i denna kod genom att integrera en viss matematisk funktion som ger ett välkänt värde när den integreras över ett visst intervall. Den funktionen är f (x) = Sin [x]. Denna matematiska funktion visas i den första medföljande bilden, ritad från 0 till 2π, och intresseområdet är skuggat i turkos. Det finns lika mycket positivt område som det finns negativt område i detta intervall, så om du lägger ihop den totala ytan bör du få noll. Låt oss se om detta verkligen händer:

Att sätta in den matematiska funktionen f (x) = Sin [x] i programmet:

1. Innan du kör programmet igen, under kommentaren "#typ din funktion efter retur", skriv: sin (x) där x ** 2 för närvarande finns. (se bild).
2. Kör programmet genom att trycka på den gröna uppspelningsknappen igen.
3. Skriv 10000 för N -värdet (hur många gånger du vill summera).
4. sätt "0" för den nedre gränsen.
5. Sätt in 6.2832 för den övre gränsen (ungefär 2π).
6. Se vilket värde du får.

När jag gjorde detta fick jag ett värde på 1.079e-10: det här motsvarar.0000000001079, som verkligen är nära noll, så det verkar vara korrekt och visar att algoritmen hanterar negativt område på ett adekvat sätt.

Steg 10: Köra programmet Del 3: Utöka programmet

Vid denna tidpunkt är du klar: du har en fungerande bestämd integralalgoritm kodad i Python som går smidigt och ger mycket exakta svar. Detta program kan dock förbättras. Jag är ingen programmerare, och jag har minimal erfarenhet av Python. Faktum är att jag var tvungen att uppdatera mig själv med att använda Python för att slutföra denna handledning, men det borde ge dig förtroende för att Python är ett så enkelt språk att lära sig. Min poäng är att du kan utöka detta program genom att göra det mer effektivt, kanske implementera lite GUI och göra det mer användarvänligt.

Mina tankar om att utöka programmet:

• Implementera ett grafiskt användargränssnitt som låter dig köra programmet utan att använda Canopy interaktiva dataanalysmiljö
• Gör det så att den matematiska funktionen som ska integreras inte behöver matas in i programmet, utan kan matas in efter att programmet har körts (jag försökte först göra detta, men kunde inte räkna ut det).
• Definiera en "Integrera" Python -funktion så att f (x) -funktionen är avsedd att ha funktionen f (x) definierad i den.

Detta är bara några exempel på förbättringsområden, men jag garanterar att det finns många andra områden som kan förbättras. Så jag lämnar detta steg som ett exempel på de brister detta program har och kanske en övning för alla som vill förbättra programmet ytterligare.