Ideen von LISP: 1.) Berechnung mit Symbolen anstelle von

Ideen von LISP:
1.)
2.)
3.)
4.)
5.)
6.)
7.)
8.)
Berechnung mit Symbolen anstelle von Nummern/Strings
Variablen sind Pointer!
Listen als Grundrepräentation
Funktionen
Conditionals (IF – Then – ELSE)
Rekrusion
Programm nur Ausdrücke, keine Anweisungen
Code – Notationen über Symbolbaum
(+2 ( - 5 3))
9.) Garbage Collection
10.) keine Unterscheidung zwischen read-time, compile-time, ran-time
11.)evae als Defintion und Interpreter
– LISP mit PROLOG => Programmiersprache für KI's
Prolog:
Entwicklung von Prolog:
1.) Compilerbau: Speicherverwaltung nicht deterministischer Algorithmus
2.) Logik:
– Automatischen Theorembeweisen
– Aus Prädikatenlogischen Klasueln Schlüsse ziehen (nach Inplementierung nur
Hornklauseln
– Frage-Antwort-System
3.) maschinelle Sprachverarbeitung/linguistik
– z.B. Überseten
– natürlichsprachliche Schnittstelle für Frage-Antwort-System
– Horn-Klausel Kompromiss nur gebräuchliste Regel der Linguistik ( nicht z.B.
Umwandlung Aktiv/Passiv)
4.) (2)+(3) zentrale Gebiete der KI-Forschung
5.) Datenbank: relationale Programmiersprache (relationale => Tabellen)
Auswertungsbaum:
--------------------------------->
|
|
a(A) :- b,c(a).
|
a(A):-d,c(A)
|
d.
|
c(1)
|
c(2)
|
V
Anfrage: ? - a(X)
Negationen:
– Darsgtellung von:
Klaus mag niemand, der Hunde mag
likes (klaus, y) :- likes (klaus, x), not (likes (x.dogs))
y \= x, likes (X, dogs)
– Negation => Failure => nicht beweisbar
–
p(a)
p(b)
q(c)
–
Reihenfolge wichtig wegen cuts!
–
grüner cut
verändert semantik nicht, schneiten nur Unterbäume ab die nicht mehr
wahr werden können
roter cut
schließt mögliche Lösungen aus
aus Linguistik abgeleitet um effizienter mit Sätzen in Baumstruktur umzugehen
Für Logik nicht theoretische fundiert.
–
–
? - not ( p (X) ), g (X) -> no
? - q (X), not ( p (X) ) -> X = c
cuts:
–
–
–
p(a)
p(b)
q(c)
q(b)
? - p(x). !, q(x).
1=cut
-> no
? - p(x). q(x), !.
-> x = b
– keine weiteren Lösungen
–
–
cuts 1.Lösung hängt über den Cut kann aber nicht mehr zurück
not(p) :- p ,
! , fail
not(p). wahr->cut->fail
=> Wenn p -> fail cut sonst ~> true
pups seminat 30.05.05
!!! Aufgabenblatt 4: IOTools.zip nicht benutzten !!! - EIGENE SCHREIBEN
Ergänzung zur 7.Vorlesung:
C:
–
niedriger Abstraktionsgrad ≙ „High-Level Assembler“
-> kleiner Sprachumfang
-> leichte Portierbarkeit
-> viele Betriebssysteme in C geschrieben (siehe Waschmaschine, Fernbedinung, kleine Systeme ...)
–
–
–
in Anwendungsentwicklung von C++, JAVA verdrängt
Programme haben Portabilitätsprobleme, z.B. Speichergröße von Typen( Integer, Char, usw...)
Code -> Compiler -> Objektcode -> Linker (fügt andere Datein hinzu, wie z.B. -m für Mathebibliotek) -> Programm
-> Bibliotheken
-> Optimierung (bessere Ausnutzung der Pipes)
Prärozessor
#include
#ifdef ... (Alles zwischen diesem Block wird nicht mitcompiliert)
.
.
.
#enddef
-> Bedingt Compilierung z.B. für Debugging, bessere Betrachtung unter verschiedenen Betriebssytemen
-> Makros (Inhalt des Makros wird im Programmtext beim Compilieren erstetzt => kürzerer Text, bessere
Möglichkeit zum optimieren durch Compiler)
Unterschied zwischen Funktion und Prozedur
-> Prozedur hat keinen Rückgabewert (einziger Unterschied)
-> muss vor der MAIN stehen, sonst „kennt“ Compiler diese nicht
-> wenn man dies aber will dann MUSS ein Prototyp erstellt werden
*double what(double x, double y) => Funktion
*double what(double x, double y); => Prototyp
Reihenfolge der Unterprogramme wichtig => Prototypen
header Datein
-> beinhalten (sichtbare) Prototypen
-> Programm über mehrere Datein verteilt
-> #include „datei.h“
-> compilieren
• gcc prog1.c prog2.c -o prog
• gcc -c prog1.c
gcc -c prog2.c
.
.
.
ld prog1.o prog2.o ... -o prog
=> Makefiles
„Wilde Zeiger“, Speicherverwaltung
Zeichenketten nur als Array von Char realisierbar
Arrays sind keine eigentliche Datentypen, sondern werden intern von C als Pointer behandelt
structs
->
struct {
char vname[20], nname[20];
char telnr[15];
int alter;
} PERSON
PERSON tom;
tom_vname = „Tom“;
=> ein „Array“ mit verschiedenen Datentypen
–
–
–
–
–
–
–
–
–
Pointer
-> Bsp: int j, k;
k = 2;
j = 7;
k = j;
• j ist eine Variable ab Speicherplatz X(value) bis Speicherplatz X + sizze of(int)
• Typ: int
• k = j; wird der Wert kopiert
• bei großen/vielen Daten ist das kopieren ineffizent
• => int* ptr; || int * ptr; || int *ptr;
• => ptr hat rvalue ML, lvalue Y, typ Pointer auf int
• ptr = &j; // „&“ gibt lvalue aus
• => ptr hat rvalue X
• -> dereferenzieren *tr // ≙j
-> Pointer und Arrays
• int a[ ] = {1,2,3,4};
• ptr: & a[0];
• alternativ: ptr = a; (damit ist er der Pointer auf daas erste Element von a)
• *(ptr++); // 2 (bei Pointer wird immer erst inkrementiert vor der Übergabe
• *(ptr + 2) // 4
• a[5] = 5; // !!!kann zum Speicherüberlauf führen !!!
-> void *ptr;
kein Typ, dadurch Vergleiche mit anderen Pointern möglich
Aufgabe 3:
bei der Dekermentierung von Pointern wird der Orginalwert überschrieben, wenn man das mit variablen macht
dann wird die lokale Variable verändert.
=> unterschiedliche Werte von x & y
b.)
int A[ ] [ ] = {1,2,3},{4,5,6};
dynamische Allokierung von Speicherplatz
-> malloc, free
-> Während der Laufzeit Speicherplatz anfordern und wieder freigeben
-> z.B. Einlesen „Telephonbuch“, unbekannt viele Einträge
-> double *x;
x = (double*) malloc(30*sizeof(double));
for ( int i = 0; i < 30; i++)
x[i] = i;
free(x);
mehr Dimensionale Arrays
[3][5]
double **x
x = (double**) malloc(3* sizeo(double*));
for (int i = 0; i < 3; i++)
x[i] = ...
Programmieren und Programmiersprachen Seminar 13.06.05
Java:
– Prorammcode -> Compiler
-> Bytecode -> Interpreter
– Interpreter emuliert Java Virtual Maschine(JVM)
–
–
Bytecode ist Maschinencod für JVM
(C / C++: Objektcode in Assembler)
JVM ermöglicht Portierung von Programmen auf verschiedene Maschinen ohnen Änderungen des Sourcecodes
–
Programme durch Interpreter langsamer
–
kein Präprozessor
–
Java ist prinzipell Objektorientiert, aber primitive Datentypen(int, boolean... ) sind keine Objekte
–
bessere Optimierung
–
keine Überladung von Operationen wie in C++
–
kein Zeiger, nur Referenzen (Referenz darf nur auf eine Variable zeigen)
–
Garbage Collection
–
Wegen Portierbarkeit nicht möglich:
–
Benutzterrechte setzen
–
Farben ändern
–
Laufwerkstypen erkennen
–
CD auswerfen
–
kein Umgang mit niederen Netzwerkprotokollen (IPX/SPX/NetBIOS)
–
USB, Firewire zugriff
-> keine Systemprogrammierung oder Treibersoftware
( dafür aber C/C++ )
Aufgabe 2:
A2
(a)
Specifier
private
(none)
protected
public
Class
y
y
y
y
Package
n
y
y
y
n
n
y
y
Subclass
n
n
n
y
World
-> legt automatisch das Interface einer Klasse fest!
(b)
final: Variablen -> Konstanten
Methoden -> nicht überschreibar
Klassen -> nicht ableitbar
-> z.B. um Sicherheit zu gewährleisten
-> z.B. Strings sind final
(c)
this: Zeiger auf das Objekt selbst, erlaubt Namenskonflikte zu lösen oder
einen anderen eigenen Konstruktor aufzurufen.
Bsp:
class test
{
int a,b;
...
test ()
{
this(0,0);
}
test (int a, int b)
{
this.a=a;
this.b=b;
}
...
}
(d)
super: Mit super kann auf die Oberklasse und deren Variablen und Methoden
zugegriffen werden. Wenn beim Ableiten Methoden überschrieben oder Variablen
verdeckt werden, so kann mit super trotzdem noch auf die ursprünglichen
Methoden und Variablen zugegriffen werden.
(e)
Eine Referenz ist ein Pointer, dessen Wert nicht geändert werden kann. Die
Referenz kann also immer nur auf ein bestimmtes Objekt/ eine bestimmte
Variable zeigen. Der Wert der Variablen kann natürlich trotzdem geändert
werden.
In Java gibt es keine Pointer. Referenzen gibt es auf Objekte und so auch auf
Arrays. Da einfache Datentypen nicht als Objekte implementiert sind, gibt es
keine Referenzen auf einfache Datentypen.
Call by Value: Beim Aufruf der Funktion wird eine lokale Variable angelegt und
der Wert in diese Variable kopiert. Damit kann die ursprüngliche Variable
nicht verändert werden.
Call by Reference/Pointer: Die Referenz wird übergeben, somit kann die
ursprüngliche Variable verändert werden.
(f)
Überladen: Erstellen mehrerer Methoden mit gleichem Namen und
unterschiedlichen Aufruf-Parametern.
Überschreiben: Wird eine geerbte Methode zusätzlich in der beerbten Klasse mit
der selben Signatur implementiert, so überschreibt die neue Methode die
geerbte Methode, welche damit nicht mehr benutzt wird.
(g)
static:
static deklariert eine Variable/Methode als zur Klasse selbst gehörend und
nicht zur Instanz. Damit wird ausgedrückt, daß kein Zustand vom Objekt für
die Implementierung benutzt wird. Diese static Variablen/Methoden werden nur
einmal pro Klasse erzeugt, egal wie viele Instanzen erzeugt werden, und dann
von allen Instanzen geteilt. Sie können über die Instanzen wie auch über die
Klasse selbst aufgerufen werden. Die Variablen können trotzdem geändert
werden, auch wenn sie meisten für Konstanten benutzt werden.
(h)
keine Mehrfachvererbung
Konstruktoren werden nicht vererbt
private Methoden werden nicht vererbt
(i)
Nochmal sorry, Mehrfachvererbung und Polymorphie sind zwei völlig unterschiedliche Sachen.
Probleme, die bei der Mehrfachvererbung auftreten können, sind
Namenskonflikte. So ist bei Oberklassen mit gleichen Methoden oder
Variablennamen nicht klar, welche geerbt werden sollen oder wie man sie
unterscheiden kann.
(zu Polymorphie kenne ich keine Probleme, außer daß erst zur Laufzeit
entschieden werden kann, welche Klasse es ist.)
Aufgbae 3:
siehe trace.sxc
Aufgabe 4:
Aufgabe 5:
Programmieren & Programmierspraschen Seminar 11.07.05
Phyton:
- Unterstützt OOP, imperativ, funktionale Programmierung
– Interpretierte Sprache
– Ziel: einfach und übersichtlich
Python
Java
C++
Code
10x
3-5x
1x
schreiben
schneller
schneller
als C++
als C++
Ausführung 1x
3-5x schneller
10x schneller als Phyton
als Phyton
– Skriptsprache
– (für C++, Java, Ooffice, Gimp, GnuPlot,...)
– Strukturierung durch Einrücken
– keine Formfreiheit mehr
– lesbar
– weniger syntaktische Elemente
– Große Standartbiblothek
– Garbage Collector
– intern alle Datentypen, Objekte
– Dynamische Verwaltung von Datentypen
-> ähnlich zu LISP
– Unterscheidung internerbenutzerdef. Typen
– interne Typen nicht ableitbar
– Exceptions
Vergleich mit Perl:
– Python lesbar
– Python einfacher für große Projekte
– Perl -> regular expressions -> text pattern matching besser
Klausurvorbereitung:
aus jeder Sprache eine Frage.
kein VI
LISP: Quersumme
(defun quer (zahl)
( if (> zahl 0)
(setq i (MOD (zahl 10)
(+ i quer ( / ( - zahl i) 10)))
0))
(quer 235 10)
LISP: Summer der ersten n-ten Zahlen
(defun sum(number)
(if (> number 0)
(+ number ( sum (- number 1)))
0))
// wenn n=0 dann ∑ = 0
PROLOG: drehen einer Liste
[a, b, c] -> [c, b, a]
reverse( L, A) :- rev(L,[],A).
rev([],A,A).
rev([H|L], R, A): - rev(L,[H, R], A).
Auswerten, Zuweisung in der Klausur
Prolog: addieren von Zahlen
(def cesar_rec (list offset)
(if leg list nil)
nil
(cons ( + (car list) offset)
(caesar_rec(cdr list) offset ))))
(3,7,2,9) , offset:5
(8, caesar_rec((7,2,9) 5))
C: Summe der ersten n-ten Zahlen
int sum(int number)
{
if(number>0)
return (number + sum(mumber -1));
return 0;
}
Zeiger sollte mit Zeigern umgehen können( !!keine Funktionszeiger!! )
Java:
wahrscheinlich keine Vererbung bei (schriftlicher) Programmierung.
wenig bis kein UML
keine Kreuzelfragen
50 % bestanden, wird nicht wirklich runter gehen...