Programmeringsteknisk översiktskurs (5DV031) Föreläsning 10 kallin@cs.umu.se
Innehåll Ändlig aritmetik Fler exempel på funktioner med arrayer som parametrar Läsanvisningar: Dessa bilder, kapitel 11 kallin@cs.umu.se
Många beräkningar är Val av modell Idealiseringar Fel i indata approximationer Mätvärden med begränsad noggrannhet Avrundningsfel Ändlig aritmetik Trunkeringsfel ett oändligt värde ersätts med en ändlig
Exempel Jordens yta beräknas med: A=4πr 2 Approximationer modelleras som en sfär radiens värde är ett resultat av tidigare beräkningar värdet π är ett oändligt värde som måste trunkeras värden och resultat i beräkningarna avrundas och dessutom så ökar felets storlek pga beräkningarna (bla multipliceras felen med 4)
Avrundningsregler Avkorta eller avrundning till närmast jämna? Fel fortplantas snabbt! Vancouver-exemplet Januari 1982 börsindex satt till 1000 November 1983 bottennotering 520 Index noterades med 3 decimaler och avhuggning och uppdaterades efter varje transaktion Korrekta beräkningar med avrundningar nästan dubblade index Ariane 5, 1996 Obemannad raket som exploderade 40s efter start En 16 bitars signed int tilldelades ett 64-bitars flyttal 16 bitar kan lagra max 32768 och talet var för stort Talet hade med raketens horisontella hastighet att göra
Avrundningsregler Amerikansk patriot missil i Gulf-kriget 1991 Datorns tid multiplicerades med 0.1 för att få tid i sekunder. 0.1 kan ej lagras exakt 24-bit tal medför avkortning som medförde fel på 0.000000095 100h körning gav ett fortplantat fel på 0.34s Raketen åker > 0.5 km på den tiden Hamnade i en amerikansk barack och dödade 28 soldater Sida med fler exempel: http://ta.twi.tudelft.nl/users/vuik/wi211/disasters.html
Olika typer av fel Syntaxfel Grammatiska fel Felstavningar Upptäcks vid kompileringen Programkörningsfel(run-time error) Problem som uppstår under programkörning. Avslutar programmet Logiska/Semantiska fel (Tankefel) Problemet är löst på fel sätt, eller man har löst fel problem. Man får ett felaktigt resultat
Heltal(int) Datatypen int används tillsammans med char, short int och long int för att lagra heltal i C. Matematiskt sett finns det oändligt många heltal. På en dator måste det införas en begränsning på hur stora heltalen kan bli. Normalt sparas ett heltal (int) i ett maskin-ord, oftast 4 byte (4 * 8 = 32 bitar).
Heltal forts. Om int lagras som 4 bytes, betyder det att den kan anta 2 32 olika värden. Hälften av värdena används för att lagra negativa heltal och hälften för att lagra positiva heltal. Om i är en variabel av typen int, kan i anta heltalsvärden i intervallet [-2 31,2 31-1]. Eftersom variabler har begränsad lagringskapacitet kan man drabbas av overflow, t.ex. om man försöker multiplicera två variabler vars produkt blir större än det maximala värdet som en variabel kan lagra.
Overflow #include <stdio.h> #include <windows.h> #include <limits.h> int main(void){ int x=int_max; printf("%d\n",x); x=x+1; printf("%d\n",x); system("pause"); return 0; } kallin@cs.umu.se 2147483647-2147483648 Varför blev det så här?
Heltalsrepresentation Alla variabler oavsett typ representeras internt i datorn som binära tal med ettor och nollor. Om vi antar att en int representeras med 2 byte (dock vanligare med 4 byte) på systemet blir den binära representationen: 00000000 00000001 1 2 0 =1 00000000 00000111 1 2 2 +1 2 1 +1 2 0 =7 00000000 00001000 1 2 3 +0 2 2 +0 2 1 +0 2 0 =8 00000000 00001001 1 2 3 +0 2 2 +0 2 1 +1 2 0 =9
Bitvisa operationer I C kan man operera direkt på de enskilda bitarna med de så kallade bitoperatorerna. Logiska operatorer unary complement and & exclusive or ˆ inclusive or Shiftoperatorer left shift << right shift >> Bitvisa operatorer kan enbart utföras på heltalstyper (int,unsigned int, long, char,...).
Binärt komplement Med komplementet menas att alla bitar byter värde, dvs alla ettor blir nollor och alla nollor blir ettor. Den binära representationen av heltalet int a = 550055; (2 0 + 2 1 + 2 2 + 2 5 + 2 7 + 2 10 + 2 13 + 2 14 + 2 19 ) är 0000000 00001000 01100100 10100111 Uttrycket a blir således 1111111 11110111 10011011 01011000 eller -550056
Negativa tal Negativa tal representeras ofta enligt vad som på engelska kallas two s complement representation. Det innebär att ett negativt tal -n representeras som det binära komplementet till n-1 0 00000000 00000000 00000000 00000000-1 11111111 11111111 11111111 11111111 6 00000000 00000000 00000000 00000110-7 11111111 11111111 11111111 11111001
Addition exempel 1 I en byte för enkelhetens skull 3+(-2)=1 Notera att man struntar i den sista minnessiffran! kallin@cs.umu.se
Addition exempel 2 127 + 1 =-128 Man får en overflow om de två sista minnessiffrorna är 01 (som ovan) eller 10. Nu vet vi varför 2147483647 + 1 blev -2147483648 kallin@cs.umu.se
Övriga heltalstyper short lagras oftast med 2 byte vanligen mindre intervall än int. long lagras oftast med 4 eller 8 byte vanligen större intervall än int. unsigned framför en heltalstyp (ex. unsigned int) innebär att enbart positiva tal kan lagras. Detta innebär också att intervallet för tal (positiva) som kan lagras fördubblas.
Typstorlek, sizeof Operatorn sizeof används för att veta hur många bytes som krävs för att lagra ett objekt. Objekt kan vara en datatyp (float), eller ett uttryck (a+b). sizeof(int) sizeof(a+b) sizeof returnerar ett heltal som anger hur många bytes som krävs för lagringen. C är flexibelt när det gäller storlekarna på datatyper vilket kan leda till dålig portabilitet av kod. Användandet av sizeof kan delvis undvika detta problem.
Lagring Följande gäller alltid på alla system. sizeof(char) == 1 sizeof(unsigned) == sizeof(signed) == sizeof(int) sizeof(char) <= sizeof(short) <= sizeof(int) <= sizeof(long) ANCI C specificerar också att sizeof(int) >= 2 sizeof(long) >= 4
Konvertering Uttryck som x+y har ett värde och en datatyp. Om x och y är av typen int, blir x+y typen int. Om x och y är av typen short, blir x+y typen int. short konverteras alltid till int i uttryck.
Konvertering En char eller short (signed eller unsigned) kan användas där en int eller unsigned int förväntas. Ex: Om en funktion tar en int som argument, kan man skicka en char istället. Om däremot funktionen returnerar en int, så bör man inte ta emot det i en char. kallin@cs.umu.se
Aritmetiska konverteringar Om operanderna till en binär operator är av olika typ så kan en av dom konverteras. Antag att vi har: int i; float f; Uttrycket i+f i konverteras till en float och hela uttrycket får typen float.
Aritmetiska konverteringar Vid tilldelningar kan också konvertering ske. double d; d = i Värdet av i att konverteras till double och hela uttrycket blir double. En utökning av en variabel, som sker i fallet med d = i går ofta bra men däremot kan i = d orsaka problem. Decimaldelen av d kommer att försvinna och i kommer att tilldelas heltalsdelen.
Explicita konverteringar Explicita konverteringar (eng. casts) låter programmeraren byta typ på ett uttryck. Om vi antar att i är av typen int så kommer (double)i att konvertera värdet av i så att uttrycket har typen double. Variabeln i påverkas inte av konverteringen utan är fortfarande av typen int (long)('a' +1.0) f = (float)((int)d + i) d = (double) i/3; (double)(x = 77)
Flyttal - float En float har vanligtvis en ungefärlig precision av 6 signifikanta siffror och ett ungefärlig omfång (range) på 10-38 till 10 38. Representationen i maskinen blir (i bas 10 i.s.f. 2): 0.d 1 d 2 d 3 d 4 d 5 d 6 10 n där -38<n<38.
Flyttal - double En double har vanligtvis en precision av 15 signifikanta siffror och ett omfång på 10-308 till 10 308. x i satsen double x = 123.45123451234512345; /* 20 signifikant digits */ resulterar att x blir tilldelat ett värde som lagras enligt 0.123451234512345 10 3 (15 signifikanta siffror)
Exempel Att reella tal inte lagras exakt kan ge upphov till vissa problem. Om vi antar att vår dator kan lagra en float med maximalt 5 signifikanta siffror. float x = 12345F; float y = 1e-1F; float z = 0 / (x + y - 0.12345e5F); /*problem*/ När uttrycket i nämnaren skall evalueras måste exponenten av de tre talen vara av samma storlek. x=0.12345e5 y=0.00000e5 x+y- 0.12345e5==0
Exempel 2 #include <stdio.h> #include <windows.h> #include <math.h> int main(void) { floor 0.2/0.2 = 1.000000 floor 0.4/0.2 = 2.000000 floor 0.6/0.2 = 2.000000 floor 0.8/0.2 = 4.000000 floor 0.2/0.2-1.0 = 0.000000 floor 0.4/0.2-2.0 = 0.000000 floor 0.6/0.2-3.0 = -1.000000 floor 0.8/0.2-4.0 = 0.000000 /* Funktionen floor ger oss närmsta heltalet mindre eller lika med ett reellt tal */ printf("floor %.1f/0.2 = %f\n", 0.2, floor(0.2/0.2)); printf("floor %.1f/0.2 = %f\n", 0.4, floor(0.4/0.2)); printf("floor %.1f/0.2 = %f\n", 0.6, floor(0.6/0.2)); printf("floor %.1f/0.2 = %f\n", 0.8, floor(0.8/0.2)); /* Såg ni att något blev konstigt?? Vi provar att räkna ut * differensen mellan beräkningen och det förväntade resultatet */ printf("\n\n"); printf("floor %.1f/0.2-1.0 = %f\n", 0.2, floor(0.2/0.2)-1.0); printf("floor %.1f/0.2-2.0 = %f\n", 0.4, floor(0.4/0.2)-2.0); printf("floor %.1f/0.2-3.0 = %f\n", 0.6, floor(0.6/0.2)-3.0); printf("floor %.1f/0.2-4.0 = %f\n", 0.8, floor(0.8/0.2)-4.0); } system("pause"); return 0; kallin@cs.umu.se
Flyttalslagring mer exakt Tecken (+/-) 0 betyder positivt 1 negativt Exponenten Högsta och lägsta float 1 [31] double 1 [63] Tecken Exponent Mantissa Bias 8 [30-23] 11 [62-52] 23 [22-00] 52 [51-00] exponenten reserverade för speciella tal. För att klara positiva och negativa har man en bias som adderas till exponenten Mantissa Ledande 1:an implicit 1.Mantissa*2 (Exponent-Bias) 127 1023 kallin@cs.umu.se
Exempel 12.0 12 binärt 1100 = 1.100*2 3 Teckenbit 0 Exponent 127+3=130=>10000010 Mantissa 10000000000000000000000 Totalt: 01000001 01000000 00000000 00000000 kallin@cs.umu.se
Exempel -0.125 0.125 binärt 0.001 = 1.0*2-3 Teckenbit 1 Exponent 127+-3=124=>01111100 Mantissa 00000000000000000000000 Totalt: 10111110 00000000 00000000 00000000 kallin@cs.umu.se
Overflow för float Det finns 5 talområden där float variabler inte kan hantera normalt: 1. Negativa tal mindre än -(2-2 -23 ) 2 127 (negative overflow) 2. Negativa tal större än -2-149 (negative underflow) 3. Noll 4. Positiva tal mindre än 2-149 (positive underflow) 5. Positiva tal större än (2-2 -23 ) 2 127 (positive overflow) 0 Hanteras av ett tal där exponent och mantissa båda är 0 Finns också +- Infinity (Inf) och NotANumber (NaN) kallin@cs.umu.se
Intern talrepresentation Interna talrepresentationen påverkar noggrannheten 0.1 kan inte lagras exakt på det sätt som flyttalen lagras #include <stdio.h> int main(void) { double x; for(x=0;x!=10;x+=0.1) printf("%f\n",x); return 0; }
Utskrift från exemplet... 9.600000 9.700000 9.800000 9.900000 10.000000 10.100000 10.200000 10.300000... Loopen avslutas alltså inte då x blir 10. Detta pga att det resultatet inte blir exakt 10 i datorns interna representation.
Logiska bitvisa binära operationer Tabellen visar and (&), exclusive or (ˆ) och inclusive or ( ) på 1-bits fält. a b a & b a ˆ b a b 00 0 0 0 10 0 1 1 01 0 1 1 11 1 0 1
Logiska bitvisa binära operationer Uttryck Representation Värde a 00000001 01001101 333 b 11111100 11110111-777 a & b 00000000 01000101 69 a ˆ b 11111101 10111010-582 a b 11111101 11111111-513
Shiftoperatorer De två operatorerna till shiftoperatorerna måste vara av heltalstyp. Uttrycket expr1 << expr2 innebär att bitrepresentationen i expr1 shiftas expr2 steg till vänster. int d=1076; 1076 00000000 00000000 00000100 00110100 d << 1; 2152 00000000 00000000 00001000 01101000 d << 3; 8608 00000000 00000000 00100001 10100000 d << 29; -2147483648 10000000 00000000 00000000 00000000 d << 32; 0 00000000 00000000 00000000 00000000 Vid vänstershift fylls 0:or på från höger
Exempel void bit_print(unsigned in) { unsigned mask=1<<8*sizeof(in)-1; while(mask) { printf("%d",mask&in?1:0); mask=mask>>1; } } int main(void) { bit_print(123); printf("\n"); return 0; } 00000000 00000000 00000000 01111011
Övningarna baseras på uppgifter från skrivsalstentor på en liknande kurs Exempel 1 Skriv en funktion som ur parametern instr kopierar en delsträng till parmetern utstr. Den delsträng som skall kopieras börjar i index start och är antal tecken lång. void substr(char instr[], int start, int antal, char utstr[]) kallin@cs.umu.se
Övningarna baseras på uppgifter från skrivsalstentor på en liknande kurs Exempel 2 Skriv en funktion som konverterar en sträng av tecken till dess heltalsmotsvarighet. För att göra funktionen lite mer generell så ska funktionen kunna ta en följd av tecken på valfri plats i strängen. int string2int(char tal[], int start, int stopp) start och stopp är index för första och sista tecknet i strängen tal som skall konverteras. Du får anta att funktionen anropas på ett rimligt sätt, dvs. att start<=stopp och att båda är korrekta index i arrayen. Du får också anta att det framräknade heltalet kan representeras i datatypen int. kallin@cs.umu.se
Övningarna baseras på uppgifter från skrivsalstentor på en liknande kurs Exempel 3 Skriv en funktion som tar en textsträng som parameter och vänder på den. Om funktionen anropas med strängen Program ska resultatet bli margorp. void kastaom(char str[]) Tips: Det finns en funktion som heter strlen som ger längden på en sträng! kallin@cs.umu.se
Övningarna baseras på uppgifter från skrivsalstentor på en liknande kurs Exempel 4 Givet följande main-funktion int main(void){ int i, tarning[5]; srand(time(0)); for (i=0; i < 5; i++) tarning[i] = rulla(); for (i=0; i < 5; i++) printf("%d: %d\n",i,tarning[i]); if (par(tarning)) printf("minst par!"); else printf("alla olika!"); printf("\nklart!\n"); return 0; } Skriv funktionerna rulla och par. kallin@cs.umu.se