Zwischenspeicherung 20170526

doc.go

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

go2lgl_l06/go2lgl_l06.go

@@ -65,6 +65,7 @@ func main() {
 	c <- true
 
 	wg2.Wait()
+	close(c)
 
 	fmt.Println("\u2690", töpfchenAlle)
 	timestamp[1] = time.Now().UnixNano()

go2lgl_l07/go2lgl_l07.go

@@ -18,6 +18,11 @@ type zeiten struct {
 	tt []int64
 }
 
+type zeitenMitEinheit struct {
+	unit   string
+	zeiten //  Vererbung
+}
+
 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())
 }
@@ -38,7 +43,8 @@ var wg, wg2 sync.WaitGroup // !
 func main() {
 	runtime.GOMAXPROCS(runtime.NumCPU())
 
-	var z zeiten = zeiten{}
+	//var z zeiten = zeiten{}
+	var z zeitenMitEinheit = zeitenMitEinheit{unit: "Momentchen"}
 	var töpfchenAlle []int = make([]int, anzahlTöpfchen, anzahlTöpfchen)
 	var c chan bool = make(chan bool, 1) // !
 
@@ -78,10 +84,12 @@ func main() {
 	c <- true
 
 	wg2.Wait()
+	close(c)
 
 	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)))
+	//fmt.Printf("\nProzess ist fertig und hat %v Sekunden gedauert!\n\n", (float64(z.zeitgeb(1)) * math.Pow(10, -9)))
+	fmt.Printf("\nProzess ist fertig und hat %v %s gedauert!\n\n", (float64(z.zeitgeb(1)) * math.Pow(10, -9)), z.unit)
 }
 
 func zeigeMirDenGauß(anzahlKugeln int, anzahlTöpfchen int, töpfchenAlle *[]int) {

go2lgl_l08/go2lgl_l08.go

@@ -1,42 +1,71 @@
 /*
 Landesamt für Geoinformation und Landentwicklung, Referat 35
 Einführung in die Sprache Go, 25.7.2017
-Lektion 8: Exkurs zur Objektorientierungl
+Lektion 8: Exkurs zur Objektorientierung
 */
 package main
 
 import "fmt"
+import "math"
 
-type floatdings struct {
+//Schlechter Stil bei der Reihenfolge, dient hier der Anschaulichkeit (Besser: type interface - type struct - func)
+type StructA struct {
+	FieldA1, FieldA2 float64
 }
 
-type stringdings struct {
+func (thisA StructA) FMethod1() float64 {
+	return thisA.FieldA1 * thisA.FieldA2
+}
+func (thisA StructA) FMethod2() float64 {
+	return thisA.FieldA1 + thisA.FieldA2
 }
 
-func (this stringdings) ichWandleUm(i string) (o []byte) {
-	return []byte(i)
+type StructB struct {
+	FieldB1 float64
 }
 
-func (this floatdings) ichRechne(ia float64, ib float64) (o float64) {
-	return ia / ib
+func (thisB StructB) FMethod1() float64 {
+	return math.Pow(thisB.FieldB1, 2)
+}
+func (thisB StructB) FMethod2() float64 {
+	return math.Sqrt(thisB.FieldB1)
 }
 
-type floatundstringdinger interface {
-	ichWandleUm(string) []byte
-	ichRechne(float64, float64) float64
+type IFace interface {
+	FMethod1() float64
+	FMethod2() float64
+}
+
+func FPolyfunc(i IFace) {
+	fmt.Println(i, i.FMethod1(), i.FMethod2())
 }
 
 func main() {
-	var a stringdings = stringdings{}
-	var b floatdings = floatdings{}
+	//1. Implementierung der Methoden über die Struktur, Implementierung des Interfaces im Funktionskopf
+	var a StructA
+	var b StructB
+	a = StructA{FieldA1: 10, FieldA2: 11} // a: = StructA{FieldA1: 10, FieldA2: 11}
+	b = StructB{FieldB1: 16}              // b: = StructB{FieldB1: 16}
+
+	//fmt.Println(a) //{10 11}
+	//fmt.Println(b) //{12}
+
+	FPolyfunc(a) //{10 11} 110 21
+	FPolyfunc(b) //{16} 256 4
+
+	//2. Implementierung der Methoden über das Interface (= identisches Resultat!)
+	var c, d IFace = StructA{FieldA1: 10, FieldA2: 11}, StructB{FieldB1: 16}
+
+	FPolyfunc(c) //{10 11} 110 21
+	FPolyfunc(d) //{16} 256 4
+
+	//3. Neuere Implementierungen überschreiben vorherige
+	var e IFace
 
-	fmt.Println(a.ichmachewas("Hallo"))  //[72 97 108 108 111]
-	fmt.Println(b.ichmachewas(1.2, 3.4)) //0.35294117647058826
+	e = StructA{FieldA1: 10, FieldA2: 11}
+	fmt.Println(e, e.FMethod1(), e.FMethod2()) //{10 11} 110 21
 
-	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]
+	e = StructB{FieldB1: 16}
+	fmt.Println(e, e.FMethod1(), e.FMethod2()) //{16} 256 4
 
 }

go2lgl_l09/go2lgl_l09.go

@@ -0,0 +1,97 @@
+/*
+Landesamt für Geoinformation und Landentwicklung, Referat 35
+Einführung in die Sprache Go, 25.7.2017
+Lektion 9: Ansprechendere Visualisierung zum Abschluß
+*/
+package main
+
+import (
+	"fmt"
+	"math"
+	"math/rand"
+	"runtime"
+	"sync"
+	"time"
+
+	"Präsentation3hGolang4LGLRef35/go2lgl_l09/gui"
+)
+
+const (
+	anzahlTöpfchen int8  = 35
+	anzahlKugeln   int32 = 1000000
+)
+
+var timestamp [2]int64
+
+var wg, wg2 sync.WaitGroup // !
+
+func main() {
+	gui.SesamÖffneDich()
+
+	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:
+				//guichannel <- *t
+				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()
+	close(c)
+
+	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_l09/gui/gui.go

@@ -0,0 +1,53 @@
+package gui
+
+import (
+	"os"
+
+	"github.com/therecipe/qt/core"
+	"github.com/therecipe/qt/uitools"
+	"github.com/therecipe/qt/widgets"
+)
+
+func SesamÖffneDich() {
+	//1. Eröffne eine neue Applikation (als eine Sammlung von Widgets)
+	widgets.NewQApplication(len(os.Args), os.Args) // ... übergebe Kommandozeilenparameter (ansonsten "nil")
+
+	//2. Erzeuge ein Widget
+	var widget = widgets.NewQWidget(nil, 0)
+
+	//3. Lade UI/QML (Qt Meta-object Language)-Datei und erzeuge damit indirekt
+	//   auch das Haupt-Fenster.
+	var loader = uitools.NewQUiLoader(nil)
+	var file = core.NewQFile2("./gui/qml/formular.ui")
+	file.Open(core.QIODevice__ReadOnly)
+	var formWidget *widgets.QWidget = loader.Load(file, widget)
+	file.Close()
+
+	//4. Erzeuge Input-Widgets aus QML-Datei
+	var (
+		ui_textinputEingabefeld = widgets.NewQTextEditFromPointer(widget.FindChild("textinputEingabefeld", core.Qt__FindChildrenRecursively).Pointer())
+		ui_buttonAusloeser      = widgets.NewQPushButtonFromPointer(widget.FindChild("buttonAusloeser", core.Qt__FindChildrenRecursively).Pointer())
+	)
+
+	//5. Weise dem Knopf ein Signal zu, das beim Drücken eine Funktion ausführen soll
+	ui_buttonAusloeser.ConnectClicked(func(checked bool) {
+		widgets.QMessageBox_Information(nil, "Titel des Infofensters", ui_textinputEingabefeld.ToPlainText(), widgets.QMessageBox__Ok, widgets.QMessageBox__Ok)
+	})
+
+	//6. Erzeuge ein Layout und weise es dem Widget zu
+	var layout = widgets.NewQVBoxLayout()
+
+	//8. Weise dem Widget ein Layout zu und weise dem Layout die Input-Widges zu
+	widget.SetLayout(layout)
+	layout.AddWidget(formWidget, 0, 0)
+
+	//9. Ändere Attribute, falls nötig
+	widget.SetWindowTitle("Titel des Hauptfensters Nr. 2")
+
+	//10. Zeichne das Haupt-Fenster
+	widget.Show()
+
+	//11. Damit die Applikation dynamisch auf Benutzereingaben/Events reagieren
+	//   kann, muß sie in einer Endlosschleife laufen
+	widgets.QApplication_Exec()
+}

go2lgl_l09/gui/qml/formular.ui

@@ -0,0 +1,61 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>meinFormular</class>
+ <widget class="QWidget" name="meinFormular">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>394</width>
+    <height>620</height>
+   </rect>
+  </property>
+  <property name="sizePolicy">
+   <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
+    <horstretch>0</horstretch>
+    <verstretch>0</verstretch>
+   </sizepolicy>
+  </property>
+  <property name="windowTitle">
+   <string notr="true">Titel des Hauptfensters</string>
+  </property>
+  <layout class="QGridLayout">
+   <property name="leftMargin">
+    <number>9</number>
+   </property>
+   <property name="topMargin">
+    <number>9</number>
+   </property>
+   <property name="rightMargin">
+    <number>9</number>
+   </property>
+   <property name="bottomMargin">
+    <number>9</number>
+   </property>
+   <property name="spacing">
+    <number>6</number>
+   </property>
+   <item row="0" column="0" colspan="4">
+    <widget class="QGraphicsView" name="graphicsView"/>
+   </item>
+   <item row="1" column="0" colspan="2">
+    <widget class="QProgressBar" name="progressBar">
+     <property name="maximumSize">
+      <size>
+       <width>182</width>
+       <height>16777215</height>
+      </size>
+     </property>
+     <property name="value">
+      <number>24</number>
+     </property>
+    </widget>
+   </item>
+   <item row="1" column="3">
+    <widget class="QLCDNumber" name="lcdNumber"/>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>

gui/gui.go

@@ -1,47 +0,0 @@
-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

@@ -1,38 +0,0 @@
-// 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

@@ -1,126 +0,0 @@
-// 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

@@ -1,77 +0,0 @@
-/*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 }
-*/