Informatica Deel II: les 8 Software & binaire bomen Jan Lemeire Informatica deel II&III februari mei 2014 Parallel Systems: Introduction
Waarmaken van Leibniz s droom (10) Artificiële intelligentie (9) Communicatie & internet (8) Operating system (7) Computatietheorie & Software (6) Efficiënt productieproces (5) Hardware architectuur Electronica: (3) relais -schakeling, (4)geheugen (2) Digitaal & binair (1) Het idee Informatica deel III: technologie, historiek en economische aspecten
Hoofdstuk 7: Software Jan Lemeire Pag. 3 / 65
Leibniz droom De Calculus ratiocinator Een logisch denkend apparaat 1646 1716 Om met de regels van de logica ondubbelzinnig te kunnen vaststellen of een statement waar of vals is Deductief systeem waarin alle regels afgeleid zijn van een kleine verzameling axiomas Leibniz was één van de eerste die begreep dat als je filosoferen, denken, redeneren, in formele regels kunt gieten, je dit ook door een apparaat kunt laten doen Jan Lemeire Pag. 4 / 65
George Boole 1815 1864 Logica herleid tot Booleaanse algebra Boole zette een belangrijke stap met het ontwikkelen van een algebra voor het rekenen met statements over waar/onwaar. Jan Lemeire Pag. 5 / 65
Gottlob Frege Beschrijft hoe wiskundigen en logici denken 1879: de universele taal van de logica 1903: brief van Betrand Russel die hem op een onvolledigheid wijst Extra-ordinaire verzameling = verzameling dat een element is van zijn eigen Vb: verzameling van alle dingen die geen spreeuw zijn Maar: de verzameling E van alle ordinaire verzamelingen En wat is E? Ordinair of extra-ordinair 1848 1925 Informatica II: les 9 Jan Lemeire Pag. 6 / 65
David Hilbert Wir mussen wissen; wir werden wissen We moeten weten; we zullen weten 1862 1943 Elke logische of mathematische vraag is oplosbaar (en zal opgelost worden) Nodig: een expliciete procedure om vanuit premises na te gaan of een conclusie volgt of niet (Hilbert s beslissingsprobleem) Hilbert s beslissingsprobleem zou leiden tot een doorbraak in de theoretische informatica. Jan Lemeire Pag. 7 / 65
Alan Turing Hilbert s procedure: algoritme! Als we een mechanische lijst van regels hebben om de oplossing van een mathematisch probleem op te lossen, zouden wiskundigen geen werk meer hebben Bestaat er zo n algoritme? Om tegendeel te bewijzen moest hij een ding maken dat een/elk algoritme kan uitvoeren Alan Turing wierp zich op Hilbert s probleem. Hij bedacht dat er hiervoor een algoritme gemaakt moet worden (die nagaat of een statement klopt of niet), en vervolgens een machine die het algoritme kan uitvoeren. De Turing machine werd geboren, een theoretisch model van een computer. Jan Lemeire Pag. 8 / 65
De Turing machine Data: oneindige lange tape voor het lezen of schrijven van 0/1/spatie Kan 1 vakje naar links of rechts bewogen worden Staat (toestand): een aantal binaire variabelen Gedragsregels Staat Gelezen bit Nieuwe staat Te schrijven bit 0 0 0 0 > 0 1 1 1 < 1 0 1 _ > 1 1 HALT Bewegen Deze Informatica machine II: les 8is alleen maar van theoretisch nut. Ze is bijvoorbeeld niet echt gemakkelijk programmeerbaar. Jan Lemeire Pag. 9 / 65
Voorbeeld Applet van studenten 2012 Java applet: http://ironphoenix.org/tril/tm/ Jan Lemeire Pag. 10 / 65
Oplossing van Hilbert s beslissingsprobleem? Met de machine nagaan of een logisch statement waar of vals is: Programma runnen Als de machine stopt is statement bewezen (waar). Halting problem (tegelijkertijd ontdekt door Alonzo Church en Alan Turing) Gegeven een Turing machine en programma, ga na of dit programma zal stoppen. Hier bestaat geen algoritme voor die dit kan nagaan Hilbert s beslissingsprobleem is onoplosbaar Het resultaat Turing s van resultaten Turing was weer ook een belangrijk knak in het voor optimisme informatica van de wetenschap. Je kan niet voor alles bewijzen of het waar of niet waar is. Hieruit onstond mede de moderne relativistische kijk op de wereld. De wetenschap kan niet alles oplossen/verklaren De VUB blijft echter geloven dat wetenschap veel kan oplossen. Scienta Vincere Tenebras. Jan Lemeire Pag. 11 / 65
De universele computer Elke computatie kan er op uitgevoerd worden = Turing Machine Kan alles berekenen wat berekenbaar is rekenen ook om logisch te denken universeel Misschien wel het belangrijkste resultaat van Turing is echter het idee van een universele computer. Eén computer (hardware) die alles kan berekenen wat maar te berekenen valt. Dit was revolutionair, omdat velen in die tijd niet konden geloven dat je met 1 machine totaal verschillende berekeningen kan doen. Alsof je met een wasmachine ook kan autorijden. Jan Lemeire Pag. 12 / 65
Misvattingen omtrent computers Howard Aiken, bouwde de eerste computer voor IBM in 1944 en zei in 1956: If it should turn out that the basic logics of a machine designed for the numerical solution of differential equations coincide with the logics of a machine intended to make bills for a department store, I would regards this as the most amazing coincidence I have ever encountered Studie van 1947: slechts zes elektronische digitale computers zullen voldoende zijn om al het rekenwerk van de gehele Verenigde Staten te kunnen doen." Jan Lemeire Pag. 13 / 65
Basisprincipe 1 universele computer kan elke andere computer simuleren Zo is je programma ook maar data die zegt wat de computer moet doen. Voor dat programma heb je geen aparte machine nodig, toch? Nogal logisch, niet? Dit kan je ook toepassen op programmeertalen: je wilt een taal waarmee je alle mogelijke algoritmes kan programmeren, een universele programmeertaal. Informatica II: les 9 Jan Lemeire Pag. 14 / 65
Computatietheorie: bewijzen dat een programma correct is Heel omslachtig! Enkel mogelijk voor eenvoudige algoritmes. Dus: ad-hoc testen noodzakelijk, zorgvuldig programmeren, goed opdelen, Anderzijds zijn er nog vele gaten in de theoretische informatica. Zo zou het toch handig zijn om te bewijzen dat je programma correct is. Dit blijkt heel omslachtig te zijn, zelfs voor simple programma s. Informatica blijft dan ook gedeeltelijk een praktische wetenschap. Maar wij ingenieurs malen daar toch niet om, he? Als het maar nuttig is, die computer. Jan Lemeire Pag. 15 / 65
Vandaag 1. Theoretische informatica 2. Binaire bomen 3. Operaties op bomen 4. Software 5. Zoektijd in bomen
Bomen
p. 63 Bomen (hoofdstuk 6) Arrays: basis ArrayList: flexibele grootte van array Linked Lists: flexibel toevoegen en verwijderen van elementen Maar: doorlopen van lijst is traag (bvb zoeken van element) Nodig: flexibele structuur om elementen in op te zoeken Jan Lemeire Pag. 18 / 65
Binaire boom Jan Lemeire Pag. 19 / 65
Alle mogelijkheden afgaan = aanmaken boom (les 8) p. 108 Initial UP LEFT UP LEFT DOWN UP LEFT RIGHT Oplossing puzzel zoeken LEFT DOWN DOWN LEFT RIGHT Jan Lemeire Pag. 20 / 65... Geen binaire boom, kan meer of minder takken hebben
p. 63 Geordende binaire boom Zoeken kan snel Flexibel: toevoegen & verwijderen Jan Lemeire Pag. 21 / 65
Elke node is een object class Node<T>{ T data; Node<T> left, right; } Node(T data){ this.data = data; this.left = null; this.right = null; } Jan Lemeire Pag. 22 / 65
Boom object public class BinaryTree<T> { Node<T> root; Comparator<T> comparator; } public BinaryTree(Comparator<T> comparator){ this.comparator = comparator; root = null; } Jan Lemeire Pag. 23 / 65
Definiëren van ordening java.util Interface Comparator<T> Method Summary boolean int compare(t o1, T o2) Compares its two arguments for order. Returns a negative integer, zero, or a positive integer as the first argument is less than, equal to, or greater than the second. equals(object obj) Indicates whether some other object is "equal to" this comparator. Jan Lemeire Pag. 24 / 65
Voorbeeld Niet in cursus public class Student implements Comparable<Student>{ String voornaam, naam; int rolnummer, score; Vak[] vakken; int[] punten; Student(String voornaam, String naam, int rolnummer){ this.voornaam=voornaam; this.naam=naam; this.rolnummer=rolnummer; vakken = new Vak[4]; } @Override public int compareto(student student2) { int ordenaam = this.naam.compareto(student2.naam); if (ordenaam == 0) // beide dezelfde naam return this.voornaam.compareto(student2.voornaam); else return ordenaam; } Jan Lemeire Pag. 25 / 65
p. 65 IntegerComparator class IntegerComparator implements Comparator<Integer> { @Override public int compare(integer val1, Integer val2) { return val1 - val2; } } Jan Lemeire Pag. 26 / 65
Aanmaken van boom IntegerComparator comparator = new IntegerComparator(); BinaryTree<Integer> tree = new BinaryTree<Integer>(comparator); korter: BinaryTree<Integer> tree = new BinaryTree<Integer>(new IntegerComparator()); Jan Lemeire Pag. 27 / 65
Niet in cursus Nog korter: via anonymous class BinaryTree<Integer> tree = new BinaryTree<Integer>( new Comparator<Integer>() { @Override public int compare(integer val1, Integer val2) { return val1 - val2; } } ); Jan Lemeire Pag. 28 / 65
Operaties op bomen
Belangrijke operaties 1. Toevoegen element 2. Zoeken element 3. Verwijderen element 4. Doorlopen van boom (bvb printen) 5. Balanceren van de boom Jan Lemeire Pag. 30 / 65
Recursie zonder recursie? Staartrecursie kan met while 1 recursieve oproep Boomrecursie niet Meer dan 1 recursieve oproep (vb fibonacci) Jan Lemeire Pag. 31 / 65
p. 66 1. Toevoegen element public void add(t object){ Node<T> newnode = new Node<T>(object); if (root == null) root = newnode; else add(root, newnode); } private void add(node<t> current, Node<T> newnode){ if (comparator.compare(newnode.data, current.data) < 0){ // moet links komen if (current.left == null) current.left = newnode; else add(current.left, newnode); } else { // rechts if (current.right == null) current.right = newnode; else add(current.right, newnode); } } Jan Lemeire Pag. 32 / 65
Volgorde bepaalt boom! Niet in cursus Wat als {k, l, g, i, x, q, r, a, e, f, c, z} {a, c, e, f, g, i, k, l, q, r, x, z} {i, z, q, l, k, f, e, g, c, x, a, r} Jan Lemeire Pag. 33 / 65
p. 66-67 2. Zoeken element public boolean contains(t object){ return find(root, object); } private boolean find(node<t> current, T object){ if (current == null) return false; else if (comparator.compare(current.data, object) == 0) return true; else if (comparator.compare(object, current.data) < 0) return find(current.left, object); else return find(current.right, object); } Tijd ~ diepte boom Idealiter: log 2 n Behalve als ongebalanceerd (zie verder) Jan Lemeire Pag. 34 / 65
Staartrecursie Met while: public boolean containswithoutrecursion(t object){ Node<T> current = root; while (current!= null){ if (comparator.compare(current.data, object) == 0) return true; // gevonden! else if (comparator.compare(object, current.data) < 0) current = current.left; else current = current.right; } return false; // niet gevonden } Jan Lemeire Pag. 35 / 65
Hoofdstuk 7: Software Jan Lemeire Pag. 36 / 65
software: weg met de kabeltjes
software Programmeertalen Een processor biedt een aantal instructies aan die hij begrijpt en kan uitvoeren. Deze instructies zijn binair en noemt men machinecode. Voor de leesbaarheid biedt assembler mnemonische afkortingen aan voor binaire instructies, variabelen Informatica II: en les 8labels van codelijnen. De assembler maakt de vertaling en zet Jan Lemeire Pag. 38 / 65 alle afkortingen om naar binaire machinecode die dan uitgevoerd kan worden.
Machinetaal - assembler Instructies op machineniveau: STO (store): sla waarde op in geheugenvakje met naam x EQ/NE (equal): als gelijk aan/is niet gelijk, spring naar xxx (label) MUL/ADD (multiply/add): vermenigvuldig/voeg toe aan x Informatica JMP II: les 8(jump): spring naar xxx Jan Lemeire Pag. 39 / 65
Assembler-instructieformaat Informatieverwerkende instructie OPC OP1 OP2 RES OPeration Code: de aard van de bewerking OPerand addresses: de adressen van de twee gegevens waarop operatie zal worden uitgevoerd RESult address: het adres van het resultaat Stuurinstructies (control instructions) OPC OP1 OP2 NEXT NEXT instruction: het adres in het programmageheugen van de volgende instructie Jan Lemeire Pag. 40 / 65
3 e generatietaal Onafhankelijk van de hardware beschrijving van het algoritme Gebruik van variabelen ipv geheugenadressen Geen JUMP, enkel for/while/if/switch Jumps leidt tot spagetticode, je mag van overal naar overal springen Functies/methodes mogelijk Omzetting naar assembler: compileren Checkt je code op syntaxfouten! Programmeren in assembler is niet produktief. Het is redelijk omslachtig, je maakt snel fouten en de code is heel onleesbaar. Daarom heeft men programmeertalen ontwikkeld die minder code vergen, meer aansluiten bij algoritmes, meer gestructureerd, leesbaarder en minder foutgevoelig. De Nederlander Informatica II: les Edgser 8 Dijkstra was het voornaamste genie achter de 3 e generatietalen. Jan Lemeire Pag. 41 / 65
Edsger Dijkstra (NL) Welke constructies moet een programmeertaal minimaal bevatten? 1930 2002 While/for Goto is onnodig. In oude talen kon je zeggen spring naar lijn 111, een willekeurige lijn van je programma. Dit leidde echter tot onoverzichtelijke spaghetti -code. Dijkstra toonde aan dat een while voldoende is Functies In het begin waren er om praktische redenen veel beperkingen op het gebruik van functies. Recursie Hier was veel tegenkanting tegen, omdat het praktisch tamelijk duur is (vergt veel van processor) Jan Lemeire Pag. 42 / 65
Programma => computer broncode Applicatie (executable.exe) Operating System (Windows, Linux, Mac, ) Hogere taal compileren Machinetaal uitvoeren Hardware (Intel of AMD processor) Nieuwe compilatie nodig voor elk systeem (operating system + hardware)! Jan Lemeire Pag. 43 / 65
Java: via virtuele machine Java code (.java file) Java applicatie (.class of jar-file) Java Virtual Machine Operating System (Windows, Linux, Mac, ) Hardware (Intel of AMD processor) compileren Specifieke tussentaal die iets hoger is dan assembler uitvoeren Tijdens het uitvoeren wordt instructies van de class-files omgezet naar machinetaal Javacode werkt op elk operating system! Je moet wel virtual machine installeren Jan Lemeire Pag. 44 / 65
Ideaal voor internet Java applicatie (.class of jar-file) Java Virtual Machine Operating System (Windows, Linux, Mac, ) Jou code staat op webserver INTERNET Via virtuele machine runt hij op elke lokale machine ( client ) Hardware (Intel of AMD processor) Doordat Java via een virtuele machine (die wel specifiek is voor elk system) tijdens Informatica het II: uitvoeren les 8 wordt omgezet naar machinetaal, kan je programma Jan Lemeire Pag. 45 / 65 overal uitgevoerd worden.
4e generatietaal High-level specification languages: programmeren wat je wilt, niet hoe het moet gebeuren Vb: GUI aanmaken met een tool Te integreren in Eclipse Google Windowbuilder Pro Visual Editor (Nog) niet echt succesvol Enkel voor specifieke applicaties (zoals GUIs) Mijn mening: nog geen artificiële intelligentie => computer kan nog niet begrijpen wat je wilt Een GUI aanmaken kan via een tool waarbij je niets moet programmeren. Je bouwt Informatica als II: het les 8ware je applicatie door aan te geven hoe deze er uit moet zien. Dit werkt echter nog niet voor algemene applicaties Jan Lemeire Pag. 46 / 65
Tool om GUIs te maken Jan Lemeire Pag. 47 / 65
Object-georiënteerde talen Worden als 3 e generatietalen aanzien Toch is de code-organisatie fundamenteel verschillend De code is opgesplitst in klasses ipv functies. Vergt een andere manier van denken Is dè uitdaging van dit semester, zowel voor jullie als voor ons (lesgevers) Jan Lemeire Pag. 48 / 65
Voor ingenieur: welke taal? moet handig en efficiënt zijn, geschikt voor de taak Python Matlab High-level (doet veel voor u) Java Kleine projecten C/C++ Grote projecten Low-level (kort bij de hardware) Zonder al te diep in te gaan over wat nu de beste taal is (een eeuwige steeds-hoogoplopende discussie onder informatici), een kleine poging tot conclusies. C/C++ zullen velen later nog zien, het is de meest-gebruikte taal die kort bij de hardware staat, daarvoor uitermate geschikt voor het programmeren van systemen (chips, robots, kritische applicaties, ) Jan Lemeire Pag. 49 / 65
Zoektijd in bomen
p. 67 Zoektijd binaire boom Als gebalanceerd n => n/2 => n/4 => n/8 => => 1 Of: 1.2 x = n x = aantalzoekstappen = log 2 n Jan Lemeire Pag. 51 / 65
Ongebalanceerde boom aantalzoekstappen = log 4 n aantalzoekstappen = log 1.33 n Gemiddelde is slechter dan log 2 n! Jan Lemeire Pag. 52 / 65
Zoektijd log 2 n log 4 n log 1.33 n n/2 10 3,3 1,7 8,1 5 100 6,6 3,3 16,1 50 1000 10,0 5,0 24,2 500 10000 13,3 6,6 32,3 5000 1000000 19,9 10,0 48,4 500000 1000000 19,9 10,0 48,4 500000 10000000 23,3 11,6 56,5 5000000 100000000 26,6 13,3 64,6 50000000 1000000000 29,9 14,9 72,7 500000000 /2 *2,433 Jan Lemeire Pag. 53 / 65
Verschil in zoektijd Eigenschap logaritmes : Verschil in aantal stappen: log d n = log 2 n log 2 d Verandering van basis stappenratio = log d n log 2 n = 1 log 2 d stappenratio = 1 log 2 1.33 = 1 0.411 = 2.43 stappenratio = 1 log 2 4 = 1/2 2 t.o.v. 1.333 2 t.o.v. 4 Besluit: logaritmisch << lineair Jan Lemeire Pag. 54 / 65
p. 69 Ongebalanceerde boom 2 Vast aantal (k-1) nodes links, de rest rechts k << n Rechterboom heeft n/k => n/2k stappen Totaal n/2k + log(k 1) n/2k lineair Jan Lemeire Pag. 55 / 65
Gebalanceerde bomen
Perfect gebalanceerde bomen p. 67 imbalance # nodes # nodes links links # nodes # nodes rechts rechts 12/11 5/6 4/6 2/2 3/2 1/2 3/2 1/0 0/1 1/1 1/0 0/0 1/0 1/1 1/0 Jan Lemeire Pag. 57 / 65
// geeft -1 als niet perfect gebalanceerd, anders aantal nodes public int isperfectgebalanceerd(node<t> node){ if (node == null) return 0; int nlinks = isperfectgebalanceerd(node.left); int nrechts = isperfectgebalanceerd(node.right); if (nlinks < 0 && nrechts < 0) return -1; if (Math.abs(nLinks - nrechts) > 1) { System.out.println("Node "+node.data+" is niet perfect gebalanceerd: "+nlinks+" versus "+nrechts); } return -1; } else { } return nlinks + nrechts + 1; Jan Lemeire Pag. 58 / 65
Voorbeelden imbalance # nodes # nodes links links # nodes # nodes rechts rechts imbalance=100% imbalance=60% Promotie node l tot root Jan Lemeire Pag. 59 / 65
Operaties op bomen (vervolg)
3. Verwijderen van element p. 71 4 mogelijkheden: Element is root Element is niet in boom Element heeft 0 of 1 subboom Element heeft 2 subbomen 5 Jan Lemeire Pag. 61 / 65 3 2 6 1 4 7 3 mogelijke situaties : a) 2 subbomen: 3, 6 b) 0 of 1 subboom: 1, 2, 4, 5, 7 c) niet aanwezig: 0, 8,
4 e geval: promoten van node 2 6 2 6 1 4 7 1 4 7 5 5 Meest linkse van rechtersubboom Meest rechtse van linkersubboom Jan Lemeire Pag. 62 / 65
public boolean remove(t object){ if (comparator.compare(root.data, object)== 0){ root = createsubtree(root); return true; } else return findnodeandremove(root, object); } p. 72 private boolean findnodeandremove(node<t> current, T object){ if (current == null) return false; if (current.left!= null && comparator.compare(current.left.data, object)== 0){ current.left = createsubtree(current.left); return true; } else if (current.right!= null && comparator.compare(current.right.data, object)== 0){ current.left = createsubtree(current.right); return true; } } else if (comparator.compare(current.data, object) < 0) return findnodeandremove(current.left, object); else return findnodeandremove(current.right, object); Jan Lemeire Pag. 63 / 65
private Node<T> createsubtree(node<t> current){ if (current.left == null){ // current.right is the only subtree that we should consider return current.right; } else if (current.right == null){ // current.left is the only subtree that we should consider return current.left; } else { // promote rightmost node of left subtree if (current.left.right == null){ current.left.right = current.right; return current.left; } else { Node<T> rightmostnode=pickrightmostnode(current.left); } } } // he is new root of subtree rightmostnode.right = current.right; rightmostnode.left = current.left; return rightmostnode;
private Node<T> pickrightmostnode(node<t> current){ // we expect current.right not to be null if (current.right.right!= null){ return pickrightmostnode(current.right); } else { Node<T> rightmostnode = current.right; current.right = rightmostnode.left; rightmostnode.left = null; return rightmostnode; } }