Browse Source

Initial commit

master
Klaus Wendel 5 years ago
commit
292a34b621
  1. BIN
      Präsentation3hGolang4LGLRef35
  2. 6
      doc.go
  3. 9
      go2lgl_l01/doc.go
  4. BIN
      go2lgl_l01/go2lgl_l01
  5. 49
      go2lgl_l01/go2lgl_l01.go
  6. 31
      go2lgl_l02/derTöpfchenfüller/derTöpfchenfüller.go
  7. BIN
      go2lgl_l02/go2lgl_l02
  8. 28
      go2lgl_l02/go2lgl_l02.go
  9. BIN
      go2lgl_l03/go2lgl_l03
  10. 48
      go2lgl_l03/go2lgl_l03.go
  11. BIN
      go2lgl_l04/go2lgl_l04
  12. 56
      go2lgl_l04/go2lgl_l04.go
  13. BIN
      go2lgl_l05/go2lgl_l05
  14. 32
      go2lgl_l05/go2lgl_l05.go
  15. BIN
      go2lgl_l06/go2lgl_l06
  16. 90
      go2lgl_l06/go2lgl_l06.go
  17. BIN
      go2lgl_l07/go2lgl_l07
  18. 103
      go2lgl_l07/go2lgl_l07.go
  19. BIN
      go2lgl_l08/go2lgl_l08
  20. 42
      go2lgl_l08/go2lgl_l08.go
  21. 47
      gui/gui.go
  22. 38
      main.go
  23. 126
      main.go.alt
  24. 77
      tcbb/tcbb.go

BIN
Präsentation3hGolang4LGLRef35

Binary file not shown.

6
doc.go

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

9
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

BIN
go2lgl_l01/go2lgl_l01

Binary file not shown.

49
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]))
}

31
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)
}

BIN
go2lgl_l02/go2lgl_l02

Binary file not shown.

28
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))
}

BIN
go2lgl_l03/go2lgl_l03

Binary file not shown.

48
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]++
}

BIN
go2lgl_l04/go2lgl_l04

Binary file not shown.

56
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]++
}

BIN
go2lgl_l05/go2lgl_l05

Binary file not shown.

32
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!")
}
}

BIN
go2lgl_l06/go2lgl_l06

Binary file not shown.

90
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]++
}

BIN
go2lgl_l07/go2lgl_l07

Binary file not shown.

103
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]++
}

BIN
go2lgl_l08/go2lgl_l08

Binary file not shown.

42
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]
}

47
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()
*/

38
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
}
}

126
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))
}

77
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 }
*/
Loading…
Cancel
Save