In diesem Teil der Einführung in Lua zeigen wir wie immer anhand von Beispielen die grundlegenden Funktionsweisen der Kontrollstrukturen und Funktionsaufrufe. Wie immer verweisen wir für tieferes Verständnis auf die offizielle Lua-Doku. Im dritten Teil der Lua-Einführung werden wir Tables und Datenstrukturen behandeln. In den folgenden Beiträgen wird es um Errorhandling und um das Entwickeln und Einbinden von einem einfachen C-Modul gehen.

Funktionsaufruf mit einem Parametern

das local Keyword für die Variable file sagt aus, dass der Variablenname nur in diesem Scope gültig ist.
Überdies sehen wir hier ein einfaches if-Statement

function openFile(path)
    local file = io.open(path, "rb") -- r read mode and b binary mode
    if not file then return nil end
    return true
end

Funktionsaufruf mit einem Parametern

Umwandeln einer Zahl in einen String mit der toString-Funktion. Über einen String iterieren (#x ist die Länge des Strings).
string.sub ist die Substring-Funktion.


--[[ 
Eine natürliche Zahl wird Münchhausen-Zahl genannt, wenn die Summe ihrer einzelnen mit sich selbst potenzierten Ziffern wieder diese Zahl ergeben. 
]]--
local function isMunchhausen(num)
	x = tostring(num) --typecast to string
	local res = 0
	
	for i = 1, #x do
		c = string.sub(x, i, i) --substring (also x:sub(i,i) )
		res = res + (c+0) ^ (c+0) --implicit type cast to number (int in lua >= 5.3)
	end

	return res == num --return boolean
end

for i=1, 100000000000 do
	if isMunchhausen(i) then
		print(i)
	end
end

Einem Table-Key eine Funktion zuweisen

Wir deklarieren eine Variable t mit einem leeren Table. Dann weisen wir dem Table-Key foo eine lambda-Funtion zu, die zwei Werte summiert.

t = {}
t.foo = function (x,y) return x + y end
print(t.foo(3,4)) --call function of table-key with two values

Funktionsaufruf mit zwei Parametern und einfacher for-Schleife

man beachte die Funktion pairs(), die über den table iteriert und das Keyword local vor der Funktionsdefinition


--[[ 
das Kartesische Produkt in Lua

das kartesische Produkt zweier Mengen ist definiert als die Menge aller Tupel (a,b),
wobei a ein Element aus A und b ein Element aus B ist
A x B := { (a,b) | a ∈ A und b ∈ B }

der euklidische Raum ℝ³ beispielsweise besteht aus dem dreifachen kartesischen Produkt
der reellen Zahlen ℝ (Dreier-Tupel)
ℝ x ℝ x ℝ = ℝ³ {(x,y,z) | x ∈ ℝ, y ∈ ℝ, z ∈ ℝ}

in Python existiert die Methode:
list(itertools.product((1,2), (3,4)))
]]--

-- load inspect (e.g. install with luarocks)
local inspect = require('inspect') 

-- create cartestian product of two tupels (implemented as lua tables)
-- @param t1 table, first tupel
-- @param t2 table, second tupel
-- @return table cartesian product
local function buildProduct(t1, t2)
	local p = {}
	for x,v1 in pairs(t1) do
		 for z,v2 in pairs(t2) do 
			t = {v1,v2}
			table.insert(p, t)
		 end
	end
	return p
end


-- build cartesian product of two tupels 1,3 1,4 2,3 2,4
a = {1,2,3}
b = {4,5,6}
result = buildProduct(a,b)

-- dump result
print(inspect(result))

--[[ 
Ergebnis:
{ { 1, 3 }, { 1, 4 }, { 1, 8 }, { 2, 3 }, { 2, 4 }, { 2, 8 }, 
{ 6, 3 }, { 6, 4 }, { 6, 8 } }
]]--

0 Kommentare

Dein Kommentar

An Diskussion beteiligen?
Hinterlasse uns Deinen Kommentar!

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.