Initial commit

doc.go

@@ -0,0 +1,6 @@
+// Präsentation3hGolang4LGLRef31 project doc.go
+
+/*
+Präsentation3hGolang4LGLRef31 document
+*/
+package main

go2lgl_l01/doc.go

@@ -0,0 +1,9 @@
+/*
+Landesamt für Geoinformation und Landentwicklung, Referat 35
+Einführung in die Sprache Go, 25.7.2017
+Lektion 1: Gaußsche Normalverteilung nach dem Zufallsprinzip
+
+Das Beispiel der Gaußschen Normalverteilung wurde gewählt, weil es mit wenig Zeilen Code eine relativ zeitaufwendige Berechnung bewirkt, die zudem beliebig skalierbar ist.
+*/
+
+package main

go2lgl_l01/go2lgl_l01.go

@@ -0,0 +1,49 @@
+/*
+Landesamt für Geoinformation und Landentwicklung, Referat 35
+Einführung in die Sprache Go, 25.7.2017
+Lektion 1: Gaußsche Normalverteilung nach dem Zufallsprinzip
+*/
+package main
+
+import (
+	"fmt"
+	"math/rand"
+	"time"
+)
+
+const (
+	anzahlTöpfchen int8  = 25
+	anzahlKugeln   int32 = 100000
+)
+
+var timestamp [2]int64
+
+func main() {
+
+	var (
+		töpfchenAlle      [anzahlTöpfchen]int16
+		töpfchenTmpZähler int16
+	)
+
+	timestamp[0] = time.Now().Unix()
+	for k := (int32)(1); k <= anzahlKugeln; k++ {
+		töpfchenTmpZähler = 0
+		for i := (int8)(0); i < anzahlTöpfchen-1; i++ {
+
+			if yesnotrigger := func() bool {
+				rand.Seed(time.Now().UnixNano()) //rand.New(rand.NewSource(time.Now().UnixNano())).Float64()
+				if rand.Float64() < 0.5 {
+					return true
+				} else {
+					return false
+				}
+			}(); yesnotrigger == true {
+				töpfchenTmpZähler++
+			}
+		}
+		töpfchenAlle[töpfchenTmpZähler]++
+	}
+	fmt.Println(töpfchenAlle)
+	timestamp[1] = time.Now().Unix()
+	fmt.Printf("\nProzess ist fertig und hat %v Sekunden gedauert!\n\n", (timestamp[1] - timestamp[0]))
+}

go2lgl_l02/derTöpfchenfüller/derTöpfchenfüller.go

@@ -0,0 +1,31 @@
+package derTöpfchenfüller
+
+import (
+	"math/rand"
+	"time"
+)
+
+func MachMirDenGauß(anzahlKugeln int, anzahlTöpfchen int) []int { // großes M = public; kleines m = private
+	var (
+		töpfchenAlle      []int = make([]int, anzahlTöpfchen, anzahlTöpfchen) // Achtung ein statische Array geht jetzt nicht meht, da "anzahlTöpfchen" keine Konstante mehr ist => Erzeuge ein Slice; da das Slice danach nicht mehr verändert wird, kann die Kapazität der Länge gleich sein.
+		töpfchenTmpZähler int
+	)
+
+	for k := 1; k <= anzahlKugeln; k++ {
+		töpfchenTmpZähler = 0
+		for i := 0; i < anzahlTöpfchen-1; i++ {
+
+			if yesnotrigger := func() bool {
+				if rand.New(rand.NewSource(time.Now().UnixNano())).Float64() < 0.5 {
+					return true
+				} else {
+					return false
+				}
+			}(); yesnotrigger == true {
+				töpfchenTmpZähler++
+			}
+		}
+		töpfchenAlle[töpfchenTmpZähler]++
+	}
+	return (töpfchenAlle)
+}

go2lgl_l02/go2lgl_l02.go

@@ -0,0 +1,28 @@
+/*
+Landesamt für Geoinformation und Landentwicklung, Referat 35
+Einführung in die Sprache Go, 25.7.2017
+Lektion 2: Parameterübergabe an Funktionen und Packages
+*/
+package main
+
+import (
+	"fmt"
+	"math"
+	"time"
+
+	dtf "Präsentation3hGolang4LGLRef35/go2lgl_l02/derTöpfchenfüller"
+)
+
+const (
+	anzahlTöpfchen int8  = 25
+	anzahlKugeln   int32 = 100000
+)
+
+var timestamp [2]int64
+
+func main() {
+	timestamp[0] = time.Now().UnixNano()
+	fmt.Println(dtf.MachMirDenGauß(int(anzahlKugeln), int(anzahlTöpfchen)))
+	timestamp[1] = time.Now().UnixNano()
+	fmt.Printf("\nProzess ist fertig und hat %v Sekunden gedauert!\n\n", float64(timestamp[1]-timestamp[0])*math.Pow(10, -9))
+}

go2lgl_l03/go2lgl_l03.go

@@ -0,0 +1,48 @@
+/*
+Landesamt für Geoinformation und Landentwicklung, Referat 35
+Einführung in die Sprache Go, 25.7.2017
+Lektion 3: Zeiger
+*/
+package main
+
+import (
+	"fmt"
+	"math"
+	"math/rand"
+	"time"
+)
+
+const (
+	anzahlTöpfchen int8  = 25
+	anzahlKugeln   int32 = 100000
+)
+
+var timestamp [2]int64
+
+func main() {
+	timestamp[0] = time.Now().UnixNano()
+	var töpfchenAlle []int = make([]int, anzahlTöpfchen, anzahlTöpfchen)
+	for k := (int32)(1); k <= anzahlKugeln; k++ {
+		zeigeMirDenGauß(int(anzahlKugeln), int(anzahlTöpfchen), &töpfchenAlle)
+	}
+	fmt.Println(töpfchenAlle)
+	timestamp[1] = time.Now().UnixNano()
+	fmt.Printf("\nProzess ist fertig und hat %v Sekunden gedauert!\n\n", float64(timestamp[1]-timestamp[0])*math.Pow(10, -9))
+}
+
+func zeigeMirDenGauß(anzahlKugeln int, anzahlTöpfchen int, töpfchenAlle *[]int) { // kleines z genügt
+	var töpfchenTmpZähler int
+
+	for i := 0; i < anzahlTöpfchen-1; i++ {
+		if yesnotrigger := func() bool {
+			if rand.New(rand.NewSource(time.Now().UnixNano())).Float64() < 0.5 {
+				return true
+			} else {
+				return false
+			}
+		}(); yesnotrigger == true {
+			töpfchenTmpZähler++
+		}
+	}
+	(*töpfchenAlle)[töpfchenTmpZähler]++
+}

go2lgl_l04/go2lgl_l04.go

@@ -0,0 +1,56 @@
+/*
+Landesamt für Geoinformation und Landentwicklung, Referat 35
+Einführung in die Sprache Go, 25.7.2017
+Lektion 4: Nebenläufigkeit
+*/
+package main
+
+import (
+	"fmt"
+	"math"
+	"math/rand"
+	"runtime"
+	"sync"
+	"time"
+)
+
+const (
+	anzahlTöpfchen int8  = 25
+	anzahlKugeln   int32 = 100000
+)
+
+var timestamp [2]int64
+
+var wg sync.WaitGroup // !
+
+func main() {
+	runtime.GOMAXPROCS(runtime.NumCPU()) // !
+	timestamp[0] = time.Now().UnixNano()
+	var töpfchenAlle []int = make([]int, anzahlTöpfchen, anzahlTöpfchen)
+	for k := (int32)(1); k <= anzahlKugeln; k++ {
+		wg.Add(1)
+		go zeigeMirDenGauß(int(anzahlKugeln), int(anzahlTöpfchen), &töpfchenAlle) // !
+	}
+	wg.Wait() // !
+	fmt.Println(töpfchenAlle)
+	timestamp[1] = time.Now().UnixNano()
+	fmt.Printf("\nProzess ist fertig und hat %v Sekunden gedauert!\n\n", float64(timestamp[1]-timestamp[0])*math.Pow(10, -9))
+}
+
+func zeigeMirDenGauß(anzahlKugeln int, anzahlTöpfchen int, töpfchenAlle *[]int) { // kleines z genügt
+	defer wg.Done() // !
+	var töpfchenTmpZähler int
+
+	for i := 0; i < anzahlTöpfchen-1; i++ {
+		if yesnotrigger := func() bool {
+			if rand.New(rand.NewSource(time.Now().UnixNano())).Float64() < 0.5 {
+				return true
+			} else {
+				return false
+			}
+		}(); yesnotrigger == true {
+			töpfchenTmpZähler++
+		}
+	}
+	(*töpfchenAlle)[töpfchenTmpZähler]++
+}

go2lgl_l05/go2lgl_l05.go

@@ -0,0 +1,32 @@
+/*
+Landesamt für Geoinformation und Landentwicklung, Referat 35
+Einführung in die Sprache Go, 25.7.2017
+Lektion 5: Exkurs zu defer, recover, panic => Error Handling; Der Error ist ein Datentyp
+*/
+
+package main
+
+import (
+	"fmt"
+)
+
+func main() {
+	defer func() {
+		if r := recover(); r != nil {
+			fmt.Printf("Es gab einen Fehler: \"%v\"\n", r)
+		}
+	}()
+	eineFunktion(10, 11)
+	fmt.Println("Und trotzdem kann der Code weiter rausgeführt werden")
+}
+
+func eineFunktion(a int, b int) {
+	defer func() {
+		if r := recover(); r != nil {
+			fmt.Printf("Es gab einen Fehler: \"%v\"\n", r)
+		}
+	}()
+	if (a - b) < 0 {
+		panic("Ich mache ständig Fehler!")
+	}
+}

go2lgl_l06/go2lgl_l06.go

@@ -0,0 +1,90 @@
+/*
+Landesamt für Geoinformation und Landentwicklung, Referat 35
+Einführung in die Sprache Go, 25.7.2017
+Lektion 6: Kommunikation zwischen nebenläufigen Prozessen
+*/
+package main
+
+import (
+	"fmt"
+	"math"
+	"math/rand"
+	"runtime"
+	"sync"
+	"time"
+)
+
+const (
+	anzahlTöpfchen int8  = 25
+	anzahlKugeln   int32 = 100000
+)
+
+var timestamp [2]int64
+
+var wg, wg2 sync.WaitGroup // !
+
+func main() {
+	runtime.GOMAXPROCS(runtime.NumCPU())
+	timestamp[0] = time.Now().UnixNano()
+
+	var töpfchenAlle []int = make([]int, anzahlTöpfchen, anzahlTöpfchen)
+	var c chan bool = make(chan bool, 1) // !
+
+	wg2.Add(1)
+	go func(t *[]int, ch chan bool) { // !
+		defer wg2.Done()
+		for true {
+			/* Bringt nichts, weil auf <-ch == true gewartet werden müßte:
+			time.Sleep(time.Second * 1)
+			if <-ch == true {
+				return
+			} else {
+
+			}*/
+			/*stattdessen:*/
+			select {
+			case <-ch: // oder <-ch == true
+				return
+			default:
+				fmt.Println("\u231B", *t, runtime.NumGoroutine())
+				time.Sleep(time.Second * 1)
+			}
+		}
+	}(&töpfchenAlle, c)
+
+	for k := (int32)(1); k <= anzahlKugeln; k++ {
+		// Limitiere die Anzahl der go-Routinen
+		if rn := runtime.NumGoroutine(); rn > 50 { // !
+			time.Sleep(time.Millisecond * 1)
+		} else {
+			wg.Add(1)
+			go zeigeMirDenGauß(int(anzahlKugeln), int(anzahlTöpfchen), &töpfchenAlle)
+		}
+	}
+	wg.Wait()
+	c <- true
+
+	wg2.Wait()
+
+	fmt.Println("\u2690", töpfchenAlle)
+	timestamp[1] = time.Now().UnixNano()
+	fmt.Printf("\nProzess ist fertig und hat %v Sekunden gedauert!\n\n", (float64(timestamp[1]-timestamp[0]) * math.Pow(10, -9)))
+}
+
+func zeigeMirDenGauß(anzahlKugeln int, anzahlTöpfchen int, töpfchenAlle *[]int) {
+	defer wg.Done()
+	var töpfchenTmpZähler int
+
+	for i := 0; i < anzahlTöpfchen-1; i++ {
+		if yesnotrigger := func() bool {
+			if rand.New(rand.NewSource(time.Now().UnixNano())).Float64() < 0.5 {
+				return true
+			} else {
+				return false
+			}
+		}(); yesnotrigger == true {
+			töpfchenTmpZähler++
+		}
+	}
+	(*töpfchenAlle)[töpfchenTmpZähler]++
+}

go2lgl_l07/go2lgl_l07.go

@@ -0,0 +1,103 @@
+/*
+Landesamt für Geoinformation und Landentwicklung, Referat 35
+Einführung in die Sprache Go, 25.7.2017
+Lektion 7: Löse ein Problem objektorientiert
+*/
+package main
+
+import (
+	"fmt"
+	"math"
+	"math/rand"
+	"runtime"
+	"sync"
+	"time"
+)
+
+type zeiten struct {
+	tt []int64
+}
+
+func (this *zeiten) zeitmess() { // Hier ist der Pointer notwendig, sonnst werden die Veränderungen nicht gespeichert. (Variablen global lesbar, lokal beschreibbar)
+	this.tt = append(this.tt, time.Now().UnixNano())
+}
+
+func (this zeiten) zeitgeb(index int) int64 {
+	return this.tt[index] - this.tt[index-1]
+}
+
+const (
+	anzahlTöpfchen int8  = 25
+	anzahlKugeln   int32 = 100000
+)
+
+var timestamp [2]int64
+
+var wg, wg2 sync.WaitGroup // !
+
+func main() {
+	runtime.GOMAXPROCS(runtime.NumCPU())
+
+	var z zeiten = zeiten{}
+	var töpfchenAlle []int = make([]int, anzahlTöpfchen, anzahlTöpfchen)
+	var c chan bool = make(chan bool, 1) // !
+
+	z.zeitmess()
+	wg2.Add(1)
+	go func(t *[]int, ch chan bool) { // !
+		defer wg2.Done()
+		for true {
+			/* Bringt nichts, weil auf <-ch == true gewartet werden müßte:
+			time.Sleep(time.Second * 1)
+			if <-ch == true {
+				return
+			} else {
+
+			}*/
+			/*stattdessen:*/
+			select {
+			case <-ch: // oder <-ch == true
+				return
+			default:
+				fmt.Println("\u231B", *t, runtime.NumGoroutine())
+				time.Sleep(time.Second * 1)
+			}
+		}
+	}(&töpfchenAlle, c)
+
+	for k := (int32)(1); k <= anzahlKugeln; k++ {
+		// Limitiere die Anzahl der go-Routinen
+		if rn := runtime.NumGoroutine(); rn > 50 { // !
+			time.Sleep(time.Millisecond * 1)
+		} else {
+			wg.Add(1)
+			go zeigeMirDenGauß(int(anzahlKugeln), int(anzahlTöpfchen), &töpfchenAlle)
+		}
+	}
+	wg.Wait()
+	c <- true
+
+	wg2.Wait()
+
+	fmt.Println("\u2690", töpfchenAlle)
+	z.zeitmess()
+	fmt.Printf("\nProzess ist fertig und hat %v Sekunden gedauert!\n\n", (float64(z.zeitgeb(1)) * math.Pow(10, -9)))
+}
+
+func zeigeMirDenGauß(anzahlKugeln int, anzahlTöpfchen int, töpfchenAlle *[]int) {
+	defer wg.Done()
+	var töpfchenTmpZähler int
+
+	for i := 0; i < anzahlTöpfchen-1; i++ {
+		if yesnotrigger := func() bool {
+			if rand.New(rand.NewSource(time.Now().UnixNano())).Float64() < 0.5 {
+				return true
+			} else {
+				return false
+			}
+		}(); yesnotrigger == true {
+			töpfchenTmpZähler++
+		}
+	}
+	(*töpfchenAlle)[töpfchenTmpZähler]++
+}

go2lgl_l08/go2lgl_l08.go

@@ -0,0 +1,42 @@
+/*
+Landesamt für Geoinformation und Landentwicklung, Referat 35
+Einführung in die Sprache Go, 25.7.2017
+Lektion 8: Exkurs zur Objektorientierungl
+*/
+package main
+
+import "fmt"
+
+type floatdings struct {
+}
+
+type stringdings struct {
+}
+
+func (this stringdings) ichWandleUm(i string) (o []byte) {
+	return []byte(i)
+}
+
+func (this floatdings) ichRechne(ia float64, ib float64) (o float64) {
+	return ia / ib
+}
+
+type floatundstringdinger interface {
+	ichWandleUm(string) []byte
+	ichRechne(float64, float64) float64
+}
+
+func main() {
+	var a stringdings = stringdings{}
+	var b floatdings = floatdings{}
+
+	fmt.Println(a.ichmachewas("Hallo"))  //[72 97 108 108 111]
+	fmt.Println(b.ichmachewas(1.2, 3.4)) //0.35294117647058826
+
+	var c floatundstringdinger
+	c = stringdings{}
+	//d = stringdings{}
+	fmt.Println(c.ichmachewas("Hallo")) //[72 97 108 108 111]
+	//fmt.Println(d.ichmachewas(1.2, 3.4)) //[72 97 108 108 111]
+
+}

gui/gui.go

@@ -0,0 +1,47 @@
+package gui
+
+var A int = 123
+
+/*
+
+//1. Eröffne eine neue Applikation (als eine Sammlung von Widgets)
+	widgets.NewQApplication(len(os.Args), os.Args) // ... übergebe Kommandozeilenparameter (ansonsten "nil")
+
+	//2. Erzeuge das Haupt-Fenster
+	window := widgets.NewQMainWindow(nil, 0)
+	window.SetWindowTitle("Show my results")
+	window.SetMinimumSize2(400, 100)
+
+	//3. Erzeuge ein Layout ⇒ https://doc.qt.io/qt-5/qlayout.html
+	layout := widgets.NewQHBoxLayout()
+
+	//4. Erzeuge ein Widget und weise dem Widget ein Layout zu
+	widget := widgets.NewQWidget(nil, 0)
+	widget.SetLayout(layout)
+
+	//5-1. Erzeuge eine Eingabezeile
+	input := widgets.NewQLineEdit(nil)
+	input.SetPlaceholderText("Schreib mal wieder!")
+
+	//5-2. Erzeuge einen Knopf
+	button := widgets.NewQPushButton2("Hier klicken", nil)
+	button.ConnectClicked(func(checked bool) {
+		//6. Weise dem Knopf ein Signal zu, das beim Drücken des Knopfes eine
+		//   Funktion ausführen soll
+		widgets.QMessageBox_Information(nil, "Titel des Infofensters", input.Text(), widgets.QMessageBox__Ok, widgets.QMessageBox__Ok)
+	})
+
+	//7.  Weise die Input-Widges dem Layout zu
+	layout.AddWidget(input, 0, 0)  // ⇒ http://doc.qt.io/qt-5/qboxlayout.html#addWidget
+	layout.AddWidget(button, 0, 0) // ⇒ https://doc.qt.io/qt-5/qboxlayout.html#addWidget
+
+	//8. Dem Haupt-Fenster muß ein Haupt-Widget zugewiesen werden
+	window.SetCentralWidget(widget)
+
+	//9. Zeichne das Haupt-Fenster
+	window.Show()
+
+	//9. Damit die Applikation dynamisch auf Benutzereingaben/Events reagieren
+	//   kann, muß sie in einer Endlosschleife laufen
+	widgets.QApplication_Exec()
+*/

main.go

@@ -0,0 +1,38 @@
+// Präsentation3hGolang4LGLRef35 project main.go
+package main
+
+import (
+	"fmt"
+	"math"
+	"time"
+)
+
+var testzahl int = 8978793242417717171
+
+func main() {
+	defer func() {
+		if r := recover(); r != nil {
+			fmt.Printf("Es gab einen Fehler: \"%v\"\n", r)
+		}
+	}()
+
+	t0 := time.Now().UnixNano()
+	fmt.Println(isPrim(&testzahl))
+	t1 := time.Now().UnixNano()
+	fmt.Printf("Zeitbedarf: %.5f Sekunden\n\n", float64(t1-t0)*math.Pow(10, -9))
+}
+
+func isPrim(n *int) bool {
+	if *n <= 2 && *n > 0 {
+		return true
+	} else if *n%2 == 0 {
+		return false // Gerade Zahlen > 2 sind keine Primzahlen
+	} else {
+		for i := 3; i <= int(math.Sqrt(float64(*n))); i += 2 {
+			if *n%i == 0 {
+				return false
+			}
+		}
+		return true
+	}
+}

main.go.alt

@@ -0,0 +1,126 @@
+// Präsentation3hGolang4LGLRef35 project main.go
+package main
+
+import (
+	"bytes"
+	"crypto/md5"
+	"fmt"
+	"strconv"
+	"unicode/utf8"
+)
+
+const maximalePrüflänge int = 8
+const referenzZeichenkette string = "lglRocks"                                                                        // Darf nicht länger sein, als die maximale Prüflänge
+var valideZeichenString string = "1234567890aäöübcdefghijklmnopqrsßtuvwxyzAÄBCDEFGHIJKLMNOÖPQRSTUÜVWXYZ_-+*!§$%&/=?#" // var statt const, damit die Funktion einen Zeiger übernehmen kann
+
+func main() {
+	defer func() {
+		if r := recover(); r != nil {
+			fmt.Printf("Es gab einen Fehler: \"%v\"\n", r)
+		}
+	}()
+
+	valideZeichenStringArray := string2stringarray(&valideZeichenString)
+	fmt.Println(valideZeichenStringArray)
+
+	//fmt.Println(stringarray2string(&valideZeichenStringArray), len(valideZeichenStringArray), utf8.RuneCountInString(valideZeichenString))
+
+	if len(referenzZeichenkette) > maximalePrüflänge {
+		panic("Die Länge der Zeichenkette darf " + strconv.Itoa(maximalePrüflänge) + " nicht übersteigen")
+	}
+
+	/*primzahl := tcbb.FetchNextPrim()
+	for i := 1; i <= 10000000; i++ {
+		fmt.Println(primzahl())
+	}*/
+
+	generatedHashVorgabe := md5.Sum([]byte(referenzZeichenkette))
+	//fmt.Printf("%x\n", generatedHashVorgabe)
+
+	var zuPrüfendeZeichenketteIndexliste [maximalePrüflänge]int // = make([]int, 0, maximalePrüflänge) // Slice nicht notwendig, da maximalePrüflänge eine Konstante
+
+	// Damit jede mögliche Kombination einmal ausprobiert wird, baue ein Zählwerk eines Zahlensystems auf Basis der Anzahl valider Zeichen. Addiere hierzu auf den Index der niederwertigsten Ziffer 1 hinzu. Wenn diese Ziffer dann am Anschlag ist, erhöhe die nachfolgende Ziffer um 1 und stelle die aktuelle Ziffer wieder auf 0. Prüfe nun, ob dadurch die nachfolgende Ziffer auch auf 0 zurückfällt und die nächste Ziffer stattdessen erhöht werden soll.
+
+forLoop:
+	for {
+		//fmt.Println(zuPrüfendeZeichenketteIndexliste)
+
+		zuPrüfendeZeichenkette, generatedHashVergleichswert := prüfeZeichenkette(&zuPrüfendeZeichenketteIndexliste, &valideZeichenStringArray)
+
+		if generatedHashVergleichswert == generatedHashVorgabe {
+			fmt.Println(zuPrüfendeZeichenkette)
+			fmt.Printf("%x\n", generatedHashVergleichswert)
+		}
+
+		for digit := 0; digit <= maximalePrüflänge; digit++ {
+			if digit == maximalePrüflänge {
+				break forLoop // Wenn eine Ziffer zuviel ausgewählt wurde, ist der Zähler einmal durch alle Kombinationen durch. Breche dann ab.
+			} else if zuPrüfendeZeichenketteIndexliste[digit] >= len(valideZeichenStringArray)-1 {
+				zuPrüfendeZeichenketteIndexliste[digit] = 0
+			} else {
+				zuPrüfendeZeichenketteIndexliste[digit]++
+				break // Wenn die eine Ziffer nicht am Anschlag ist, müssen die nachfolgenden nicht verändert werden
+			}
+		}
+	}
+
+	/*
+		for digit := 0; digit < len(valideZeichenStringArray); digit++ {
+			if zuPrüfendeZeichenkette[digit] == valideZeichenStringArray[len(valideZeichenStringArray)-1]
+			  zuPrüfendeZeichenkette[digit] = valideZeichenStringArray[d]
+			  	fmt.Println(zuPrüfendeZeichenkette[0])
+		}
+
+	*/
+
+	/*
+		for k := maximalePrüflänge - 1; k >= 0; k-- {
+			for i := k - 1; i >= 0; i-- {
+				for j := 32; j <= 100; j = func(a int) int { // Sorge dafür, daß nur die validen Ascii-Character abgefragt werden.
+					switch {
+					case a >= 128 && a <= 159:
+						return 160
+					default:
+						return a + 1
+					}
+				}(j) {
+					zuPrüfendeZeichenkette[i] = byte(j)
+					fmt.Println(string(zuPrüfendeZeichenkette[:]))
+					//time.Sleep(10000000)
+					fmt.Println(string(j), j) //DEBUG
+				}
+
+			}
+		}
+	*/
+}
+
+// Wandele string in []string
+func string2stringarray(myStr *string) (myStrArr []string) {
+	myStrArr = make([]string, 0, utf8.RuneCountInString(*myStr)) // Fange mit einer Länge von 0 an und rechne mit einer Kapazität der bekannten Länge und verhindere auf diese Weise Kapazitäten oberhalb des tatsächlichen Bedarfs. Teste eventuelle Kapazitätsverdopplungen mit "fmt.Println(utf8.RuneCountInString(myStr), cap(valideZeichenStringArray), len(valideZeichenStringArray))"
+	for _, c := range *myStr {
+		myStrArr = append(myStrArr, string(c))
+		// fmt.Println(string(c), valideZeichenStringArray[i], string(rune(myStr[i]))) // Deshalb []string statt []rune oder []byte
+	}
+	return
+}
+
+// Wandele []string in string
+func stringarray2string(myStrArr *[]string) string {
+	var buffer bytes.Buffer
+	for i := 0; i < len(*myStrArr); i++ {
+		buffer.WriteString((*myStrArr)[i])
+	}
+	return buffer.String()
+}
+
+func prüfeZeichenkette(zuPrüfendeZeichenketteIndexliste *[maximalePrüflänge]int, valideZeichenStringArray *[]string) (string, [16]byte) {
+	var zuPrüfendeZeichenketteStringArray []string = make([]string, maximalePrüflänge, maximalePrüflänge) // Kapazität kann auf Länge begrenzt bleiben
+	for i := 0; i < maximalePrüflänge; i++ {
+		zuPrüfendeZeichenketteStringArray[i] = (*valideZeichenStringArray)[(*zuPrüfendeZeichenketteIndexliste)[i]]
+	}
+
+	zuPrüfendeZeichenketteString := stringarray2string(&zuPrüfendeZeichenketteStringArray)
+
+	return zuPrüfendeZeichenketteString, md5.Sum([]byte(zuPrüfendeZeichenketteString))
+}

tcbb/tcbb.go

@@ -0,0 +1,77 @@
+/*tcbb = time consuming black box;
+In dieser Blackbox werden Berechnungen durchgeführt, die irgendetwas machen und dafür einige Zeit in Anspruch nehmen sollen. Es werden drei Werte zurückgelifert: Status (True/False), Ausgabetext, Error.
+*/
+package tcbb
+
+import (
+	"errors"
+	"math"
+)
+
+func isPrim(n *int) bool {
+	if *n <= 2 && *n > 0 {
+		return true
+	} else if *n%2 == 0 {
+		return false // Gerade Zahlen > 2 sind keine Primzahlen
+	} else {
+		for i := 3; i <= int(math.Sqrt(float64(*n))); i += 2 {
+			if *n%i == 0 {
+				return false
+			}
+		}
+		return true
+	}
+}
+
+func FetchNextPrim() func() (int, error) {
+	primZahl := 1
+	var locked bool
+	return func() (int, error) {
+		if locked == false { // Simple Sicherheitsvorkehrung, die bei Nebenläufigkeit notwendig wird, damit nicht zwei Routinen gleichzeitig auf die Funktion zugreifen können.
+			locked = true
+			//fmt.Printf("Vorherige Primzahl: %v\n", primZahl)
+			for i := primZahl + 2; i < (1<<32 - 1); i += 2 { //1<<32-1 gleich int32 bzw. int auf meinem Rechner
+				if isPrim(&i) {
+					//fmt.Printf("Neue Primzahl: %v\n", i)
+					primZahl = i
+					break
+				}
+			}
+			locked = false
+			return primZahl, nil
+		} else {
+			return primZahl, errors.New("locked")
+		}
+	}
+}
+
+/*
+func KreiszahlPiFlächenformel(r float64) float64 {
+	var kreistreffer float64 = 0
+	quadrattreffer := math.Pow(r, 2)
+	for i := 0.; i <= r-1; i++ {
+		x := i + 0.5
+		for j := 0.; float64(j) <= float64(r)-1; j++ {
+			y := j + 0.5
+			if math.Pow(x, 2)+math.Pow(y, 2) <= math.Pow(r, 2) {
+				kreistreffer++
+				//fmt.Println(kreistreffer)
+			}
+		}
+
+	}
+
+	return 4 * kreistreffer / quadrattreffer
+}*/
+
+/*
+
+
+ for i = 0 to r - 1
+   x = i + 0.5
+   for j = 0 to r-1
+     y = j + 0.5
+     if x ^ 2 + y ^ 2 <= r ^ 2 then
+       kreistreffer = kreistreffer + 1
+ ausgabe 4 * kreistreffer / quadrattreffer { 3.14159388 }
+*/