/* Parallel computation of Pi with Monte Carlo method */

package main

import (
   "fmt"
   "os"
   "flag"
   "math/rand"
   "time"
   "runtime"
   "strconv"
)

func main() {

   // Check number of arguments
   flag.Parse()
   if flag.NArg() != 2 {
     fmt.Println("Error: specify arguments as number of threads and iterations")
     os.Exit(0)
   }
   // Number of threads
   nb_process, err := strconv.Atoi(flag.Arg(0))
   if err != nil {
     // Error
     fmt.Println("Error with Argument 1")
     os.Exit(0)
   }
   // Number of iterations
   niter, err := strconv.Atoi(flag.Arg(1))
   if err != nil {
    // Error
    fmt.Println("Error with Argument 2")
    os.Exit(0)
   }
   // Check divisibility
   if (niter % nb_process != 0) {
     fmt.Println("Error: number of iterations not divisible by number of threads");
     os.Exit(0)
   }
   // Max number of threads
   runtime.GOMAXPROCS(nb_process)
   // Time elapsed 
   t0 := time.Now();
   pi_eval := random_thread(nb_process, niter)
   elapsed := time.Since(t0)
   // Printf Output
   fmt.Printf("# Estimation of Pi = %1.8f\n",pi_eval)
   fmt.Printf("# Number of tries = %d\n",niter)
   fmt.Printf("# Elapsed Time = %d seconds %d micro\n", (int64)(elapsed.Seconds()),
             (int64)(elapsed.Nanoseconds()/1e3))
}

// Generate random values
func random_thread(nb_process int, nb_iter int) float64 {
   // Size of sub-loops
   nb_eff := nb_iter/nb_process
   ch := make(chan float64, nb_process)
   for k:=0;k<nb_process;k++ {
      go pi_process(ch,nb_eff)
   }
   pi := float64(0)
   for l := 0;l<nb_process;l++ {
      pi += <-ch
   }
   return 4*(pi/(float64)(nb_iter))
}

// Compute PI with Monte-Carlo
func pi_process(ch chan float64, nb_eff int) {
   // Change seed for random
   rand.Seed(time.Now().UnixNano())
   // Generate random values
   src := rand.NewSource(time.Now().UnixNano())
   r := rand.New(src)
   nb_in := 0
   for i:=0;i<nb_eff;i++ {
      x, y := r.Float64(), r.Float64()
      if x*x+y*y <= 1.0 {
        nb_in++
      }
   }
   ch <- float64(nb_in)
}