Go pi monte carlo

README.md

@@ -24,6 +24,7 @@ We're using four implementations of the algorithm:
 - [x] [Rust](https://www.rust-lang.org/) version in [/rust](/rust).
 - [x] [Python calling Rust with cffi](https://bheisler.github.io/post/calling-rust-in-python/) version in [/hybrid](/hybrid).
 - [x] Python calling Rust with [WASM/WASI](https://wasi.dev/) version in [/wasm](/wasm).
+- [x] [Go](https://golang.org) version in [/go](/go).
 
 We're using the [hyperfine](https://github.com/sharkdp/hyperfine) benchmark tool.
 
@@ -168,5 +169,46 @@ Using WASM/WASI to call the Rust monte-carlo-pi loop from Python.
 
 </details>
 
+## Go
 
+Run pi-monte-carlo algorithm in pure Go!
 
+<details>
+  <summary>Click to expand!</summary>
+
+### Build
+
+```bash
+go build .
+```
+
+### Execute
+
+```shell
+./pi-monte-carlo
+```
+
+### Benchmark
+
+```shell
+hyperfine -w 2 -m 10 ./pi-monte-carlo
+```
+
+Result (Ran on my macbook pro):
+
+```shell
+Benchmark #1: ./pi-monte-carlo
+  Time (mean ± σ):      51.8 ms ±   0.9 ms    [User: 47.9 ms, System: 2.8 ms]
+  Range (min … max):    50.7 ms …  55.1 ms    50 runs
+```
+
+### Advantage
+
+- Super fast (fastest benchmark from all experiments)
+- Imperitive easy to understand code
+
+### Disavantage
+
+- Has to be compiled for specific OS and target platform
+
+</details>

go/go-implementation/.gitignore

@@ -0,0 +1 @@
+pi-monte-carlo

go/go-implementation/go.mod

@@ -0,0 +1,3 @@
+module github.com/philips-labs/pi-python-rust/go/pi-monte-carlo
+
+go 1.16

go/go-implementation/main.go

@@ -0,0 +1,31 @@
+package main
+
+import (
+	"fmt"
+	"math/rand"
+	"time"
+)
+
+func main() {
+	pi_est := montecarlo_pi(5000000)
+	fmt.Println(pi_est)
+}
+
+func montecarlo_pi(trials int) float64 {
+	hit := 0
+	s := rand.NewSource(time.Now().UnixNano())
+	r := rand.New(s)
+
+	for i := 0; i <= trials; i++ {
+		x := r.Float64()
+		y := r.Float64()
+
+		pos_on_board := x*x + y*y
+
+		if pos_on_board < 1.0 {
+			hit = hit + 1
+		}
+	}
+
+	return float64(hit) * 4.0 / float64(trials)
+}

go/wasm/.gitignore

@@ -0,0 +1 @@
+pi-monte-carlo

go/wasm/go.mod

@@ -0,0 +1,3 @@
+module github.com/philips-labs/pi-python-rust/go/pi-monte-carlo
+
+go 1.16

go/wasm/main.go

@@ -0,0 +1,36 @@
+package main
+
+import (
+	"math/rand"
+	"time"
+	"syscall/js"
+)
+
+func main() {
+  c := make(chan struct{}, 0)
+  println("Go WebAssembly Initialized")
+
+  js.Global().Set("monteCarloPi", js.FuncOf(monteCarloPi))
+
+  <-c
+}
+
+func monteCarloPi(this js.Value, args []js.Value) interface{} {
+  trials := args[0].Int()
+	hit := 0
+	s := rand.NewSource(time.Now().UnixNano())
+	r := rand.New(s)
+
+	for i := 0; i <= trials; i++ {
+		x := r.Float64()
+		y := r.Float64()
+
+		pos_on_board := x*x + y*y
+
+		if pos_on_board < 1.0 {
+			hit = hit + 1
+		}
+	}
+
+	return float64(hit) * 4.0 / float64(trials)
+}

go/wasm/pi-monte-carlo.py

@@ -0,0 +1,6 @@
+import wasmtime.loader
+
+import main
+
+pi_est = instance.exports.monteCarloPi(5_000_000)
+print(pi_est)

hybrid/pi-monte-carlo/src/lib.rs

@@ -10,7 +10,7 @@ pub fn montecarlo_pi(trials: u32) -> f64 {
     for _i in 1..trials {
         let x: f64 = rng.gen::<f64>();
         let y: f64 = rng.gen::<f64>();
-        
+
         // Shouldn't we do a sqrt over this?
         let position_on_board: f64 = x * x + y * y;
 

rust/pi-monte-carlo/src/main.rs

@@ -5,7 +5,7 @@ fn montecarlo_pi(trials: u32) -> f64 {
     let mut hit: u32 = 0;
     let mut rng = rand::thread_rng();
 
-    for _i in 1..trials {
+    for _i in 0..trials {
         let x: f64 = rng.gen::<f64>();
         let y: f64 = rng.gen::<f64>();
 

wasm/pi_monte_carlo.wasm

@@ -1 +1 @@
-wasm/pi-monte-carlo/target/wasm32-wasi/release/pi_monte_carlo.wasm
+pi-monte-carlo/target/wasm32-wasi/release/pi_monte_carlo.wasm