Koda med TI: TI-84 Plus Python Edition

I den första övningen från kapitel 1 kommer du att upptäcka grundläggande egenskaper hos TI-Python och de vanligaste matematiska funktionerna som ingår i TI-84 Premium CE-T-räknaren.

Syfte:

• Använda TI Python-modulen
• Upptäck de matematiska funktionerna i Python
• Skilja programeditor och konsol (Shell)
• Använda en programmerings-instruktion i konsolen

För att komma åt Python-appen så trycker du på knappen <prgm> och väljer sedan Python App. Du kan också komma åt Pythonappen via tangenten . Sök sedan i listan med olika appar.

Lärarkommentar: För att använda TI-Python-appen måste räknarens operativsystem uppdateras till version 5.35 eller senare. Vi rekommenderar också att TI-Connect-CE-programvaran uppda- teras så att du direkt kan överföra Python-utformade program till en IDLE (Integrated Development Environment) direkt till TI-84 Plus CE-T-räknaren.

Välj nu 2:Python App. Då öppnas filhanteraren. Längst ner i fönstret finns olika funktioner som du når med räknarens vita tangenter. Den lilla gröna rutan längst upp till höger på skärmen visar att Python är ”på”.

Lärarkommentar: Pythonspråket är baserat på ett skript som utförs i konsolen (shell). Emellertid är det möjligt att där också

• Göra beräkningar, definiera variabler för att integrera dem i beräkningar.
• Skriva och köra ett program.
• Köra ett program som anges i editorn och be om de värden som tas av variablerna i det programmet.

Först kommer vi att använda konsolen även kallad "Shell" Tryck nu på f4-tangenten för att komma åt konsolen (Shell). Du kan rensa fönstret och i detta fall ta bort listan med filer genom att trycka på f4 (Tools och välja 5:Clear screen. Det har vi gjort här på skärmen.

Några grundläggande kommandon.

Variabler namnges vanligtvis med små bokstäver. a ←5 skrivs i Python a = 5 och erhålls på räknaren genom att skriva: a  5. Den här satsen innebär att 5 har tilldelats variabeln a.

För att testa a-värdet av variabeln c: skriver man a == 5 eller c>=5. Du får då svaret True eller False

För åtkomst samt grundläggande kontroller kan du alltså trycka på f2 och får då en palett med vanliga bokstäver och en massa symboler. De flesta tecken når du dock från räknarens tangentbord. Trycker du [A] så får du a. Trycker du på alpha-tangenten två gånger får du A. Pröva nu själv.

Några specialberäkningar

• Resten vid division av a med b skrivs a%b
• Heltalsdelen vid division av a med b skrivs a//b
• x upphöjt till n kan skrivas x**n. Man kan också skriva pow(x,n).

För att kunna utföra beräkningar med kvadratrötter och bråk måste man ladda biblioteksmodulen ”math import”. För att infoga modulen så trycker du på f1-tangenten (Fns..) och väljer Modul och sedan 1:math. Roten ur x skrivs nu som sqrt(x) och talet π skrivs på skärmen som pi. Du kan också trycka på tangenten för att nå olika mate- matiska funktioner.

Lärarkommentar: Om du trycker en gång på tangenten så konfi- gureras tangentbordet för att skriva bokstäver som gemener (”små bokstäver”). Om du trycker på två gånger så skrivs bokstäverna som versaler (stora bokstäver). Sekvensen y   gör att du låser tangentbordet i alfanumeriskt läge. Trycker du på igen ändar du inställning från aktuellt läge till det tidigare.

Obs: För att tömma en konsol från tidigare aktiviteter så trycker du på f3 (Tools) och väljer 5: Clear Screen eller 6: New shell om du inte vill behålla variablerna.

Teckensträngar definieras med dubbla eller enkla citattecken, ’Python’ eller ”Python”.

• Längden hos en teckensträng fås med kommandot len(c). (Välj f1 (Fns…) och sedan List.
• c[k] returnerar element k-1 hos kedjan c
• För att sätta samman två strängar så adderar man dem

Ett litet trick:

Vid tilldelning av flera variabler så kan man göra det på en gång, vilket visas på skärmen här

Använda en programinstruktion i Shell-fönstret

I Pythonspråket har man möjlighet att observera en viss funktion oberoende av ett skript. Så på skärmen till höger kan du analysera funktionen av en s.k. for-loop. Du kommer åt instruktionen genom att trycka på f1 (Fns…) och sedan välja menyalternativet 5:Ctl For i in range (start, slut). Vi återkommer till loopar i en senare övning.

Nu till en enkel tillämpning

Den kinetiska energin hos en kropp i rörelse ges av uttrycket

E_k = (1/2)·mv²

Där m är massan i kg och v är hastigheten i m/s. Beräkna nu den kinetiska energin för en kropp som har massan 50 kg och hastigheten 12 m/s.

Lärarkommentar: Ett datorprogram innehåller instruktioner som använder variabler. En variabel är en ”låda” som gör att du kan behålla programdata (tal, användarens indatavärden, teckensträngar, etc.) genom att lagra den i datorns minne. För tilldelningen av ett värde till en variabel används tangenten  som kopieras in som = i Shell-fönstret.

Om du trycker på [ catalog ] så får du en lista med alla Python-funktioner som finns hos räknaren.

Till slut: För att avsluta Python-appen så kan du trycka på [ quit ]. Du får då ett nytt fönster och du kan ångra dig eller välja att avsluta.

I denna andra övning i kapitel 1 så ska du upptäcka hur man använder olika typer av data i Python

Syfte:

• Känna till olika typer av data i Pythonspråket
• Forma formatet hos digitala data

Känna till vilken typ av kvantitet som används

När du använder ett Pythonspråk-skript kan det vara nödvändigt att känna till vilken typ av variabel som används, eller att ändra dessa vari- abler för senare användning. Om kvantiteten som returneras av ett Python-skript till exempel returnerar en magnitud som motsvarar ett mått ifrån naturvetenskaperna, är det oftast inte lämpligt att behålla ett resultat med 6 decimaler.

Du ska skapa ett skript i Python-appen för att skilja mellan de typer av kvantiteter som används.

• En kedja av tecken
• Ett reellt tal
• Ett irrationellt tal, till exempel √2

Du visar namnet liksom typen under instruktionen Type.

• Importerna modulen Math (Tryck Fns och välj därefter 1:Modul. Tryck sedan 1:math… och till sist from math import *)
• Alla kommandon kan nås genom att trycka på f1-tangenten (Fns…) och sedan välja undermenyerna I/O och Type.
• Typkommandot som låter dig känna till variabelns typ skrivs för hand.

Till höger här har vi en teckensträng. Citattecknen (dubbla och enkla) kan man nå genom att trycka resp. .

Tips: Med piltangenten kan du kopiera en rad när man arbetar i Shell-fönstret (konsolen).

• Operatorn int() extraherar där så är möjligt, hela kedjan av tecken och returnerar heltalsdelen av ett tal.
• Operatorn str() omvandlar ett tal till en teckensträng.
• Operatorn float extraherar om så är möjligt flyttalet (tal med decimaltecken) från en teckensträng.

Ett annat tips:

Man kan skriva variabler som man vill använda på samma rad

För att öka värdet av en variabel med ett räkneverk så finns det två möjligheter. Skriv till exempel enligt skärmarna till höger och be sedan om att variabeln ska visas.

Lärarkommentar: 

• Tänk på att man kan använda det alfanumeriska tangentbordet och skriva gemener genom att trycka på y  . Trycker du sedan på en gång till kan du skriva versaler.
• Använd "klistra in"-funktionen från f3-menyn (Tools). Här kan man klistra in text som man kopierat i editorn.
• När du skriver in text så kan du trycka på tangenten  om du skrivit in tecken som du vill ta bort.
• Se till att räknaren har svenska som lokaliseringsspråk. Då får man med å, ä och ö i teckenpaletten. Se skärmbilden till höger. För att ställa in språk trycker man på och välj sedan språk längst ner i listan för olika inställningar.
• Man kan lägga in kommentarer i sina skript genom att lägga till tecknet # innan kommentaren. Placeringen först på raden indikerar att det som står efter tecknet# inte tolkas. Man når # genom att trycka på f2-knappen (a A #).

I den tredje lektionen i enhet 1 ska du använda programeditorn (skriptet) för att skapa funktioner och sedan köra dem, och obser- vera resultaten i konsolen (Shell-fönstret)

Syfte:

• Upptäck begreppet funktion i Python
• Skapa en funktion

Begreppet funktion i Python.

Implementera följande algoritm:

x←3
y←2*x + 3

I en konsol görs detta enkelt. Se skärmbilden till höger. Men om du vill upprepa den här typen av beräkning för ett annat x-värde måste du skriva om hela sekvensen. För ett mindre trivialt exempel blir detta både tidskrävande och väldigt tråkigt. Så vi leds nu att skapa en funktion som gör det möjligt för oss att enkelt kopiera processandet av algoritmen.

Lärarkommentar: En funktion gör det möjligt att dela upp problem i subproblem och på så sätt undvika upprepning av instruktioner. När den är definierad kan den "anropas" så många gånger som det behövs. En funktion behöver inte ha något argument. Den kan också anropas från ett annat program. Man behöver bara infoga den i en instruktion genom att mata in namnet på funktionen och värdena på argumenten. 

Genomförande av ett första exempel.

• Öppna Python-appen och välj att skapa ett nytt skript genom att trycka på f3 "New"

• Ge ditt skript ett namn. Välj till exempel CALC och bekräfta genom att trycka på . Det maximala antalet tecken är 8.
• Namnet på skriptet visas sedan högst upp i det grå fältet: name=CALC. Tryck sedan Ok.

Tryck sedan på f1 (Fns) och välj def function():. Tryck sedan på enter.

Skriv sedan enligt skärmen till höger. Observera indragen på rad 2 och 3. Det kallas för indentering. Den sker automatiskt och gör det möjligt att definiera programblocken. Man kan säga att indentering är en del av själva Pythonspråket.

Instruktionen return finns också under fliken Fns… Vi återkommer till betydelsen av instruktionen return senare.

Tryck nu på f4 (Run) för att köra programmet. Du får nu ett meddelande att programmet är uppladdat i konsolen (Shell).

För att beräkna funktionsvärdet för x = 6 kan du skriva in t.ex. f(6). Ett annat sätt är att trycka på tangenten 0ch sedan trycka Ok. Du fyller sedan i x-värdet. Vi har här beräknat funktionsvärdet för tre olika värden på x.

Inom funktionsblocket kan man ha flera rader. Här ska vi nu beräkna funktionsvärden för

(2x - 3) · (2x + 3) = 4x²- 9

Du kan också plotta denna funktion och se om de beräknade funktionsvärdena stämmer.

I en senare övning ska vi skriva ett program som gör en tabell där vi har matat in start- och slutvärde. Se nedan.

>

Avsluta nu Python genom att trycka på [ quit ].

Att skriva skript som repetition på de tre första övningarna i kapitel 1.

• Pythons språkfunktion
• Skapa en lista

Syfte:

• Skapa en temperaturomvandlare
• Skapa ett skript som utformar ett algebraiskt uttryck

Exempel 1: Omvandla temperatur

För att mäta temperatur använder vi i Sverige och de flesta andra länder Celsiusskalan (^OC). I anglosaxiska länder använder man Fahrenheitskalan.

Din uppgift nu är att programmera en funktion som utför temperaturomvandling i båda riktningarna, Celcius till Fahrenheit och tvärtom!

Finns det någon temperatur där mätetalet är lika i båda skalorna.

Sambandet är

t(°F) = (9/5) · t(°C) + 32 som kan skrivas t(°F) = 1,8 · t(°C) + 32

• Öppna Pythonappen och starta ett nytt skript genom att trycka på f3 (New)
• Döp skriptet till TEMP t.ex. Tryck sedan på f5 (Ok).
• Tryck på tangenten och välj sedan modulen 1:math och till sist 1:from math import. Raden ”from math import *” kopieras in i editorn.

• Skapa nu den första omvandlingsfunktionen genom att trycka f1 och välja 1:def function():. Tryck sedan på .
• På nästa rad skriver du return f. Du kan antingen mata in return från räknarens tangenttbord eller trycka på f1 och välja 2:return.
• Kör nu skriptet (Run) och skriv f(30). Du får resultatet 86.

Lärarkommentar: När du är i ett skript kan du trycka på tangenten och sedan anropa funktionen utan argument. Tryck på f5 (Ok) och slutför sedan funktionen genom att mata in ett argument inom parentesen.

• Slutför nu redigeringen av skriptet genom att lägga till de nödvändiga instruktionerna för omvandlingen från grader Fahrenheit till grader Celsius.
• Vi ser att man automatiskt får indrag på funktionsblocket efter definitionen av c(f). Indentering finns med bland editeringsverktygen om du trycker på f3 (Tools).

• Om du nu kör detta skript och beräknar Fahrenheit-temperaturen vid 30 °C får vi resultatet 86. Vi beräknar sedan Celsiustemperaturen vid 86 °F. Då får vi tillbaka värdet 30.

Lärarkommentar: Fråga eleverna om det finns någon temperatur
där mätvärdet är lika i båda skalorna?
Enklast sättet att lösa problemet är att lösa ekvationen
x =1,8.x +32. För att visst värde på x är vänstra och högra ledet lika.

x =1,8.x +32

x - 1,8.x = 32

-0,8x = 32

0,8x = -32

x = -32/0,8 = -40

Om man +skriver f(-40) så ska man få ut -40.

Till höger här visar vi nu ett skript där man kan få ut en tabell med värden i båda skalorna. Man ska här vid körningen av programmet mata in startvärde, slutvärde och steg. Kan du förklara de olika stegen i programmet. De instruktioner som förekommer i programmet har vi bara tagit upp ytligt i de tidigare övningarna. Utförliga förklaringar kommer i senare övningar.

Lärarkommentar: Be eleverna att skriva in programmet och sedan exekvera det i Shell-fönstret. Man kan också skriva programmet så att man går från Celsius till Fahrenheit.

I den första övningen i kapitel 2 får du lära dig att skriva och använda en villkorsinstruktion i Python.

Syfte:

• Skriva och använda en villkorsinstruktion
• Återanvända begreppet funktion i Python

Lärarkommentar: I Pythonspråket finns det ingen instruktion för att ange slutet på en instruktion med villkor. Det visas av indragen (inden- teringen) för instruktionerna A och B. elif är sammandragning av else och If. För att testa likheten mellan två värden i Pythonspråket används två likhetstecken ”==”.

Exempel: Ett biluthyrningsföretag erbjuder sina kunder följande avtal: Ett weekendpris för 66 euro plus 0,25 euro per kilometer över 70 km. Ditt jobb är att konstruera ett skript som automatiskt beräknar kost- naden för avtalet baserat på den tilltänkta sträckan.

Genomförande:

• Starta Python-appen genom att trycka på tangenten .
• Starta sedan ett nytt -skript genom att trycka på f3(New) och döp det till "BILHYRA". Validera genom att trycka på f5-tangenten (Ok).
• Startas skriptet genom att definiera en funktion. Tryck då på f1 (Fns…) och tryck sedan på 1:def function():. Namnge funktionen till kostnad(s). s står här för sträckan i km.

• Tryck nu på f1-tangenten (Fns…) och välj sedan Ctl, som står för Kontroll. Här finns nu ett antal val för olika villkorssatser plus ett antal alternativ för s.k. loopar. Välj nu 2:if .. else. Detta kan översättas till svenska som ”om .. annars”.

På nästa sida ser vi resultatet.

Vi ser strukturen på skärmen med nödvändiga indrag för villkorsblocket. I Python-språket så hör kommandon med samma antal indrag ihop. Detta är en del av själva språket. Man får då en bra bild av programstrukturen.

Du kan se intill hur funktionen kan se ut, till exempel. Om sträckan s är 70 eller mindre blir resultatet 66. I det andra fallet beräknar funktionen först antalet kilometer över 70 och sedan kostnaden. I det här exemplet kan du se att ett block kan bestå av flera regler. Du infogar symbolen ≤ med f1(Fns...) och sedan Ops eller också kan du trycka på .

Nu kan vi köra programmet för några olika värden på sträckan s. Du får fram kostnadsfunktionen genom att trycka på tangenten 

Lärarkommentar: Till höger har vi ett skript som ser lite annorlunda ut än skriptet Bilhyra. Be eleverna att skriva in skriptet i editorn och göra några körningar vid olika värden på sträckan s. Be dem förklara vad det är för beräkningar som utförs. Förklara också användandet av villkorssatsen if .. elif .. else.

Lärarkommentar: Hur plottar man nu denna kostnadsfunktion på räknaren. Den kallas för en styckvis funktion eftersom den består av olika bitar som är definierade för olika intervall. Vi ska här visa ett sätt att plotta funktionen som handlar om hur räknaren utvärderar jämförelser när man använder s.k. relationsoperatorer. Se nästa sida

Räknaren utvärderar påståenden och ger ett av två möjliga sannings- värden: 1 = Sant och 0 = Falskt. När är A < 2 sant?

Räknaren returnerar 1 för sant och 0 för falskt när A är mindre än 2.
Se skärmbilden till höger.
Om du delar en funktion med ett påstående divideras funktionen med 1 när påståendet är sant och funktionen divideras med 0 när påståendet är falskt. Nu kan man ju inte dividera med 0 och då kan man heller inte plotta funktionen.

Den funktion vi nu ska plotta kan skrivas så här:

Ett sätt att mata in detta i Y=-editorn blir då som i skärmen här bredvid. Här måste man se till att man ställt in visningen som MATHPRINT (tryck på  för att ställa in). I Y-editorn trycker man sedan på  för att få inmatning som bråk. Sedan skriver man enligt skärmen till höger

Med en bra fönsterinställning kan plottningen sedan bli så här. Man ser lätt de tre delarna då de är i olika färg både i inmatningsskärmen och plottningsskären.

I den andra övningen i enhet 2 får du lära dig hur du upprepar en process eller en uppsättning instruktioner med hjälp av en förbestämd for-loop.

Syfte:

• Utforska och implementera for-loopar
• Använda for-loopar i enkla exempel

Det är ibland användbart i ett program att upprepa en eller flera instruktioner ett antal gånger. Om antalet repetitioner av processen är känt i förväg används en förbestämd for-loop. Syntaxen för en for-loop är följande:

Naturligt språk

För variabler som sträcker sig från lägsta till högsta instruktioner.

Python-språk
for variabel i intervall ():
     Instruktioner

För funktionen range() kan du ange antalet steg i den förbestämda loopen. Det kan kallas på flera sätt:

for i in range(size): tar heltalsvärden från 0 till range-1. range(4)==[0, 1, 2, 3]

for i in range:(start,stop): tar heltalvärden från start till stop-1

for i in range:(strt,stp,step): tar heltalsvärden från start till stop-1 med steglängden step.

for i in list: Variabeln använder listvärdena från det första värdet till det sista.

Det finns ingen end-i en loop-sats. Det är indenteringen, dvs indraget till höger som gör det möjligt att markera slutet på loopen.

Genomförande

Implementering: Du ska skapa ett skript för att förstå vad en loop är och en iterationsprocess.

• Starta ett nytt skript och namnge det "LOOP"
• Starta en tom lista med satsen b=[ ]. I Python-språket placeras elementen i en lista mellan [ ], åtskilda av kommatecken.
• Tryck på f1 (Fns...) och välj från Ctl-menyn, alternativ 4: for i in range (size)
• append-satsen gör att du kan slutföra en lista. b.append (i**2) stegar b-listan med i2. För varje värde på i så placeras värdet på i² i slutet av i²-listan.
• Variabeln varierar från 0 till och med 4 vilket motsvarar 5 värden.

Lärarkommentar: Tänk på att, loopräknare alltid startas från 0. Instruktionen gäller för listorna. För att nå den, så trycker man på F1 (Fns ...),och väljer sedan listmenyn och slutligen 6: .append (x). 

Tryck nu f4 för att köra skriptet.

I konsolen (shell) ber du sedan om visning av b.

Lärarkommentar: I en loop eller instruktion med en indentering är alla indenterade inmatningar ”för hand” ett kommando som är en del av loopen. Slutet av loopen markeras med avslutningen på indenteringen.

Låt oss tillämpa vår kunskap:

Här kommer nu en liten berättelse.

Inuti ett slott finns en kista full av guldmynt. För att komma ut från slottet måste du ta dig igenom fem dörrar, var och en skyddad av en vakt. De låter dig passera så länge du uppfyller deras krav. Här är vakternas krav:

”För att kunna gå ut genom dörren måste du ge mig hälften av dina mynt plus ett halvt mynt”

Vad är det minsta antalet mynt du borde ta med dig från kistan, så att du kan behålla minst ett för dig själv när du kommer ut från slottet?

När man har gått igenom 5 dörrar ska man alltså ha 1 mynt kvar. Det måste ju betyda att man ska ha 3 mynt innan man passerar den sista dörren. Man ska ju ge bort hälften av 3 mynt + ett halvt mynt och det blir ju 2 mynt och då har man ett mynt kvar.

Så här kan man fortsätta och räkna ut antalet mynt man ska ha innan man passerar dörr 4, dörr 3 osv. Vi räknar här baklänges!

Här är ett algebraiskt uttryck som beskriver relationen mellan antalet mynt a_n man ska ha vid en dörr och den föregående dörren. Vi kallar antalet mynt för a.

a_n = 2·a_n-1 + 1

Så här då vårt skript ut. Se till att du har indrag enligt skärmen

Ska du ha ett mynt kvar efter 5 dörrar så måste du ha 63 mynt från början. Vi visar också körningar när man passerat 1, 2, och 3 dörrar.

Ändra nu i skriptet och gör nu körningar när antalet kvarvarande mynt efter passage av 5 dörrar ska vara 2 respektive 0! Vad får du för resultat?

Lärarkommentarer: Svaret på den sista frågan ovan är 95 dörrar resp. 31dörrar. Nämn för eleverna att vid körning kan variabeln skatt() kopieras in på skärmen genom att trycka på tangenten ½.
Den här uppgiften finns som en särskild aktivitet för TI-Nspire^TM. Här finns också ett antal andra bra tillämpningar med upprepade beräkningar.
Gå till https://ti-resurser.com/materialdatabas och sök på upprepade beräkningar. De flesta beräkningar (utom de rent algebraiska) kan du utföra med TI-84 Plus CE-räknaren också.

I den tredje övningen i enhet 2 får du lära dig hur du på ett enkelt sätt kan upprepa tilldelningar.

Syfte:

• Hur man använder kommandot while
• Exempel på hur man använder while i enkla situationer

Antag att du vill upprepa en serie kommandon ett antal gånger men du vet inte i förväg hur ofta. Då kan du använda kommandot while.

Här är vad kommandot gör:

Så länge ett visst villkor gäller, fortsätt att upprepa

Vi ska nu skapa ett program för följande problem:

Kasta en tärning och upprepa tills en sexa kommer upp.

Det går inte i förväg att veta hur många gånger du måste kasta tärningen. Öppna nu ett nytt pythonprogram och ge det ett namn. Eftersom vi ska använda slumptal, behöver vi först slumptalsmodulen ”from random import”. Den ska vi sätta in i programmet först. Välj F1 (Fns...) sedan Modul och därefter 2: random. Du kan också trycka på tangenten och sedan 2:random.

Vi kommer att behöva två variabler i programmet. Variabeln n som håller reda på antalet kast och variabeln x som håller reda på vad som kastas (1 t.o.m. 6). Vi ger båda variablerna värdet 0 från början.

Därefter lägger vi till mallen för while. Tryck på f1 (Fns…) och välj alternativ 8:while condition. Villkoret blir ”inte lika med 6” vilket kan skrivs som != i Pythonspråket. Upprepning ska alltså ske tills d får värdet 6.

while-blocket innehåller två tilldelningar. Först ska vi ha ett slumptal d mellan 1 och 6 och sedan ska vi öka räkneverket n med 1. Får vi nu 6 som resultat vid alstringen av slumptalet avslutas körningen och vi får en utskrift av hur många gånger vi fick kasta tills en sexa kom upp.

Om vi nu kör programmet ett antal gånger så får vi lite olika värden på n.

Om du ska köra programmet flera gånger så kan du trycka på f3 (Tools) och välja 1:Rerun last Program.

• Vi ska nu bygga på programmet så att vi inte bara gör ett kast utan ett stort antal kast och där vi sedan beräknar medelvärdet från de många kasten.
• Först så att själva kastet läggs i en funktion ”tills en sexa kommer upp”. Vi kallar denna funktion tärning(). Om du anropar denna funktion så kommer den att rapportera antalet kast.
• Om vi sedan t.ex. anropar denna funktion 500 gånger, adderar resultatet och dividerar denna summa med 500 så får vi ett medelvärde.

• Vi lägger alltså till en for-loop som gör denna upprepning 500 gånger.
• Då måste vi först lägga till en ny variabel, summa, som har startvärdet 0 från början.
• I programmet så körs for-loopen 500 gånger och summan uppdateras efter varje kast. Till sist så beräknas medelvärdet som summan/500.

Lärarkommentar: Vi människor och programmerade datamaskiner har minne och vet att det t.ex. ska bli ungefär lika många sexor som ettor om vi kastar en tärning många gånger. Det vet inte tärningen eller kronan när den hänger i luften. I ett äkta slumpförsök finns det ingen- ting som heter minne. Allt börjar om igen när vi kastar tärningen nästa gång.

Räknaren kan alltså egentligen inte generera riktiga slumptal. Den an- vänder faktiskt en formel för att generera en sekvens av tal som verkar vara helt slumpmässiga. Varje tal i sekvensen beror på det föregående talet. Detta betyder då att hela sekvensen av tal beror på det första talet. Detta tal kallas för en kärna. Om du låter två räknare få samma kärna, t.ex. talet 273, så genereras samma sekvens. Det kan väl knap- past kallas slumpen.

Normalt så behöver man dock inte tänka på detta eftersom räknaren hela tiden använder det sista slumptal som har alstrats som en ny kärna. I den övre skärmbilden har vi två gånger lagrat talet 273 som kärna (med kommandot 173  slump. Vi får samma sekvens av tal båda gångerna. I den nedre skärmbilden har vi lagrat talet 273 bara en gång och vi ser att vi får olika sekvenser av tal varje gång.

För denna tillämpningsaktivitet i kapitel 2 ska vi skriva ett program som löser en allmän andragradsekvation. Det finns tre möjliga lösningar till en ekvation som skrivs på formen:

a · x² + b · x + c = 0

och vi ska använda olika villkor för de tre olika lösningarna. Vi börjar med lite teori.

Syfte:

• Använda If… elif… else-kommandon i två program som båda löser andragradsekvationer.

Den allmänna andragradsekvationen a · x² + b · x + c = 0 kan skrivas om som

Omskrivning och första kvadreringsregeln ger nu

Vi drar roten ur båda leden

Vi subtraherar nu till sist både leden med b / 2a :

Uttrycket ovan kan skrivas om genom att först sätta termerna under rottecknet på gemensam nämnare.

Uttrycket under rottecknet, b² - 4ac kallas för diskriminanten och det ska vi använda i programmet.

• Om diskriminanten är mindre än noll finns det ingen lösning i reella tal eftersom man inte kan dra kvadratroten ur ett negativt tal.
• Om diskriminanten är noll finns det bara en lösning, nämligen - (b / 2 · a). Vi har då en dubbelrot.
• Om diskriminanten är större än noll har vi två lösningar enligt formeln ovan.

När man befinner sig i editorn och ska göra en körning så trycker du på tangenten . Överst i fönstret så står det då lösandra(). Tryck på Ok och fyll sedan i argumenten i funktionen, t.ex. lösandra(1,2,1). Tryck sedan på . Då får vi en utskrift på tre rader. Överst diskriminantens värde, sedan antalet rötter och till sist rötterna värde.

Vi ska nu titta på ett annat program som också beräknar rötterna till en andragradsekvation. Det innehåller också if…elif…else för ingen, en respektive två lösningar till ekvationen. Här har vi dock ingen funktion utan istället tre inputsatser.

I input-satser vill programmet hämta in information från användaren. Input-satser läser in allt som text. Vi tar ett exempel:

Vi skriver in det korta programmet till höger och kör det. Du skriver in talet 5.7 t.ex. Du kommer att få svaret 5.75.7 och inte 10. Det beror på att input läser in allt som text.

För att verkligen få multiplikationen utförd så kan du skriva

a = float(input("Mata in…)).

Alltså: Genom att omge input() med float() eller int(), så omvandlas svaret till ett decimaltal eller heltal.

På nästa sida kommer nu det andra programmet som löser andragradsekvationer.

Här är nu programmet, som inleds med tre input-satser. Float som vi använder här är den datatyp som används för decimaltal. På svenska säger man flyttal. Precis som det föregående programmet använder vi här if…elif…else.

Ändra nu i programmet så att bara två decimaler i de beräknade värdena skrivs ut. Man använder då kommandot round i printsatserna, t.ex.

print(round(rot1,2))

Du hittat round genom att tryck på f1 (Fns..) och sedan välja Type.

I den första lektionen i kapitel 3 använder du dina kunskaper om algoritmer och Pythonspråket för att lära dig:

• Intervallhalveringsmetoden i algebra och i sannolikhetslära
• Söka efter lösningar till en tredjegradsekvation

Syfte:

• Implementera en avgränsad while-loop
• Visa på två metoder för att lösa ett problem

Vi skall i denna övning också lösa en ekvation, dvs. finna nollställen till funktionen. Vi ska titta på något som kallas intervallhalve-ringsmetoden. Som exempel har vi valt tredjegradsfunktionen

f(x) = 0,03x³ - 0,3 x² - 0.6x + 1,45

Denna ekvation kan vi inte lösa exakt med elementära metoder.

Vi börjar med att rita grafen till funktionen för att få en uppfattning om var nollställena är placerade. En tredjegradsfunktion har i allmänhet tre nollställen.

Mellan varje skalstreck är det 5 längdenheter. Vi väljer att titta på det nollställe som ligger längst till höger. Nollstället ligger mellan 10 och 15.

För att förklara den metod vi kommer att använda så visar vi samma metod i ett enklare sammanhang:

Detta resonemang med intervallhalveringar ger att man maximalt behöver 10 gissningar eftersom 2¹⁰ = 1024. Man kan också skriva att (1/2)¹⁰ = 1/1024.

Beskrivning av intervallhalveringsmetoden

Nu ska vi bli lite mer formella och försöka göra en bra algoritm av detta som passar till vårt problem med funktionens nollställe.

Metoden bygger på följande resonemang: Om en funktion växlar tecken i intervallet [a, b] och om funktionen är kontinuerlig så är funktionen noll någonstans i intervallet. Man har då minst ett nollställe i intervallet. Delar man nu intervallet i mitten så att man får två nya intervall. Då kommer vi fortfarande ha teckenväxling i något av de nya intervallen. Detta intervall kommer då att innehålla minst ett nollställe och vi fortsätter med detta intervall och upprepar resonemanget.

Vi förutsätter också att funktionen f(x) är kontinuerlig. Man börjar med ett intervall [a, b] där f(x) växlar tecken, dvs. där f(a)·f(b)< 0.

Eftersom f(x) är kontinuerlig så finns det minst ett nollställe i intervallet [a, b]. Man bildar nu mittpunkten m = (a+b()/2 och delar alltså intervallet i två lika långa delintervall [a, m] och [m, b]. Se figuren. Det delintervall där funktionen växlar tecken är det man är intresserad av. Man behåller alltså [a, m] om f(a)·f(m) < 0, annars behåller vi [m, b]. I detta fall behåller vi alltså [a, m]. Se figur. Sedan går man vidare och delar detta intervall på mitten igen.

Vi gör nu en förstoring och tittar nu på intervallet [10, 12.5] och vi ser att nollstället finns i den högra halvan, dvs i intervallet [11,25, 12,5]. Så här håller man på tills man har ett intervall som är tillräckligt litet och man har uppnått önskad precision i beräkningarna.

Förberedelse för skapandet av ett skript

1. Först ser man att nollstället finns mellan 10 och 15.
2. Man tar nu medelvärdet av 10 och 15 och ser nästa gång att nollstället ligger mellan 10 och 12,5.
3. Nu tar man medelvärdet av 10 och 12,5 och då ser man (nedre figuren) att nollstället ligger mellan 11,25 och 12,5.
4. Så här fortsätter man med allt mindre och mindre intervall.

Efter den här ganska långa genomgången kan man börja skriva in sitt skript.

Först definierar man sin funktion och sedan definierar man en funktion med argumenten a, b och prec. a och b är gränserna i intervallen och prec är precisionen, dvs differensen mellan a och b.

Så länge som (while) avståndet b-a är större än den precision man vill ha så utförs beräkningar av medelvärde och sedan kommer if …else-sats med beräkning av vilket tecken (positivt eller negativt värde) som f(a)*f(m) har. Är det negativt så har vi en teckenväxling och nollstället ligger i det vänstra delintervallet. Är det positivt så ligger nollstället i det högra delintervallet.

Tips för inskrivning: Olikhetstecken kommer du åt genom att trycka   . while finns i kontrollmenyn. Tryck f1 (Fns..) och sedan Ctl. Där finns också villkorsinstruktionen if .. else.

Tryck nu på f4 (Run) för att köra programmet. Trycka på och välj dela() och tryck sedan på Ok. Fyll nu i argumenten (10,15, 0.001). Tryck sedan på .

Nu får vi beräknade värden på ett smalt intervall. Med två korrekta decimaler blir svaret 11.38.

En variant som gör samma sak

Istället för att ge precision kan vi arbeta med ett antal steg. Istället för en while-sats så har vi nu en for i in range(step)-sats. Vid körning så skriver man t ex dela(10,15,20). Se resultat i skärmbilden till höger.

Med räknarens inbyggda verktyg för bestämning av nollställe får vi detta resultat.
Man plottar då grafen och trycker sedan på  [ calc ]. Välj sedan alternativ 2. Vi får resultatet 11,383905

Lärarkommentar: På första sidan i denna övning så visade vi på strategin för att hitta en sida i en bok på 1024 sidor. Här har vi ett skript som fungerar på samma sätt. Användaren får alltså själv göra intervallhalveringar uppåt eller nedåt. Här har vi 100 som övre gräns men användaren kan ju själv bestämma denna gräns.

Vi har fuskat lite och satt ihop två skärmar på räknaren för att kunna visa hela programmet.

Här har vi en körning. Det räckte med 5 gissningar här.

Visa detta skript för eleverna och gör några körningar. För att visa principen kan man börja med ett fåtal tal. Den uppgift eleverna får här är att skriva klart skriptet. Vid körning ska det se ut som det visas på skärmen nedan.

Vi visar här bara den översta delen av skriptet. Eleverna uppgift är alltså att skriva klart! När de är klara och har provkört så ska de göra ett antal körningar och redovisa statistik på antal gissningar.

I den andra övningen i kapitel 3 kommer du att upptäcka hur du upprepar en uppsättning instruktioner genom att använda den avgränsade loopen FOR.

Syfte:

• Använda en funktion
• Upptäcka och implementera den avgränsade loopen For
• Använda for-loopen enkla exempel

Slumpmässigt urval

En ogenomskinlig bag innehåller sex röda och fyra gröna bollar. Vi drar slumpmässigt en boll från påsen, noterar dess färg och lägger sedan tillbaka den i påsen.

Programmera en funktion som simulerar experimentet med bollarna med en slumpmässig variabel.

• Vilka är de möjliga värden variabeln kan ha?
• Vi vill skriva ett skript som kan skilja de röda bollarna från de gröna med hjälp av ett test.

Starta ett nytt skript och döp det till "DRABOLL".

När du arbetar med slumptal krävs inläsning av ett bibliotek för arbete med slumptal. För att göra detta, tryck på f1 (Fns...) och välj i menyn Modul och sedan 2: Random....

Skriv in skriptet här till höger i editorn och se till att ha de indrag som visas. Det är oerhört viktigt i Python.

Skriv in skriptet här till höger i editorn och se till att ha de indrag som visas. Det är oerhört viktigt i Python.

Till höger ser vi konsolen några körningar av det korta skriptet. Om slumpvariabeln X får värdet 1 till och med 6 visas ”grön”. Och om slumpvariabeln X får värdet 7 till och med 10 fås svaret ”röd”.

Lärarkommentar: Detta skript kan modifiera för vilket antal bollar som helst. man kan t.ex. definiera färg(n,r) där n är antalet bollar och r är de röda bollarna.

Vi ska nu tillämpa våra kunskaper genom ett exempel på stickprov och beslutsfattande utifrån stickprovet.

En undersökning genomfördes vid lanseringen av en ny show som föreslagits av en fransk konstnär. Denna undersökning som genomförts i en stor stad visade att två tredjedelar av de som såg showen gillade den. Konstnärens agent ansåg att hela den franska befolkningen hade samma uppfattning. Han beställde en undersökning från ett opinionsinstitut för att kontrollera detta.

Befolkningsstudie:

Vid den statistiska undersökningen måste undersökningsinstitutet skapa en funktion som simulerar svaret på situationen.

Vi ska nu skapa denna funktion i enlighet med följande specifikationer:

• Showen uppskattades med en sannolikhet p = 2/3.
• Showen uppskattas inte med sannolikheten p = 1/3

Starta ett nytt skript och namnge det STPROV (förkortning av stickprov)

Skriv den här funktionen i editorn och testa den flera gånger genom att trycka på f4 (Run) och tryck sedan på och väljs sedan fråga() genom att bekräfta med att klicka Ok. Tryck sedan på . Du får svaret 1 eller 0.

Upprepa nu detta ett antal gånger.
Det går fortast om du trycker på  och trycker på  . Om du gör detta många gånger bör du få ettor ungefär två tredjedelar av gångerna.

Göra en stickprovsundersökning med storleken n

Opininionsinstitutet vill nu göra en simulering där man gör undersökningar med olika värden på storleken n. För att göra detta så måste vi skapa en stickprovsfunktion i skriptet som frågar efter stickprovsstorleken n.

• Vi börjar med att skapa en tom lista L.
• Vi fyller denna lista genom att använda funktionen fråga().

Lärarkommentar: Med Python-språket kan du använda en funktion för att fylla en lista som ökas i steg av en For-loop, som argument i listan. Det här exemplet kan uppnås utan användning av listor. Skriptet måste då ändras något genom att listinstruktionerna ersätts med avgränsade loopar som stegvis ökar en variabel. 

Vi ska nu prova stickprovsfunktionen genom att göra ett test med storleken 30.

• Tryck på Run och tryck sedan på tangenten [ vars ] och välj sedan stickprov(). Bekräfta med Ok.
• Fyll i stickprovsstorleken och tryck på [ enter ]. Nu får vi en lista med nollor och ettor på skärmen.

I exemplet på skärmen får vi 17 ettor. Kör nu några gånger och räkna antalet ettor.

Vad händer om vi kör skriptet 1000 gånger?

Vi får hela skärmen full av nollor och ettor. Vi måste hitta ett sätt att titta på andelen ettor. Istället för att returnera listan med satsen return L ska vi nu istället returnera ett värde. Värdet vi ska ha utskrivet vid körning är andelen ettor i listan.

Tryck f1 (Fns…) och sedan List. Där finns nu ett antal funktioner för listor. Det uttryck vi nu ska skriva är

return sum(L)/len(L)

och instruktionen sum ger den aritmetiska summan, dvs vi adderar alla ettor. len ger antalet element i listan.

Körning av programmet

Tryck på Run och sedan på för att välja stickprov(). Titta både på små och stora stickprov och kör programmet ca 10 gånger. Det går snabbt om du efter varje körning trycker på  för att göra en ny.

Vad kan du säga om resultaten? Vilka slutsatser kan du dra?

Lärarkommentar: Vi ska nu titta lite närmare på osäkerheten bakom stickprov på andelar. Man stöter ofta på detta i samband med undersökningar om partisympatier.

Vi antar att stickprovsstorleken är 1000 personer, ungefär vad man brukar ha i opinionsundersökningar. Frågan är vad man kan förvänta sig om hur nära andelen i stickprovet kommer andelen i hela befolkningen.Vi kallar den för p.

Vi börjar här med teorin och genomför sedan några undersökningar med slumpen. Man kan visa att i 19 fall av 20 (95 % konfidensintervall) så hamnar stickprovets andel i intervallet

Vi får alltså då en felmarginal på 3 %. Av uttrycket ser vi att felmarginalen beror både på andelen och stickprovsstorleken.

Vi har gjort en plottning för p = 0,65 i marginalen. Man ser hur osäkerheten ökar kraftigt när stickprovsstorleken minskar.

På https://ti-resurser.com/materialdatabas finns en aktivitet, Opinionsundersökning, för TI-Nspire som ger en ordentlig av teorin bakom stickprovsundersökningar.

I den tredje övningen i kapitel 3 ska vi göra flera simuleringar som illustrerar Stora talens lag i ett praktiskt sammanhang. Vi behöver då en slumpgenerator, därför måste biblioteket för slumptal importeras.

Syfte:

• Använda en funktion
• Implementera den avgränsade loopen For i flera exempel
• Använda villkorssatser

I statistik och sannolikhetsteori är Stora talens lag en sats som beskriver resultatet av att upprepa samma experiment ett stort antal gånger. Denna lag anger att om samma experiment, som ska vara oberoende av varandra, upprepas ett stort antal gånger måste genomsnittet av resultaten av försöken ligga nära det förväntade värdet. Resultatet kommer också närmare det förväntade värdet i takt med att antalet försök ökar.

Exempel: Ett enkelt exempel på lagen är att kasta tärningar. Ett kast innebär sex olika händelser med lika stora sannolikheter. Det förväntade värdet (förkortas ofta EV för Exepected value) av tärningshändelsen är:

(1 + 2 + 3 + 4 + 5 + 6) / 6 = 3,5

Om vi bara kastar en tärning några få gånger kan genomsnittet av de erhållna resultaten vara långt ifrån det förväntade värdet. Låt oss säga att du kastade en tärning tre gånger och resultatet blev 3, 6, 6. Genomsnittet av resultaten blir då 5. Enligt lagen om stora tal, så blir det genomsnittliga värdet om vi kastar tärningarna ett stort antal gånger att vara närmare det förväntade värdet på 3,5.

I denna övning ska vi göra en del experiment med fyra tärningar och titta närmare på sannolikheten experimentellt att få en viss totalsumma.

Kastar du en tärning så är ju sannolikheten 1/6 för varje utfall 1 till och med 6. Kastar du två tärningar så ser utfallen för summan ut som i diagrammet till höger. Man ser direkt att summan 7 kan man få på 6 sätt: 1+6, 2+5, 3+4, 4+3, 5+2, 6+1. Sannolikheten blir alltså 6/36. Man kan också räkna ut maxsumman som 2 gånger 3,5.

För summan 6 och 8 blir sannolikheten 5/36, för summan 5 och 9 blir den 4/36 osv. Se diagrammet i marginalen som visar de olika sannolikheterna.

Nog med grundläggande teori om sannolikheter. Nu ska vi se hur vi kan skriva skript som simulera kast med 4 tärningar.

Simulering

Vi ska nu skriva ett program som utför ett antal simuleringar av kast med fyra tärningar. Vi ska sedan beräkna summan av prickarna vid varje kast och titta på när summan är mindre eller lika med 16. Om summan är <=16 så ökar värdet på ett räkneverk med 1. Satsen räkneverk=räkneverk+1 ökar värdet.

• Då vi ska arbeta med slumptal importerar vi först biblioteksmodulen random import. Tryck f1 (Fns…) och välj sedan i menyn Modul och sedan 2:random.
• Vi definierar sedan funktionen sim1(n) där n är antalet upprepningar av försöket. Tryck f1 (Fns…) och välj func och sedan 1 def function().
• Sedan skriver vi in startvärdet 0 för vårt räkneverk.
• Sedan kommer for-satsen som vi använder för att (upprepa en del av programmet n antal gånger. Vi skriver alltså här sim1(100) om vi vill köra 100 gånger.
• Nu kommer if-satsen där vi undersöker om totala antalet prickar är ≤ 16. Om det är sant så räknas räkneverket upp.
• Till sist beräknas kvoten räkneverk/n som är andelen kast där totalsumman blir ≤ 16.

För att köra programmet så trycker du Run och på tangenten och väljer sedan sim1() och skriver in värdet på n, t.ex. 200. Sedan trycker du på . Kör några gånger med samma värde och se hur det beräknade värdet varierar. Tryck på för att snabbt göra många körningar.

Du kan göra körningen ett stort antal gånger, t. ex. 2000. Kör några gånger. Diagrammet visar de värden vi fick när vi gjorde detta 10 gånger. Vi får värden mellan 0,751 och 0,775 ca.

Lärarkommentar: Diskutera med eleverna skillnaden mellan att skriva

randint(1,6)+randint(1,6)+randint(1,6)+randint(1,6)<=16

som vi gjorde i skriptet och

randint(1,6)*4<=16 eller randint(4,24)

Be dem att skriva in enligt ovan och sedan tolka resultatet.

Exakt beräkning

När vi gjorde ett antal simuleringar fick vi ett medelvärde på ca 0,76. Nu ska vi skriva ett ganska tufft program som gör exakta beräkningar. Det åstadkommer vi genom fyra for-satser (en för varje tärningskast). Det som händer är att programmet går igenom alla kombinationer och tittar vilka som ger 16 prickar eller mindre. Om man skulle göra detta utan någon hjälp av räknare eller dator skulle det ta väldigt lång tid.

Vi kör nu programmet en gång och ser vilket resultat vi får. Sammanlagt finns det 6⁴=1296  kombinationer som ger en totalsumma som är 16 eller mindre. Totalt finns det kombinationer. Detta ger att sannolikheten att få 16 eller mindre är

986/1296 ≈ 0,7608

Cirka tre av fyra gånger så får du alltså i genomsnitt en poängsumma som är 16 eller mindre.

Tabellen nedan visar sannolikheterna för att få totalsumman 4-24. Lägg märke till symmetrin för antalet kombinationer omkring 14 i tabellen. Pröva nu också andra totalsummor och se att det stämmer med tabellen.

Fördjupning:

Om vi plottar totalsumma mot sannolikheten för 4 respektive 6 kast så ser det ut så här. Vi ser tydligt att fördelningen alltmer närmar sig en normalfördelning när antalet tärningar ökar.

I denna övning ska vi undersöka s.k. primtal men innan dess så gör vi först en liten genomgång av faktorisering. När man förenklar ett bråk så förkortar man bort gemensamma faktorer i täljaren och nämnaren:

Men hur kommer man på att 65 = 5 · 13 och hur vet man att 13 och 5 inte har någon gemensam faktor?

Att skriva 65 som 5 · 13 kallas att faktorisera 65. Vissa tal kan faktoriseras på flera sätt, till exempel

24 = 6 · 4 = 2 · 3 · 2 · 2

De minsta tänkbara faktorerna (större än ett) kallas primtal. Talen 2 och 3 är alltså primtal.

Definition: Ett primtal är ett heltal större än ett som inte kan faktoriseras i mindre positiva heltal. Om man kan bryta ner ett tal i mindre faktorer är det alltså inte ett primtal. De första primtalen är 2, 3, 5 och 7. Jämna tal (utom 2) är inte primtal eftersom de kan divideras med 2. I marginalen visar vi alla primtal mindre än 100.

Vi ska nu titta på två program som gör faktoruppdelning. Det ena lite mer omfattande programmet arbetar med listor. Vi behöver här förklara betydelsen av symbolen %. Du hittar den genom att trycka f2 (a A #)

I konsolen (Shell) pröva nu att skriva 24%2 resp. 25%2. I det första fallet får du resultatet 0 och i det andra fallet 1. Det som beräknas är resten vid division av två heltal. 24 dividerat med 2 ger ju svaret 12 medan 25 dividerat med 2 ger 12 och resten 1.

En annan viktig sak när man ska kontrollera om ett tal n är ett primtal är att man bara behöver dividera med tal som är mindre än  √ n  Varför då?

Vi prövar nu denna sats på några tal. Roten ur 83 är ungefär 9 och roten ur 133 är ungefär 11. Vi gör nu beräkningarna utanför Python-appen och vi har lagt in talen i nämnaren som listor. Observera att vi bara behöver kontrollera med primtal i nämnaren. För att omvandla decimaltalen i svaret till bråk så lägger vi till kommandot Bråk som du når om du trycker på tangenten .

Vi ser att 83 är ett primtal men att 133 inte är det. Vi kan dela upp 133 i faktorerna 7 och 19: 7 · 19 = 133

Någon enkel metod för att faktorisera tal finns inte utan man måste dividera med alla mindre faktorer och kontrollera om divisionen går jämnt upp. Jobbigt att göra för hand men nu kan vi skriva ett program som fixar detta.

Här är nu ett enkelt program som löser uppgiften med faktoruppdelning av 133. Pröva gärna med några större men inte alltför stora tal. 133 går bra men när vi försöker faktoruppdela 9737 får vi svaret nedan till höger efter väldigt lång tid (flera minuter!). Hur ska vi tolka det? Efter en del funderande kommer du säkert på att den korrekta primtalsppdelningen 7·13·107 är Se bilderna nedan.

 

Vi prövar nu ett annat program som är lite mer sofistikerat och där man använder listor och operatorn %. Vi har fuskat lite här och satt ihop två skärmar till en.

Om vi nu kör programmet får vi resultatet nedan. Vi får samma resultat som förut men nu kommer faktorerna i stigande ordning och så får vi förtydligande text också. Dessutom är det betydligt snabbare.

Lärarkommentar: Ta upp de nya instruktioner som inte förekommit i tidigare övningar. Det gäller t.ex append och reverse för listor.

Append lägger till en post i en lista. Exempel:
listaX=[3,5,7]
listaX.append(11)
print(listaX)
[3,5,7,11]

Reverse bytter ordning på posterna i en sekvens. Exempel:
listaX=[3,5,7]
listaX.reverse()
print(listaX)
[7,5,3]

Hitta primtal

Vi övergår nu till att koncentrera oss på tal som är primtal och inte faktoruppdelning. Det första programmet testar bara om det inmatade talet är ett primtal. Enklare än så här kan det knappast bli.Pröva tal av olika storleksordning. Vi har importerat matematikmodulen from math import. Den behövs för att vi vill använda kvadratsrotsfunktionen sqrt().

Tänk också på att operatorn % beräknar resten vid division av två tal.

Tryck på tangenten och välj sedan ärprim() när du vill göra en körning. Skriv sedan i det tal du vill kontrollera inom parenteserna och tryck på .

Det andra programmet har en inputsats och användaren uppmanas alltså att mata in ett tal. Vi måste då lägga in int() i satsen för att det ska fungera. Om man inte definierar att det är tal kommer den inte att kunna utföra beräkningar med värdena. Alltså: För att definiera det som ett heltal skrivs det in enligt denna mall:

heltal = int(input(”Skriv nu in heltalet”)).

Dessa två program kan bara kontrollera ett tal i taget. Det naturliga när man håller på med primtal är att få en lista med ett antal primtal inom ett intervall t.ex.

Här är ett sådant kort program som printar ut primtal inom ett intervall. Printsatsen har med instruktionen end=” ” för att primtalen ska fyllas på vågrätt istället för radbrytning mellan varje tal. Vi har här

Lärarkommentar: På denna sista sida så visar vi hur man kan arbeta med primtal och faktoruppdelning med TI-Nspire®. Om du har möjlighet så visa gärna detta för eleverna. Aktiviteten finns i TI:s materialdatabas och heter Undersöka primtal.

Här några skärmar från denna aktivitet. Funktioner för faktoruppdelning och undersökning om ett ett tal är ett primtal är alltså inbyggda i TI-Nspire.

I den här första övningen i kapitel 4 får du lära dig att skriva och använda en instruktion för att göra grafiska representationer i Python. Du kommer också att lära dig att rita ett diagram och konfigurera skärmen på räknaren.

Syfte:

• Upptäcka ti-plotlib-modulen
• Representation av punkt och linje
• Göra en grafisk presentation

1: Biblioteket eller modulen ti-plotlib

Om du vill utföra en grafisk representation när du kör ett skript måste skriptet kunna förstå de grafiska instruktionerna. Det är därför nöd-
vändigt att "lägga på" de grafiska funktionerna inom ett bibliotek ti-plotlib.

Starta ett nytt skript genom att namnge det K4OVN1 och inkludera ti-plotlib modulen. Du hittar den under f1 (Fns...) sedan Modul och alternativ 5. Välj sedan 1: import ti_plotlib as plt.

För den här första delen ska du skriva ett skript som visar en punkt vars koordinater är kända. Sedan ska du ändra skriptet så att det hittar din punkt i en markör och dessutom ändrar dess färg.

För att slutföra den här första övningen, ska du också namnge koordi-natsystemets axlar och ge en titel till ”grafen”.

Definiera nu en funktion med koordinaterna för punkten som argu-ment och lägg sedan till en instruktion så att punkten visas.

• Rensa först din skärm med hjälp av instruktionen plt.cls () som du hittar i modulen ti_plotlib i menyn.
• För att rita punkten, välj instruktion 6: Plot belägen i ritmenyn (Draw) för ti_plotlib-modulen.
• Välj också önskad markering för punkten.

Fortsätt skriptet genom att begära visning av punkten genom att välja plt.show_plot() (instruktion 9 i ti-plotlib-modulen).

• Be nu om körning av skriptet (tryck f4). Tryck sedan på [vars] - för att komma åt punktfunktionen punkt().
• Ge koordinaterna för en punkt och observera sedan skärmen.

Tryck på [clear] " för att komma ur den grafiska skärmen, sedan på [vars] för att hitta listan över variabler i skriptet.

Ändra koordinaterna för din punkt (t.ex.till punkt(10,10) och upptäck att punkten inte längre syns på skärmen.

2: Förfina din representation

Inkludera plt.cls()-satsen under funktionsdefinitionen för att undvika att menyraden längst ner läggs ovanpå din grafiska representation.

Från de olika alternativen i inställningsmenyn för modulen ti_plotlib så ska du lägga till i skriptet de instruktioner som gör det möjligt att:

• Ställa in grafikfönstret så här:
  Xmin -10; Xmax - 10; Ymin - -10 och Ymax - 10 

          Du väljer då alternativ 4:Window)

• Visa ett rutnät. Välj alternativ 3: grid. Typ av rutnät väljer du själv.
• Visa axlar (alternativ 6:axlar)
• Ställa in färgen på punkten. Välj Draw i menyn längst upp och sedan väljer du 1: color (r,g,b).

Kör skriptet och observera ändringarna. Du bör få en skärm identisk med den till höger.

Ändra skriptet igen för att ge axlarna ett namn. Till exempel ("x-axel"  och  "y-axel").

Det gör du genom att inkludera en rad, plt.labels, i skriptet (valfri plats). Den finns som alternativ 7: Labels() på menyn Setup i tiplot-
modulen.

Man kan också lägga till en titel med instruktionen plt.title.

Ska man ha med tecken å, ä eller ö får man gå till teckenpaletten genom att trycka på f2 (a A #).

Du kan också komplettera ditt skript ytterligare genom att t.ex. skriva en instruktion som ritar ett linjesegment. Se skriptet till höger.

I denna andra övning i kapitel 4 ska du lära dig att grafiskt representera en funktion med hjälp av biblioteksmodulen ti_plotlib.

Syfte:

• grafiskt representera en funktion
• repetera notationen för en av- gränsad loop
• Göra inställningar för att visa grafik

Vi ska här skapa ett skript med hjälp av biblioteket ti_plotlib, som gör det möjligt att spåra i den grafiska representationen av en funktion g av x med värden i intervallet [a, b] och med N del-segment.

Skriptet du kommer att skapa är generellt så att du lätt kan skapa nya för andra exempel.

Starta ett nytt skript och döp det till KAP4OVN2

• Importera modulen ti_plotlib. Tryck på f1 (Fns...) och välj Modul och sedan 5: ti_plotlib.
• Definiera sedan funktionen g(x) = 0,2x² - 0,72x - 1.

Om du plottar denna funktion på räknaren utanför Python ser det ut som på skärmen här till höger. Vi ska se hur bilden blir efter Python-
programmeringen. Vid denna plottning har vi valt att plotta kurvan lite tjockare. Man kan välja mellan tunna eller feta linjer och linjerna kan antingen vara hela eller prickade. Grafen här på bilden är plottad med tjocka heldragna linjer.

Man kan även ställa in färgerna på rutnätet, det finns fyra olika gråa nyanser.

Nu tillbaka till programmeringen!

Vi definierar först funktionen graf med argumenten f, a, b, och N.

x-listan lx konstrueras med hjälp av en avgränsad loop (slinga), vars instruktion du når genom att trycka på f1 (Fns…) och sedan välja 4: for i in range (size) bland kontrollinstruktionerna. Listan ly beräknas från listan lx. Vi använder då instruktionen 7: for i in list.

Nu är du redo att utföra den grafiska representationen av funktionen. 

Du kan nu infoga instruktioner för att:

• Rensa skärmen: plt.cls().
• Göra inställningar för grafikfönstret:

plt.window (xmin, xmax, ymin,ymax)

• Visa axlar med axelmarkeringar: plt.axes ("on").
• Namnge axlarna:  plt.labels ("x", "y")..
• Utföra beräkningar för den grafiska representationen: plt.plot (lx,ly,"O")..
• Visa plottningen av funktionen: plt.show_plot()..

Alla satser ovan finns i ti_plotlib-modulen och i menyerna Setup och
Draw (alternativ 5). Till höger har vi satt ihop två skärmar till en skärm.Obs: Anvisningarna för att välja färg i RGB (röd, grön, blå) sker genom kodning med värden 0 till 255 för varje färg. Man får tänka på att placera instruktionen för färgerna på ett klokt sätt så att man t.ex. undviker att ha koordinataxlarna i rött.

Gör nu en körning av skriptet genom att trycka på tangenten [vars] och sedan välja graf(). Sedan kan du t.ex. välja att visa grafen för funk-tionen g i intervallet [0; 3] med 30 delsegment.

På nästa sida tar vi upp ett annat exempel som kanske är lite enklare.

Vi ska nu rita funktionen 0,3x²- 2x -2i intervallet [-10; 10].

• Starta ett nytt Pythonprogram och döp det till KP4OV2NL och importera först biblioteksmodulen i ti_plotlib.
• Först definierar vi funktionen f.
• Sedan gör vi en lista över x-koordinater (lx).
• Och sedan en lista över motsvarande y-koordinater (ly).

Listorna för x och y görs med for-loopar från kontrollmenyn (Ctl), tryck på f1 (Fns…) och välj alternativen 4 och 7 för de två satserna.
Se skärmbilden till höger:

Nu kan vi fortsätta med de olika instruktionerna för att plotta funktionen. När du exekverar skriptet plottas funktionen direkt. Du behöver alltså inte mata in några argument till funktionen.

För att göra plottningen ännu snyggare kan man skriva instruk-
tionen för lx så här:

lx=[i/5 for i in range (-50,50)]

Då plottas även punkter som för x inte bara har heltalsvärden.

Pröva detta och ändra även punkterna vid plottningen till ”.” Då kan slutresultatet bli enligt den nedersta bilden i marginalen.

I den tredje övningen i kapitel 4 får du lära dig hur du grafiskt representerar en uppsättning data och analyserar dessa data, och sedan beräknar en matematisk modell som anpassar sig till datamängden.

Syfte:

• grafiskt representera en uppsätt- ning av data
• Undersöka om det finns någon bra regressionsmodell
• Använda listor i Python

Scenario: Under en översvämning registrerade myndigheterna varje timme förändringen av den maximala vattennivån i förhållande till en referenspunkt.

Datan finns i tabellen nedan. Du ska representera data med hjälp av ti_plotlib-biblioteket och sedan leta efter en matematisk modell för att göra en extrapolering. Skälet till detta är att kunna förutsäga när vattennivån blir noll i förhållande till en referenspunkt.

T(h)	0	1	2	3	4	5	6	7	8	9	10	11	12
H((cm))	130	127	123	118	116	111	105	103	101	95	86	80	71

Implementering: Starta ett nytt skript och namnge det KAP4OVN3.

1. Importera modulen ti_plotlib.
2. Spara data i två listor, "t" och "h".
3. Förbered sedan den grafiska representationen med bland

annat följande:

• Rensa skärmen plt.cls(.
• Ställ sedan in det grafiska fönstret: xmin -5, xmax  35, ymin -25, ymax 250 genom att skriva plt.window (-5, 35, -25, 250)
• Visa axlar: plt.axes(”on”)
• Visa rutnät: plt.grid(5,50,”dot”)
• Visa den grafiska representationen av data som ett spridningsdiagram med instruktionen plt.scatter(t,h,”+”).

Instruktionerna för fönsterinställning av grafik finns i modulen ti_plotlib på menyn Setup. Instruktioner för plottning och datavisning finns på menyn Draw.

Observera att värdet noll alltid kommer med.

Kör skriptet och observera den grafiska representationen. Om allt gått bra bör du ha  fått skärmen här till höger.

Verkar alla punkter ligga någorlunda i linje?

Du ska nu söka efter den matematiska modellen med en metod man kallar för linjär anpassning eller linjär regression. Vi ska söka en linje som så bra som möjligt ligger nära datapunkterna.

För att göra detta måste du lägga till raden

plt.lin_reg(t, h,"center"11)

i skriptet så att regressionslinjen beräknas från listorna t och h och sedan visas och centreras på linje 11 på skärmen.

Till höger ser vi resultatet. Längst ner på skärmen visas den beräk-nade regressionslinjen. Vi vill nu veta när den skär x-axeln (nivån=0). Det sker när y=0 dvs vid x=132,90/4,64 » 28,6.

Genom att lägga till två instruktioner för färg i skriptet kan vi få det ännu snyggare. Vi vill få datapunkterna inkl. grafens titel i en färg och regressionslinjen inkl. den beräknade ekvationen i en annan färg. Se skriptet här till höger och grafen nedan.

Vid tillämpningen i kapitel 4 kommer du att undersöka en rörelse hos en golfboll utifrån mätningar med ett stroboskop och därefter ska du bygga en grafisk modell av rörelsen med programmering i Python, och med hjälp av biblioteksmodulen ti_plotlib.

Syfte:

• Grafiskt representera en datamängd
• Beräkna och representera vektorer i ett system som modelleras av en punkt

Problemet: Förflyttningen hos en golfboll studeras från en inspelning av rörelsen där man tog bilder med ett visst tidsintervall. Vi vill nu grafiskt visa hastighetsvektorns förändring över tiden.

Bollens position visas i tabellen med tidsintervallet 0,066 s.

I kapitel 5 får du lära dig hur du importerar data till Python-appen från räknarens listor med hjälp av modulen ti_system.

t(s)	0	0.066	0.132	0.198	0.264	0.33	0.396	0.462	0.528	0.594	0.66
x (m)	0.01	0.25	0.57	0.91	1.22	1.54	1.87	2.16	2.49	2.81	3.15
y (m)	0.015	0.34	0.681	1.01	1.297	1.559	1.768	1.95	2.08	2.158	2.193

Komma igång:

• Starta ett nytt skript och döp det till KAP4APPL
• Importera sedan de grafiska biblioteksmodulen ti_plotlib
• Mata nu in mätresultaten för x och y

Beräkna hastighetsvektorerna

Hastighetsvektorn vid tiden t ges av uttrycket

Du kan inte rita hastighetsvektorn från den sista punkten i listan, det måste du ta hänsyn till i koden.

Tips: För att göra den grafiska representationen läsbar har vi en skalfaktor på 2.

Inställning av parametrar för den grafiska representationen:

• plt.cls() för att rensa skärmen
• plt.title (”titel” lägga till en titel  till den grafiska bilden.
• plt.window (x_min,x_max,y_min,y_max)) ställa in fönstermåtten
• plt.grid (xscl, yscl, "type")  visa ett rutnät med en viss gradering
• plt.color (255,g,255) ställa in färg för visning av punkterna i banan. Här är inställningen en lika blandning av rött och blått, dvs magenta.
• plt.scatter (xlist, ylist, "type") visning av data som ett spridnings diagram
• plt.color (0.0.0) visning av axlar helt i svart.
• plt.pen ("medium," "solid") axlar som mellantjocka linjer.
• plt.labels ("x(m)," "y(m)) visning av axelbeteckningar.

Visas på rad 2 och 12 som förinställd standard.

Vektorspårningen görs som en avgränsad loop med n-1 värden.

• plt.line (x0,y0,x1,y1) för spårning av hastighetsvektorn
• plt.show() visning av hela den grafiska representationen.

Påminnelse: Bollens placering mellan tidpunkterna 𝑡₁ och 𝑡₂ kan identifieras i ett kartesiskt koordinatsystem med x_i + 𝑣𝑥_i × 𝑑𝑡 för
x-axeln och 𝑦_i + 𝑣𝑦_i × dt för y-axeln.

Kör nu skriptet. Du bör få en grafisk representation som på skärmen här.

I denna första övning i kapitel 5 kommer du att upptäcka hur man använder biblioteket ti_system för att importera och exportera listor i ett Pythonskript.

Syfte:

• Importera/exportera listor
• Repetera viktiga grafiska funktioner från Kapitel 4

Med biblioteksmodulen ti_system kan du, antingen ensam eller ihop med andra, kommunicera i båda riktningarna med grafräknaren. Alternativ 2 och 3 tar vi upp i denna övning:

2: var-recall_list (“name”)  och 

3: store_list ("name"name",var)

De övriga alternativen I detta bibliotek kommer vi att ta upp i de andra övningarna i detta kapitel.

1. Importera data från grafräknaren

a) Skapa två listor

Först kommer vi helt enkelt att skriva in data i listor (L₁ och L₂)

• Räknaren ska vara inställd i normalläge (ingen programmering). Ta först bort eventuellt innehåll i listorna genom att trycka på [2nd] [mem] och sedan 4: RensaAllaListor

• Gå till listredigeraren och placera markören i kolumnhuvudet hos L₁ som på skärmen här till höger.

I listan L₁ skapar vi nu en serie tal med värden mellan 0 och 12 för i nästa lista, L₂, grafiskt kunna representera funktionsvärden för funktionen f(x) = -x²/2 + 3x + 1.

Tryck nu på [enter]. I lista L₁ får vi nu värden från 0 till och med 12 med en differens på 0,2. Gå sedan med markören till kolumnhuvudet i lista L2, tryck på [enter] och skriv sedan

L2=-0.5L1²+3L1+1

Du skriver in L1 genom att trycka på [2nd]{1]  À. Tryck sedan på [enter]. Se skärmen till höger. Nu har vi två färdiga listor L1 och L2. Vi ska nu plotta ett spridningsdiagram utifrån data i listorna.

• Kör skriptet och kontrollera sedan innehållet i dina xaxel- och yaxel-variabler genom att trycka på tangenten [vars].
• Återkalla sedan namnet på xaxel- "listan" och validera detta.
• Gör samma sak med listan för y-värden

2. Exportera data

Skapa ett nytt skript och döp det till KAP5OV2B

Skapa först en funktion data (a,b,n).

Du skapar sedan två listor med data som grafiskt ska representeras i form av ett spridningsdiagram med värden inom ett intervall [a; b], beräknade med steglängden n.

I listan y beräknar vi kvadratroten för x-listans värden.

För att skapa dessa datalistor bygger vi en avgränsad loop efter att naturligtvis ha skapat två tomma listor.

För att exportera listorna till räknaren så är syntaxen 

store_list("list number,"name).

listnumret hos räknaren motsvarar listorna L₁ to L₆. Om vi kör skriptet och sedan trycker på tangenten [vars] och sedan skriver

data(0,20,1)

så får vi i editorn i listhanteraren (när vi lämnat Python-appen) i statistik-editorn data enligt skärmen till höger.

Om vi nu plottar våra data i ett fönster och ritar ett spridnings-diagram blir det så här:

I denna andra övning i kapitel 5 kommer du att upptäcka hur man använder biblioteket ti_system för att importera och exportera listor i ett Pythonskript.

Syfte:

• Utforska en linjär modell
• Importera resultaten av en linjär modellering till ett Pythonskript.

I den här lektionen kommer du att utföra linjär modellering med hjälp av data som tidigare angetts i räknarlistorna. Då skriver du ett skript som importerar resultaten av den här modelleringen för att använda dem för en grafisk representation, en interpolering eller extrapolering.

Scenariot: Vanligtvis är effektuttaget som störst omkring kl. 19. Det är alltså den tidpunkt när ett samhälle konsumerar mest energi. Effektuttaget mäts i watt. Du vill förutsäga konsumtions-topparna nästa helg inom ett område som ligger nära en kontrollcentral. För att åstadkomma denna prognos har du tio värden uppmätta på effektuttaget i MW klockan 19.00 vid olika utetemperaturer.

 

T (°C)	11	-5	-8	-6	9	14	4	-1	-12	3
MW	3	5.7	6.6	6.3	3.4	2.7	4	5.1	7.1	4.6

Data är inmatade i räknarens statistikeditor. Temperaturen i L₁ och effektuttaget i MW i L₂.

För att göra en modellering med linjär regression så trycker du på [stat] och sedan BERÄK och alternativ 4:Linreg(ax+b).

Om du nu trycker på [enter]  så kommer följande fönster fram och du fyller nu i enligt skärmen. Variabeln Y1 når du genom att trycka på [alpha] f4 (trace-tangenten) och sedan klickar du i Y1.

Markera därefter på Beräkna och tryck på [enter]. Nu får du ett resultatfönster på skärmen.

Den linjära funktion som beskriver hur effektuttaget K i MW beror av temperaturen t kan skrivas som

K = -0,18⋅t + 5,01

r är korrelationskoefficienten och beskriver hur väl datapunkterna är anpassade till den beräknade regressionsekvationen.

Om vi nu plottar datapunkterna och den beräknade regressionslinjen ser det ut som grafen till höger. Vi ser hur väl punkterna följer linjen.

Använda resultaten i ett Python-skript

• Starta ett nytt skript och döp det till KAP5OVN2.
• Lägg till ti_system och ti_plotlib
• Skapa två listor, temp[ ] och kons[ ]

Återkalla innehållet i L₁- och L₂-listorna i sina respektive namn.

Satsen var-recall_list("name") finns i menyn för ti_system-modulen (se kapitel 5 Övning 1).

Kom också ihåg ekvations-variabeln som är uttrycket för den beräknade linjära modellen.

Nu kan du testa ditt skript och be om visning av de olika variablerna. Tryck på [vars] och välj sedan variabel.

Vi ser att regressionsekvationen är importerad som en teckensträng.

Om du vill visa en tabell med funktionsvärden inom ett visst intervall och en viss steglängd kan du skriva in programmet nedan. Det finns en del andra sätt att göra detta på men det här är ett enkelt och kort program.

I denna tredje övning i kapitel 5 kommer du att lära dig hur man använder alternativen disp och sleep hos ti_system-biblioteket.

Syfte:

• Förstå hur instruktionerna disp och sleep fungerar
• Använda dessa instruktioner tillsamman med innehåll i andra bibliotek

1: Använda disp-instruktionen

I de första övningarna i detta kapitel fick du lära dig att importera datalistor och hur man arbetar med regressionsekvationer.

• Starta ett nytt skript och döp det till KAP5OVN3
• Importera modulen ti_system.

• Lägg till raden disp clr( )
• Om du kör skriptet kommer du alltid att få en rensad skärm och promten placeras högst upp på skärmen.

Fortsätt nu skriptet genom att infoga i en avgränsad loop och med instruktionen 7: disp_at(rad, "txt", "läge") som du hittar i modulen ti_system. Den här satsen visar texten på-rad i på skärmen och justerar den till vänster, höger eller centrerad på raden.

Kör nu skriptet och observera hur det ser ut på skärmen!

Redigera nu ditt skript enligt skärmen till höger. Du ska skapa tre strängvariabler l, c, r som därefter inkluderas i listan p (p står för position).

Vi ser att ordet “hallå” skrivs på rad 2, 3 och 4 samtidigt som det sker en förflyttning åt höger (vänster, mitten, höger). Man kan naturligtvis inte skriva något på rad 0. Det ger ett felmeddelande när man försöker köra skriptet.

disp_wait ()-satsen pausar skriptkörningen. Tryck på [enter] för att fortsätta exekveringen.

Ta bort statement disp_wait() och ersätt med viloläge (sekunder).
Detta sista påstående introducerar en tidsfördröjning av den angivna varaktigheten.

Således kommer det föreslagna ordet att visas i dess position som motsvarar värdet på p [i] -listan varannan sekund.

Instruktionen disp_cursor (1) visar markören som en vertikal linje i slutet av det ord som ska visas. disp_cursor (0) kommer inte att visa det.

2: escape()-instruktioner

• Skapa ett nytt skript och döp det till KAP5OVN3B
• Infoga instruktionen disp_clr() för att rensa skärmen.
• Definiera en funktion vars argument är ett heltal.

I en avgränsad loop kommer instruktionen if  escape (): break att stoppa körningen av skriptet om du trycker på [clear].

• Annars lagras i-värdet för loopsteget i en variabel x.

• Med en paus på 1 sekund kan du se texten "00" på skärmen.

När du kör skriptet, kommer du att se skärmen flimrar lite. Syftet med det här skriptet är att visa när du anropar c(n)-funktionen för att orsaka den motsatta visningen.

Driften av satsen while not escape() är identiskt när det gäller den tangent som ska tryckas in men här fortsätter skriptet att köras tills tangenten [clear] trycks in.

I denna avslutande övning i kapitel 5 ska du fördjupa begreppen som tagits upp i kapitel 4 och 5 för att skapa en simulator som beskriver fysikalisk rörelse.

Syfte:

• Göra en simulering utifrån stroboskopbilder
• Exportera resultat från simuleringen till listor hos räknaren

Här  ska Pythonspråket användas för att skapa en simulator av ett fysiskt fenomen. Det handlar om fritt fall.

• Skriptet bör tillåta beskrivning av en rörelse;
• Den grafiska representationen av data ska i grafik visa själva rörelsen
• Data ska exportera till räknarlistorna.

Scenario: En boll tappas utan begynnelsehastighet från höjden h. Bilderna för rörelsen tas med 60 millisekunders intervall. Figuren visar positionen för en boll som är tagen med ett s.k. stroboskop. Ett stroboskop är ett instrument som sänder ut ljuspulser för att lysa upp ett föremål så man kan studera dess rörelse eller hastighet. Ljuspulserna har sänts ut med frekvensen 20 pulser per sekund. Siffrorna visar hur långt bollen har fallit. (Källa: Wikipedia)

Du ska nu skriva ett skript som beräknar positionen för bollen vid olika tidpunkter och sedan representera detta grafiskt.

Beräkna bollens läge vid olika tidpunkter

Bollens position y m beräknas med hjälp av uttrycket där h₀ är ursprunglig höjd i m och t är tiden efter nedsläpp:

y = h₀ - 1/2 ⋅ g ⋅ t²
g = 9,81 m/s².

Skapa ett nytt skript och döp det till KAP5APPL

• Importera ti_system- och ti_plotlib-modulerna.
• Rensa skärmen.
• Skapa en funktion fall där argumentet är den ursprungliga höjden varifrån bollen släpps och som visar positionen för bollen vid olika tider.
• Skapa tre tomma listor, x, y och tid.
• Höjden (y-värden) ska beräknas var 60:e millisekund (0,06 s).
• Värdena sparas i listorna om y>0 (bollen kan ju inte sjunka ner i marken).

Skapa en avgränsad loop för att beräkna höjden hos en boll som funktion av tiden. Resultaten ska uttryckas med en noggrannhet på 1/100 och lagras i sina respektive listor. Listorna tid och y exporteras sedan till räknarlistorna L₁ och L₂.

b) Visning av grafiken

Inställningar för att plotta diagrammet

• Rensa skärmen med instruktionen plt.cls().
• Visa rutnät plt.grid(xscl, yscl, type,(r,g,b)).
• Gör fönsterinställningar plt.window(xmin, xmax, ymin, ymax).
• Ställ in färg för punkter till magenta plt.color(255,0,255).
• Visa spridningsdiagram (punkterna) plt.plot(x-list, y-list, mark).
• Visa plottningen plt.show_plot().

Kör ditt script och anropa din funktion fall genom att trycka på [vars]. Ange sedan som argument ursprungshöjden, t ex. 8 m.

Tryck nu på [enter]. 

Diagrammet för rörelsen visas nu.

X1T sätts nu till 2. Det har bara att göra med läget på skärmen. Vi ska ju visa en fallrörelse och då sker den vertikalt längs y-axeln.

Y1T skriver du in enligt inmatningsrutan. Det är ju samma formel som förut egentligen men här får man ett T när man trycker på  knappen.

En sak som du kanske inte uppmärksammat är att man kan ställa in hur linjer och kurvor ska ritas på skärmen. I inmatningsfältet på första raden, där det nu står 2, kommer du till olika ritningsalternativ om du flyttar dig längst ut till vänster med . Genom att upprepade gånger trycka på  bläddrar du fram olika alternativ. Välj nu det alternativ som är en nyckel 

Sedan ställer man in ett bra fönster för att visa rörelsen.

Vi har på bilden här fryst rörelsen genom att trycka på . Om man trycker på  igen fortsätter linjen med den lilla bollen sin framfart nedåt. Du märker kanske att det går fortare och fortare. Det är ju en accelererad rörelse vi visar.
Ändra nu visningen av rörelsen så man har en fet prickad linje istället för nyckeln. Ändra också Tsteg till 0.06 som vi hade i Pythonappen.
Tryck nu på  och bläddrar dig framåt 0,06 sekunder i taget. Se bilden.

Man kan även plotta lite mer komplicerade rörelser:
Du kastar en boll rakt upp luften med begynnelsehastigheten 12 m/s och fångar den på samma höjd när den kommer ner igen. Man ger samtidigt bollen en vindpust på 2 m/s rakt horisontellt

Visa själva rörelsen!

I denna första övning i kapitel 6 kommer du att upptäcka hur man använder biblioteket ti_hub för att styra integrerade komponenter hos hubben.

Syfte:

• Upptäcka hubb-modulen
• Skriva ett skript där man integrerar TI-Hub-biblioteket för de integrerade komponenterna

Du kommer också att börja fundera på hur du kombinerar det här biblioteket med de du redan känner till (ti_plotlib och ti_system) för att skapa ett mer komplett naturvetenskapligt projekt.

Skriptet du ska skriva motsvarar följande enkla algoritm:

Mäta omgivande ljusintensitet:
Lum0 ← mätning ± (tolerance?)
Ändra ljusintensitet (lampa; täckning framför ljussensorn)
Lum1 ← mätning
If Lum1 > Lum 0:
Tänd RGB LED i rött (2s)
Annars If Lum0 < Lum1:
Tänd RGB LED i grönt (2s)
Annars: Gör ingenting

Starta ett nytt skript och döp det KAP6OVN1

Det här skriptet måste integrera ti_hub-biblioteket. För detta har du flera möjligheter:

a) Tryck på f3 [Types] och välj alternativ 6 i menyn: 6:Hub Project. Bekräfta genom att trycka på [enter] två eller en gång och sedan OK.

b) Du kan också börja från ett tomt skript och sedan manuellt införliva de bibliotek du behöver.

c) Slutligen kan du också använda de bibliotek och variabler som har skrivits under TI STEM-projekten. Dessa kommer omedelbart att kopieras som "Projektobjekt". Det sista alternativet är bara intressant när du vill skapa ett skript som liknar dem som definierats under STEM-projektet (engelska) Se även den svenska sidan för STEM-projekt

Genom att välja typ 6: Project Hub så får du skärmen här:

Vi kommer att använda TI-Innovators inbyggda ljusstyrkesensor och RGB-diod. För att skriptet ska kunna hantera dem, låt oss integrera motsvarande bibliotek. För att göra det, välj i Modul-menyn alternativ 6: ti_hub  och slutligen i undermenyn  1: Hub-Built-in devices.

                  

• För att programmet ska kunna visa information på en "ren" skärm rensar du skärmen med hjälp av instruktionen disp_clr() i ti_system-biblioteket.
• Skapa en lum0-variabel till vilket ett ljusstyrt mått tilldelas. Satsen brightns.measurement() finns i modul 9: Brightness, som läses in så snart motsvarande modul importerats.
• Visa ett meddelande där användaren uppmanas att ändra ljusintensiteten i närheten av den inbyggda sensorn disp_at().

• Sätt programmet i vänteläge disp_wait(), den tid som ska ändras.
• Skapa en lum1-variabel som den nya mätningen är tilldelad.
• Mätningarna jämförs sedan. Beroende på resultatet av villkorsinstruktionen tänds RGB-lampan i grönt eller rött under 2 sekunder.

      

Utvidgning av övningen

Ändra föregående skript eller skapa ett nytt med namnet KAP6OV1B. Det nya skriptet bör registrera mätningarna av ljusstyrkan i 40 minuter.

Måtten sparas i en lista [ ].
De som motsvarar tidsvärdet i en t[]-lista.

Skriptet som föreslås nedan ger också en grafisk representation av mätningarna. Du kan jämföra den med diagrammet på nästa sida.
Export till räknarens listeditor föreslås också.

 

• Sätt programmet i vänteläge disp_wait(), den tid som ska ändras.
• Skapa en lum1-variabel som den nya mätningen är tilldelad.
• Mätningarna jämförs sedan. Beroende på resultatet av villkors instruktionen tänds RGB-lampan i grönt eller rött under 2 sekunder. 

Bri(n)-funktionen utför datainsamling varje minut i n minuter och returnerar t- och r-listorna.

Funktionen graf(t,r) ritar data t[ ]  och  r[ ] och exporterar dem sedan till räknarens listor L₁ och L₂.

I denna andra övning i kapitel 6 kommer du att lära dig hur man ansluter och använder en indata/utdata-enhet hos TI Innovator med hjälp av ti_hub biblioteket.

Syfte:

• Upptäcka TI_Hub-modulen
• Skriva och använda ett skript för att använda en ”grove” indata/utdata-komponent.

I den här övningen kommer du att använda en potentiometer som är en viktig komponent i alla mätkedjor med sensorer.

En potentiometer är en typ av reglerbart motstånd med tre anslutningar, varav den ena är ansluten till en vridbar glidkontakt som rör sig på ett motståndsspår som avslutas av de andra två som motståndet utsätts för.

Potentiometrar används ofta i elektroniska kretsar. De används till exempel för att styra volymen på en radio. Potentiometrar kan också användas som givare eftersom de omvandlar en position till en spänning. Denna typ av enhet finns i joysticks.

Du kommer att skriva ett skript för att mäta den elektriska spänningen mellan två anslutningar hos potentiometern och sedan visa spänningen på skärmen.

Obs: Tanken med denna övning är inte att studera själva komponenten, utan att integrera den i ett Pythonskript för att få den information som den måste tillhandahålla. Således kommer skriptet som du kommer att skriva att vara lätt att överföra till någon annan typ av givare.

Implementering:

Starta ett nytt skript och döp det KAP6ÖVN2. Du trycker på  f3 (New) när du ska namnge ett skript.

ti_system och time-biblioteket importeras och du ska sedan importera Hub-biblioteket som motsvarar potentiometern och möjligtvis ti_plot-biblioteket.

Tryck nu på f1 (Fns…) och välj Modul-menyn och väljs sedan 6:ti_hub och därefter 2:Input devices och slutligen 0:Potentiometer

Alla kommandon som har att göra med potentiometern är nu tillgängliga i modulmenyn plus naturligtvis de som redan finns där.

• Skapa en pot( )-funktion tillfälligt utan argument.
• Börja med att rensa skärmen för att få en konsol utan information. För att göra detta infogar du instruktionen dispclr() som finns i ti_system- modulen.
• Skapa en mät-variabel och låt markören blinka bakom namnet på denna variabel. Sök sedan i modulmenyn och välj sedan 8: Potentiometer och sedan den första instruktionen var=potentiometer("port")

Bekräfta genom att trycka på  [enter]. Tilldelningen av kommandot för att ansluta potentiometern till port IN 1 är klar.

• Skapa en variabel v för att samla in mätningen hos den anslutna sensorn (variabel mät).

• Kontrollera sensorns funktion efter att tidigare ha placerat potentiometern i ett centralt läge.
• Anslut TI-innovator till räknaren och anslut sedan potentiometern till IN1-porten.
• Anropa pot()-funktion.
• Du bör få information av samma storleksordning som den på skärmen mittemot, men observera att detta inte är en spänning eftersom din potentiometer drivs av en 3,3 V spänning. Värdet som ska hittas finns i intervallet [0; 3,3].

Man måste nu modifiera skriptet och ta hänsyn till upplösningen hos A/D-omvandlaren (14 bitar). Det betyder att spänningsmätningen blir:

u = 3,3 * 9759/2¹⁴  ≈ 1,97

Vi har här avrundat till två decimaler. Kör nu det färdiga skriptet.

I denna tredje övning i kapitel 6 kommer du att lära dig hur man ansluter robotbilen TI-Innovator Rover med hjälp av biblioteket ti_rover.

Syfte:

• Upptäcka TI_rover-modulen
• Skriva och använda ett skript för att använda TI-Innovator Rover och dess styrdon.
• Använda en öppen loop och en villkorsinstruktion

I den här övningen kommer du att skapa ett skript som ger ROVER möjlighet att köra en bana som markeras av belysning av RGB- dioden, så länge avståndet (mätt med RANGER-sensorn) respekterar en gräns skriven i en villkorsinstruktion.

• Starta ett nytt skript och namnge det KAP6OVN3
• Importera ti-rover-biblioteket från modul-menyn
• Bekräfta genom att trycka på [enter].

• Rensa skärmen med hjälp av  instruktionen disp_clr() som finns i ti_system-menyn. 
• Fortfarande i ti_system  ti_system-menyn väljer du disp_cursor( )-instruktionen med värdet 0 för att inte visa markören.

• Be ROVER att gå vidare. Måttenheten på avståndet lämnas åt ditt val. Standardavståndet är 0,1 m. rv.forward(20) gör att robotfordonet går framåt 2 m. Instruktionen rv.forward( ) finns
   i modulmenyn. Välj sedan 7: ti_rover och slutligen
   2: forward(distance) i i Drive-menyn.

• Ange sedan början av en öppen loop som finns i modul-menyn och sedan i ti_system-biblioteket.

• Skapa en variabel a till vilken avståndet uppmätt med RANGER tilldelas. För att göra detta så skriv bokstaven a och lämna sedan markören i slutet av den här bokstaven. Skriv sedan instruktionen rv.ranger_measurement( ) som finns imodulmenynsedan 7: ti_roversedan I/O(input-output); 1: Inputs och slutligen1: rv.ranger_measurement( ). Måttenheten är meter.

• Skapa nu villkorssatsen. Om det uppmätta avståndet är mindre än 20 cm stannar roboten och RGB-lysdioden lyser rött. Instruktionen rv.color( ) finns i ti_rover-biblioteket i I/O-menyn  alternativ 2: Outputs. rv.stop( ) är en körinstruktion och är därför placerad under motsvarande meny (Drive) . Annars lyser RGB-dioden grönt och roboten fortsätter sin väg tills den inställda sträckan nås. Instruktionen rv.resume()  avslutar bearbetningen av åtgärderna i kön.

• I slutet av slingan:
  • Roboten stannar. rv.stop().
  • Skärmen raderas.
  • Lysdioden visar en blå färg.
  • Det är 1 s fördröjning innan lysdioden slocknar.

I kapitel 6 ska du ansluta TI-Innovator™ Rover med Ti_hub-biblioteket och skapa ett skript som samlar in punkt-koordinaterna under en färd och sedan också visa dessa koordinater grafiskt.

Syfte:

• Undersöka ti_rover-modulen.
• Skriva och använda ett skript för att köra TI-Innovator Rover och dess tillhörande ställdon.
• Använda en sluten slinga.
• Representera data grafiskt

I den här lektionen kommer du att skapa ett skript som ger ti-rover möjlighet att göra en väg som motsvarar ritningen av en polygon.

Hörnens koordinater sparas i listor och representeras sedan grafiskt med hjälp av instruktionerna i ti_plot-biblioteket.

Genomförande:

• Starta ett nytt skript och döp det till KAP6APP
• Importera TI-Rover-biblioteket från modulmenyn
• Bekräfta genom att trycka på [enter].
• Importera även ti_plotlib-biblioteket

• Även om det inte är nödvändigt så gör instruktionerna för att rensa skärmen och inte visa markören att skärmen ser trevligare ut. Infoga alltså disp_clr() och disp_cursor(0) från modulmenyn och ti_system sedan.
• Skapa en funktion poly() med antalet sidor n i polygonen som argument och l som standardenheten längd för TI-Rover, dvs dm.
• Vinkeln vid hörnen för varje polygon kommer således att vara lika med a = 360/n.
• Skapa två tomma listor xaxel och yaxel, som är avsedda att ta emot koordinaterna för var och en av dessa hörn.

Skapa en stor öppen loop n.

Följande instruktioner finns i ti_rover-biblioteket:

• Flytta fram Rover l decimeter n gånger
• Sväng vänster med vinkeln a.
• Lägg in en fördröjning på 1 s mellan varje steg.
• Lagra koordinaterna för punkterna i x- och y-listorna.
• Koppla bort Rover i slutet av banan.
• Exportera xaxel- och yaxel-koordinaterna till listorna L₁ respektive L₂ hos räknaren.

Byt sedan till den grafiska representationen, som ingår i funktionen här men det är fortfarande möjligt att skapa en graffunktion separat som vi gjorde i andra övningar (kapitel 5).

Hur skriptet fungerar:

Kör ditt skript och anropa poly()-funktionen. Skriv (4, 1) för att rita en kvadrat med sidan1 dm.

Testa också med en hexagon med sidan 1 dm.