Übung 1: Einführung in die Programmierung mit der Skriptsprache Lua

In diesem Tutorial sollen grundlegendene Kenntnisse in der Programmierung mit der Programmiersprache Lua erworben werden.

Inhalt.

Übung 1: Einführung in die Programmierung mit der Skriptsprache Lua

Einführung

Werte, Variablen, Ausdrücke

Steueranweisungen

Ergänzung: Mehrfachauswahl

Funktionen

Datentypen

Funktionen höherer Ordnung

Arrays und Records

Objekte und Klassen

Fehlerbehandlung und Signale

Einführung

Ein Programm in Ausführung wird in Daten- und Kontrollfluss unterteilt. Die prozedurale Programmiersprache Lua besteht aus eine Menge von Programmieranweisungen die man in folgende Klassen unterteilen kann:

Berechnung (Datenfluss)
Steuerung (Kontrollfluss)
Ein- und Ausgabe (Kontroll- und Datenfluss)
Komposition (Funktionen)
Typensystem, hier dynamisch zur Laufzeit automatisch abgeleitet.

Berechnungen (Datenfluss) bestehen wiederum aus folgenden Komponenten:

Werten (Konstanten, Literale)
Variablen
Operationen (Addition, usw.)

Eine Variable kann

veränderlich wie Speicher sein,
oder unveränderlich wie eine symbolische Variable in der Mathematik.

In den folgenden Beispielen und Aufgaben können Werte und Variableninhalte mit der print Funktion in dem unter dem Code befindlichen Ausgabefenster ausgegeben werden. Hat man komplexere Werte, wie z.B. Datenstrukturen und Arrays, kann man stattdessen die inspect Funktion verwenden.

Dieses Tutorial ist in Snippets unterteilt. Ein Snippet besteht aus einem Texteditorfenster und einem darunter befindlichen Kontroll- und Ausgabefenster. Das Kontrollfenster hat links den Run Knopf, der den Code ausführt, und rechts ein Erase Knopf, der das Ausgabefenster löscht.

Alle Codesnippets werden in einem sogenannten globalen Kontext ausgeführt, d.h., praktisch bilden sie ein Programm! Einzelne Codesnipptes können von der Ausführung vorheriger abhängen.

Daher bei einem Fehler prüfen ob die vorherigen Codesnipptes fehlerfrei ausgeführt wurden!

Alle Eingabefelder (Code und Antworten auf Fragen) können gespeichert und wieder in das interaktive Tutorial geladen werden (Linker und rechter Knopf in der Kopfzeile).

Die Inhalte von Programmcodefeldern können über ein WEB Clipboard mit anderen Teilnehmern geteilt werden (wenn sie gleichzeitig am Tutorial arbeiten). Dazu befindet sich rechts oben in einem Codeeditorfeld ein Kopfsymbol. Das WEB Clipboard Fenster ist spezifisch für dieses Codefeld! Der Copy Befefhl fügt den eigenen Programmcode zum Clipboard hinzu. Code anderer Nutzer kann aus der Liste durch öffnen des Spoiler importiert werden. Der aktuell ausgwählte Code kann durch den Paste Befehl übernommen werden. Code Schnippsel verschwinden nach einer gewissen Zeit wieder aus dem Clipboard (ca. 5 Minuten).

Der Lua Interpreter ist in diese WEB App integriert. Es werden keine externen Programme benötigt! Der Zustand des Interpreters kann momentan nur durch erneutes Laden der Seite zurückgesetzt werden (vorher alle Eingaben speichern).

In Lua werden einzelne Anweisungen entweder durch einen Zeilenumbruch oder ein Semikolon ; innerhalb einer Zeile getrennt. Ansonsten ist das Semikolon "syntaktischer Zucker". Einzelne Anweisungen werden immer in der angegebenen Reihenfolge ausgeführt (imperative Programmierung).

Weitere Informationen über Lua gibt es hier:

http://edu-9.de/uploads/documents/lua_tutorial.pdf

Werte, Variablen, Ausdrücke

Lua ist dynamisch typisiert, d.h., Datentypen von Werten und Ausdrücken werden erst zur Laufzeit bestimmt. Werte und Ausdrücke können über den = Operator einer Variablen zugewiesen werden. Lua kennt keine statische Typisierung, d.h., der Variablentyp ist polymorph und wird ausschließlich durch den aktuellen Inhalt bestimmt, der sich zur Laufzeit ändern kann.

Füge in den folgenden Code die print Anweisung für y, z und f ein und beobachte die Ausgabe.

Variablen und Werte

x=1       -- type number
y=false   -- type boolean
z='text'  -- type string 
f=function (x) return x*x end
print(x)

▸

✗

≡

Die Print Funktion kann wie üblich mit mehreren Argumenten aufgerufen werden.

Ausdrücke bestehen aus Operanden (können auch wieder Ausdrücke sein) und Operatoren, die Variablen, Funktionen oder Werte sein können:

Information. Lua Operatoren

Addition: +
Subtraktion: -
Multiplikation: *
Division: /
Modulo: %
Boolesches Und: and
Boolesches Oder: or
Boolesches Nicht: not
Mathematische Funktionen über das Math Objekt math.sin() usw.
usw.

Information. Lua Werte

Ganzzahliger Wert -2,-1,0,1,2,3,..
Gebrochen rationale Werte wie 1.3456
Exponentielle Werte wie 1.2E-3
Boolesche Werte false und true
Zeichenketten "text"
Funktionen (Werte erster Ordnung)

Zusammengesetzte Ausdrücke

x=x+23     
y=(x-1)*(x+1)  
z=y/2 
print(x,y,z)

▸

✗

≡

Aufgabe 1. Was passiert wenn man verschieden Datentypen in Ausdrücken verwendet, also z.B. Addition x+y und Boolesche Verknüpfung x and y? Probieren Sie alle Kombinationen (Ganzzahlwert, Rationale Werte, Boolescher Wert, Zeichenketten). Was geht, was nicht?

Typgemischte Ausdrücke

-- TODO

▸

✗

≡

Lösung.

Obwohl Lua polymorphe Operationen unterstützt sind die arithmetischen Operationen auf numerische Werte beschränkt, wohingegen die Booleschen Operatoren mit sämtlichen Datentypen gemischt verwendet werden können.

Aufgabe 2. Da es keine Datentypisierung im Programmtext gibt müssen (numerische) Werte von einem festgelegten Datentyp sein, z.B. Integer, Float (einfache Präzision, Mantisse , Double (doppelte Fließkommapräzision). Finde mit obigen Operatoren heraus welchen numerischen Datentyp diese Lua Implementierung verwendet.

-- TODO

▸

✗

≡

Lösung.

eD0xLzIKcHJpbnQoeCkgLS0gMC41LCBhbHNvIEZsaWVzc2tvbW1hCng9MS8zCnByaW50KHgpIC0tIDAuMzMzMzMzMzMzMzMzMzMsIGFsc28gd29obCBEb3VibGUKeD0xRTMwICAgLS0gU2luZ2xlL0RvdWJsZSBtw7ZnbGljaApwcmludCh4KQp4PTFFMzAwICAKcHJpbnQoeCkgLS0gTnVyIGJlaSBEb3VibGUgbcO2Z2xpY2gKeD0xRTkwMApwcmludCh4KQotLSBFaW5mYWNoZSBQcsOkemlzaW9uOiBNPTIzL0U9OCBCaXRzCi0tIERvcHBlbHRlIFByw6R6aXNpb246IE09NTIvRT0xMSBCaXRz

Man unterscheidet globale und lokale Variablen. Eine globale Variable wird einfach durch eine Zuweisungsanweisung x=v eingeführt. Eine lokale Variable wird durch die Anweisung local x=v eingeführt. Der Initialwert v ist optional. In Funktionen immer nur lokale Variablen definieren!

Aufgabe 3. Welchen Nachteil hat ein einheitlicher numerische Datentyp (bedenke auch Kontrollanweisungen wie inkrementelle Schleifen)?

Lösung.

Wenn der Datentyp Integer ist kann es schnell zu Über- oder Unterlauf kommen
Wenn der Datentyp Float/Double ist kann es zu Rundungsfehlern bei üblicherweise ganzzahligen Operationen wie Schleifenzähler kommen. Ein echtes Problem bei VMs!!

Lokale und globale Variablen

local x1=100
function foo1(x1)
  local x2
  x1=x1+1
  x2=x1*2
  return x2*x2
end
function foo2(x3)
  local x4=x3-1
  x1=x4
  return x4*2
end
print(x1,foo1(x1),foo2(12),x1)

▸

✗

≡

Aufgabe 4. Gebe in obigen Beispiel den Wert von x1 in foo2 aus. Was passiert? Und wenn x2 ausgegeben wird? Welchen Wert hat die globale Variable x1 nach der Ausführung von foo1? Ändere die äußere globale Definition von x1 an dieser Stelle in eine lokale (löcal x1=100) um. Was passiert?

Lösung.

Ausgabe ist 100 40804 22 11, d.h., in foo1 gibt es eine überdeckte Variable x1 als Funktionsparameter, in foo2 wird die globale Variable x1 verändert.
Ist die äußere Variable x1 lokal definiert dann kann diese nicht in der Funktion foo2 referenziert Wert (undefiniert)!. Aber warum?

Lokale Variablen können in Funktionen aber auch in Anweisungsblöcken (Schleifen, Bedingte Verzweigung) definiert und benutzt werden.

Steueranweisungen

Steueranweisungen dienen zur Beeinflussung des Programmflusses. Man unterscheidet (mit s als Anweisung oder einer Reihe von Anweisungen):

Bedingte Verzweigungen: if e then s1 else s2 end
Bedingte Schleifen: while e do s end
Zählschleifen: for i=a,b do s end oder mit einer Schrittweite d for i=a,b,d do s end

Folgendes Beispiel zeigt die Implementierung der Funktion:

local r=1
for index=1,10 do
  r=r*index
end
if r > 1000000 then 
  print('Big Number!') 
else
  print(r)
end

▸

✗

≡

Der Programmfluss von Schleifen ist in folgender Abbildung dargestellt (Flussdiagramme).

#loops

Aufgabe 5. Im folgenden Beispiel wird mit einer Turtlegraphik ein Oktagon gezeichnet. Ersetze den Code mit einer Zählschleife die die gleiche Figur zeichnet und in Winkelschritten zählt.

Information. Lua Turtle API

turtle:forward(n) moves the turtle in current direction n pixels forward
turtle:goTo(x,y) moves the turtle to a new position
turtle:left(n) turns turtle n degree left
turtle:right(n) turns turtle n degree right
turtle:reset() clears the drawing area
turtle:up() activates the pen
turtle:down() deactivates the pen

Beispiel Turtlegrafik

turtle:reset()
turtle:forward(50)
turtle:right(45)
turtle:forward(50)
turtle:right(45)
turtle:forward(50)
turtle:right(45)
turtle:forward(50)
turtle:right(45)
turtle:forward(50)
turtle:right(45)
turtle:forward(50)
turtle:right(45)
turtle:forward(50)
turtle:right(45)
turtle:forward(50)

▸		✗

Lösung.

dHVydGxlOnJlc2V0KCkKCmZvciBhID0gMCwzNjAsNDUgZG8KICB0dXJ0bGU6Zm9yd2FyZCg1MCkKICB0dXJ0bGU6cmlnaHQoNDUpCmVuZA==

Ergänzung: Mehrfachauswahl

In Lua gibt es keine Anweisung für die Mehrfachauswahl, d.h., der Vergleich eines Ausdrucks mit verschiedenen Werten und konditionaler Ausführung von Fallanweisungen. Erdatz ist eine if-elsif Kette, aber nicht schön. Es gibt eine funktionale Erweiterung über eine Falltabelle (in lvm usw. bereits enthalten):

Switch(expr).caseof({
  [v1] = function,
  [v2] = function,
  ...
  [v3] = v1,
  default = function
})

Switch erzeugt einen Selektor für den Ausdruck expr, der mit der
caseof Methode mit konstanten Werten v_i verglichen wird, und bei Übereinstimmung die Fallfunktion aufruft. Mehrere Werte v₁,v₂,.. können an einen einzigen Fall v mittels [v1]=v gebunden werden.

local x = 2
Switch(x).caseof({
  [1] = function () print(1) end,
  [2] = function () print(2) end,
  [3] = 2,
  default = function () print("all others") end
})

▸

✗

≡

Frage 6. Was passiert wenn die Anweisung mit x=3 ausgeführt wird?

Lösung.

Es wird der Fall [2] ausgeführt und ausgegeben (Krücke um Mehrfachbelegungen eines Falls zu ermöglichen).

Frage 7. Funktiioniert die Mehrfachauwahl auch mit Zeichenketten? Implementiere einen Wortdekoderfunction execute, die die Worte "add", "sub", "mul" und "div" dekodiert und die beien Operanden a und b entsprechend berechnet und das Ergebnis zurückgibt. Kann die Switch Funktion die Werte der Fallfunktionen zurückgeben? Teste mit Beispielen.

function execute(a,op,b) 
  Switch(op) ...

end
print(execute(10,"mul",20))

▸

✗

≡

Lösung.

ZnVuY3Rpb24gZXhlY3V0ZShhLG9wLGIpIAogIHJldHVybiBTd2l0Y2gob3ApLmNhc2VvZih7CiAgICBbImFkZCJdPWZ1bmN0aW9uICgpIHJldHVybiBhK2IgZW5kLAogICAgWyJkaXYiXT1mdW5jdGlvbiAoKSByZXR1cm4gYS9iIGVuZCwKICAgIFsibXVsIl09ZnVuY3Rpb24gKCkgcmV0dXJuIGEqYiBlbmQsCiAgICBbInN1YiJdPWZ1bmN0aW9uICgpIHJldHVybiBhLWIgZW5kCiAgfSkKCmVuZApwcmludChleGVjdXRlKDEwLCJhZGQiLDIwKSk=

Information. Funktionale Implementierung von switch-case

local function Switch(c)
  local swtbl 
  swtbl = {
    casevar = c,
    caseof = function (code)
      local f
      if swtbl.casevar ~= nil then
        f = code[swtbl.casevar] or code.default
      else
        f = code.missing or code.default
      end
      if type(f) == "string" then
        f = code[f] or code.default
      elseif type(f) == "number" then
        f = code[f] or code.default
      end
      if f then
        if type(f)=="function" then
          return f(swtbl.casevar,self)
        else
          error("case "..tostring(swtbl.casevar).." not a function ("..type(f)..")")
        end
      end
    end
  }
  return swtbl
end
Switch=switch

Funktionen

Funktionen dienen der Programmkomposition und der Wiederverwendung von Code. Man unterscheidet:

Funktionsdefinition
Funktionsapplikation

Eine Funktionsdefinition besteht aus:

Einem Namen (wobei anonyme Funktionen als sog. Lambda-ausdrücke zur Verfügung stehen);
Keinem, einen, oder mehrere Fuktionsparameter;
Einem Funktionsrumpf der eine Berechnung (mit den Parametern) durchführt UND/ODER prozedural wirkt (d.h. Ein- und Ausgabe, globalen Speicher verändern)
Einem Rückgabewert (auch bei Prozeduren: nil!), der mit der Anweisung return zurückgegeben wird.

Die Applikation ist einfach: Name der Funktion mit folgender Liste von Argumenten, d.h., foo(1,2,3). Füge in folgenden Beispielen Funktionsaufrufe (Applikationen) von foo und foo2 ein und gebe die Werte mit print aus.

Funktionsdefiniton und Funktionsapplikation

function foo(a,b,c)
  return a+b+c
end
function foo2(a,b,c)
  return not a and b and c
end
print(foo(1,2,3))

▸

✗

≡

Frage 8. Was passiert wenn die Anzahl der Argumente kleiner oder größer als die Anzahl der Funktionsparameter ist? Teste es mit foo und foo2.

Lösung.

Mehr Argumente als Parameter werden ignoriert
Weniger Argumente als Parameter setzen die Parameter ohne Argumentwerte auf nil.

Frage 9. Was ist Funktionsrekursion?

Wenn eine Funktion sich in ihrem Funktionsrumpf selbst aufruft!

Wende die Funktionen fac und facsq für die Werte 1,10,20 an und gebe die Werte aus. Ein kleiner Tipp: Obwohl Lua eigentlich nur Fliesskommawerte (quasi reelle Zahlen) verarbeitet (und keine ganzen), unterscheidet der Lua Interpreter der in diese WEB App integriert ist (aus einem mir nicht bekannten Grund) ganze Zahlen (Integer, 1,2,3,..) und Fliesskommazahlen (Float, 1.0, 1.1, 1.2, ..). Probiere einmal als Wert 10 und dann 10.0 ...

Funktionskomposition

function fac(n)
  if n > 1 then return n*fac(n-1)
  else return n end
end
function facsq(n)
  return fac(n)*fac(n)
end

▸

✗

≡

Frage 10. Wie kann die Berechnung von facsq optimiert werden (Annahme: Berechung von fac ist rechenintensiv!). Messe die Rechenzeit durch wiederholte Ausführung von facsq und mittels der os.milli() Funktion. Was ist bei der Messung zu beobachten?

Lösung.

LS0gTHVhIG5pbW10IGkuQS4ga2VpbmUga29tcGxleGVuIEF1c2RydWNrc29wdGltaWVydW5nZW4gdm9yIChhbmRlcnMgYWxzIHouQi4gSGFza2VsbCkKZnVuY3Rpb24gZmFjKG4pCiAgaWYgbiA+IDEgdGhlbiByZXR1cm4gbipmYWMobi0xKQogIGVsc2UgcmV0dXJuIG4gZW5kCmVuZApmdW5jdGlvbiBmYWNzcShuKQogIGxvY2FsIHk9ZmFjKG4pCiAgcmV0dXJuIHkqeQplbmQKbG9jYWwgdDA9b3MubWlsbGkoKQpmb3IgaT0xLDEwMCBkbwogIGZhY3NxKDIwKQplbmQKbG9jYWwgdDE9b3MubWlsbGkoKQotLSBEaWUgWmVpdCBzY2h3YW5rdCEgV2FydW0/CnByaW50KHQxLXQwKQ==

Aufgabe 11. In der folgenden Aufgabe soll die Fibonacci Funktion implementiert und getestet werden. Benutze Funktionsrekursion! Es sollen alle Fibonacci Zahlen für n={1,2,3,4,..,20} berechnet und ausgegeben werden.

#fib

Fibonacci Funktion

function fib(n)
 -- Hier Code!
end

▸

✗

≡

Lösung.

ZnVuY3Rpb24gZmliKG4pCiAgaWYgbj4xIHRoZW4KICAgIHJldHVybiBmaWIobi0xKStmaWIobi0yKQogIGVsc2UKICAgIHJldHVybiAxCiAgZW5kCmVuZApmb3Igbj0xLDIwIGRvCiAgcHJpbnQoZmliKG4pKQplbmQ=

Datentypen

Variablen in Lua sind polymorph. Somit auch Funktionen, d.h. deren Funktionsparameter und der Rückgabewert! Es gibt nur wenige Grunddatentypen in Lua:

number
boolean
string
table
function
(userdata)

That's all folks!

Der Datentyp eines Wertes (einer Variablen) kann mit der type Funktionen ermittelt werden (gibt einen Stringwert zurück).

Datentypen

x=fac(2)
y='test'
sq=function (x) return x*x end

▸

✗

≡

Aufgabe 12. Teste und gebe die Datentypen der Werte von x, y, und sq mit der print(type(v)) Anweisung aus.

Ja richtig erkannt: Funktionen sind Werte in Lua!!! Funktionen können in Variablen enthalten sein, an Funktionen als Argument übergeben werden, und von Funktionen als Wert zurückgegebn werden!

Funktionen höherer Ordnung

Da Funktionen auch Werte (erster Ordnung) sind, kann man damit viele Berechnungen vereinfachen bzw. abstrahieren.

Beispiel ist die Berechnung eines bestimmten Integrals einer beliebigen Funktion. Man müsste für jede Funktion die Integralberechnung immer wieder definieren. Es geht auch anders:

function integral(f)
  return function (a,b) 
    local res=0
    for i=a,b do
      res = res + f(i)
    end
    return res / (b-a)
  end
end
ix = integral(function (x) return x end)
print(ix(1,100))

▸

✗

≡

Aufgabe 13. Füge eine Integralfunktion isqx für die Quadratfunktion x • x und isinx für die Sinusfunktion math.sin hinzu und teste exemplarisch.

Spezifische Funktionen von Funktionen höherer Ordnung

isqx=
isinx=

▸

✗

≡

Lösung.

aXNxeD1pbnRlZ3JhbChmdW5jdGlvbiAoeCkgcmV0dXJuIHgqeCBlbmQpCmlzaW54PWludGVncmFsKGZ1bmN0aW9uICh4KSByZXR1cm4gbWF0aC5zaW4oeCkgZW5kKQ==

Arrays und Records

Um Daten namentlich zu binden verwendet man Arrays und Records (Datenstrukturen). Der Unterschied zwischen beiden ist gering. Die Elemente von Arrays werden über einen numerischen Index (1,2,..) ausgewählt, die von Records durch die vom Programmierer gegebenen Namen der Elemente. Anders als in Programmiersprachen mit statischen Typsystem (C, Java) können auch Arrays in Lua mehrsortig sein, d.h. die Elemente können unterschiedliche Datentypen haben!

Arrays und Records sind in Lua sog. Tabellen. Genau genommen sind es beide Hashtabellen. Arrays und Records werden in Lua wie folgt definiert (v_i sind Werte oder Ausdrücke):

-- Array
local a = {v1,v2,..,vn}
-- Record
local r = {e1=v1, e2=v2, .. , en:vn}

Es gibt zwei Arten auf die Elemente von Records zuzugreifen:

x=r['ei']
x=r.ei

Die Länge eines indizierten Arrays kann durch den #a Operator ermittelt werden (d.h. die Anzahl der Elemente).

Folgende Beispiele sollen dies verdeutlichen:

a1 = {1,2,3,4}
ax1 = a1[2]
ax2 = a1['2']
ax3 = a1['name']

r1 = {a=1,b=2,c=3}
rx1 = r1.a
rx2 = r1['a']
rx3 = r1.b
rx4 = r1['b']

a2 = {1,false,'name'}
ax5 = a2[1]
ax6 = a2[2]

▸

✗

≡

Frage 14. Welche Werte haben die einzelnen Variablen ax_i und rx_i? Lese nach was Hashtabellen sind (Wikepedia https://de.wikipedia.org/wiki/Hashtabelle) und erkläre die Ergebnisse.

Lösung.

a1 ist eine numerische Tabelle (Array) mit typischer Indizierung 1,2,..
ax1 und ax2 mit den Index(Schlüssel)werten 2 und "2" sind eigentlich Synonyme, werden in JavaScript auch gleich behandelt (lifern das gleiche Ergebnis), aber nicht in Lua. Daher ist ax2 undefiniert (nil).
ax3 ist sowieso undefiniert da "name" kein definierter Schlüssel ist
r1 ist eine Abbildungstabelle (Record) mit numerischen Werten die einen Elementnamen auf einen Wert abbildet. Da Namen auch Zeichenketten sind liefern rx1 und rx2 sowie rx3 und rx4 die gleichern Werte
a2 ist ein gemischtes (mehrsortigess) Array und daher liefern unterschiedliche Elemente Werte mit unterschiedlichen Datentypen (hier ax5 einen numerischen Wert und ax6 einen Booleschen Wert)

Arrays und Records gehören zur prozeduralen Programmierung. D.h., man definiert Arrays/Records getrennt von Funktionen die die Arrays/Records verarbeiten. Beispiele:

function sum(a)
  local z=0
  for i=1,#a do
    z = z + a[i]
  end
  return z
end

function sum2(r)
  local z=0
  for p in pairs(r) do
    z = z + r[p]
  end
  return z
end

a={10,34,12,56}
print(sum(a))

r={a=10,b=34,c=12,d=56}
print(sum2(r))

▸

✗

≡

Über Tabellen (Indizierte Arrays wie Records) kann mittels Schleifen und des k,v in pairs(t) oder i,v in ipairs(t) Operators iteriert werden. Der Paaroper pairs liefert Schlüssel (k ist eine Zeichenkette), und ipairs einen Index (i ist ein numerischer Wert). Zu beachten ist dass die Paaroperatoren rechenintensiver sind als dir direkte Indizierung.

Iteration über Tabellen

a = {"one", "two", "three"}
for i = 1,#a do
  print(type(i), i, a[i])
end
for i, v in pairs(a) do
  print(type(i), i, v)
end
for i, v in ipairs(a) do
  print(type(i), i, v)
end

▸

✗

≡

Frage 15. Was ist das Problem bei der getrennten Programmierung von Daten und Funktionen die auf diesen Daten arbeiten?

Betrachte folgendes Beispiel:

print(sum(r))
print(sum2(a))

▸

✗

≡

Aufgabe 16. Implementiere die Berechnung eines Skalarprodukts zweier zweidimensionaler Matrizen a und b die durch lineare Arrays gegeben sind. Dabei muss eine Indexrechung durchgeführt werden: Wenn N die Anzahl von Zeilen und Spalten der Matrizen ist, dann ist der lineare Index für Index(row,col)=(row-1)*N+col.

\[ {c}{\left({i},{j}\right)}=\sum_{{k}}{a}{\left({i},{k}\right)}{b}{\left({k},{j}\right)} \]

local N = 20
local a = Array(N*N,0)
...
function dotprod(a,b) 
  local c = Array(#a,0)
  ...
end

▸

✗

≡

Lösung.

bG9jYWwgTiA9IDIwCmxvY2FsIGEgPSBBcnJheShOKk4sMCkKLi4uCmZ1bmN0aW9uIGRvdHByb2QoYSxiKSAKICBsb2NhbCBjID0gQXJyYXkoI2EsMCkKICBmb3IgaT0wLE4tMSBkbwogICAgZm9yIGo9MCxOLTEgZG8KICAgICAgbG9jYWwgcz0wCiAgICAgIGxvY2FsIGNpID0gTippK2oKICAgICAgZm9yIGs9MCxOLTEgZG8KICAgICAgICBsb2NhbCBhaSA9IE4qaStrIAogICAgICAgIGxvY2FsIGJpID0gTiprK2oKICAgICAgICBzPXMrYVthaSsxXSpiW2JpKzFdCiAgICAgIGVuZAogICAgICBjW2NpKzFdPXMKICAgIGVuZAogIGVuZAogIHJldHVybiBjCmVuZA==

Objekte und Klassen

Objekte binden Daten und Funktionen (hier genannt Methoden). Die Methoden arbeiten nur auf Daten ihres Objekts. Objekte werden von Klassenprototypen erzeugt.

In Lua gibt es keine Klassen und somit auch keine Objekte. Diese müssen mit Tabellen "emuliert" werden, d.h. die Bindung von Prototypenfunktionen an Tabellen.

Da Funktionen Werte sind kann man erst einmal Records (also Tabellen) direkt verwenden. Ist das schon ein Objekt nach obiger Definition?

local r = {
  x  = 16,
  sq = function (x) return x*x end
}
print(r.sq(r.x))

▸

✗

≡

Da die Bindung von Prototypenfunktionen an Tabellen etwas kompliziert ist gibt es eine einfache Funktion um eine leere Klasse als Tabelle zu definieren: Class(). Es können dann "Methoden" (also Funktionsprototypen) hinzugefügt werden und beliebig viele Objekte von dieser Klasse erzeugt werden:

-- Definition einer leeren Klasse
local myclass = Class()
-- Hinzufügen von Methoden (init wird bei Erzeugung aufgerufen)
function myclass:init(x) self.x=x end
function myclass:getx()  return self.x end
function myclass:setx(v) self.x=v end

-- Erzeugung eines Objekts der Klasse myclass
local o1 = myclass:new(100)
-- Anwendung einer Methode
print(o1:getx())

▸

✗

≡

Erweitere die Klasse um die Methoden incr und decr die die Objektvariable x um eins erhöht oder erniedrigt. Teste die Methoden exemplarisch.

Zu beachten ist der Doppelpunkt zwischen Klassenname und Methodenname! Dieser sorgt für eine Bindung der Funktion an das Objekt!

Information. Implementierung der Class Funktion

local function class()
  local Class = {}; Class.__index = Class;
  function Class:new(...)
    local self = setmetatable({}, Class)
    if Class.init then Class.init(self,...) end
    return self
  end
  return Class
end
Class=class

Aufgabe 17. Programmiere eine Matrix Klasse die (zweidimensionale) Matrizen mit linearen Arrays erzeugen kann. Weiterhin sollen die Operationen elemntweises addieren, subtrahierne, multiplizieren, und dividieren sowie das oben schon implementierte Skalarprodukt als Methode hinzugefügt werden.

Matrix = Class()
function Matrix:init(rows,cols) self.rows=rows ... self.data=Array(...) end
...

▸

✗

≡

Fehlerbehandlung und Signale

In einem Programm können Fehler auftreten:

Eine undefinierte Variable oder Funktion wird verwendet/aufgerufen
Division durch Null
Eine Variable mit dem Wert nil wird weiter dereferenziert (z.B. x[9], x.attr)
..

Ein Fehler löst ein Signal aus (ein Ausnahmesignal). Wird dieses Signal nicht behandelt, führt dies zum Abbruch des Programms (i.A.). Es gibt aber auch Signale die man verwendet um an einer Stelle des Programms an eine andere "höhergelegene" Stelle zu gelangen. Entweder geplant oder auch um "seitwärts" aus einer Funktion bei einem Fehler (nicht schwerwiegend) wieder zum aufrufenden Kontext zu gelangen.

Programmiersprachen wie Java oder JavaScript bieten Signalbehandlung mittels einer try catch Anweisung, Lua leider nicht direkt/komfortabel (nur mittels der pcall oder xpcall Funktionen).

Ein Signal kann in Lua durch die raise(signal) Anweisung ausgelöst werden. Das Signal ist i.A. ein Stringname.

function incr(x)
  if x == nil then raise "Invalid argument" end
  return x+1
end
print(incr(10))
local status = pcall(function () print(incr(10)) end)

▸

✗

≡

Frage 18. Was passiert wenn die Funktion ohne Argument aufgerufen wird? Wie ändert sich das Verhalten bei Aufruf von incr durch pcall(function () .. end)? Was gibt pcall als Wert zurück (mit print testen)? Welche Wert lifert status?

Lösung.

Ohne pcall wird ein Fehler ausgelöst (und Abbruch)
Mit pcall passiert nichts.
pcall liefert true bei fehlerfreier Ausführung, ansonsten false

Man kann die fehlende try-catch Anweisung aber funktional ergänzen, und man erhält dann:

Try (function () 
  print(incr(2))
  print(incr())
end).catch(function (err)
  print(err)
end)
print('After try-catch')

▸

✗

≡

Information. Try-catch Code (abhängig ob natives Lua-C oder Lua-JS verwendet wird)

local functionType = "function"
local function Try (tryBlock)
    local status, err = true, nil, trace
    function traceback(e)
      trace = e;
      return e 
    end
	if type(tryBlock) == functionType then
		status, err = xpcall(tryBlock,traceback)
	end

	local _finally = function (finallyBlock, catchBlockDeclared)
		if type(finallyBlock) == functionType then
			finallyBlock()
		end
		
		if not catchBlockDeclared and not status then
			raise(err)
		end
	end

	local _catch = function (catchBlock)
		local catchBlockDeclared = type(catchBlock) == functionType;

		if not status and catchBlockDeclared then
			local ex = err or "unknown error occurred"
			catchBlock(ex,trace)
		end

		return {
			finally = function(finallyBlock)
				_finally(finallyBlock, catchBlockDeclared)
			end
		}
	end

	return
	{
		catch = _catch,
		finally = function(finallyBlock)
		    _finally(finallyBlock, false)
		  end
	}
end
Try=try

Hilfe

Einreichung (Assignment #2025-20874)

Prüfen

Bewerten (Lehrer)

Created by the NoteBook Compiler Ver. 1.36.2 (c) Dr. Stefan Bosse (Tue Apr 22 2025 23:12:40 GMT+0200 (Central European Summer Time))