Data commit

Task/Monte-Carlo-methods/00-META.yaml

@@ -0,0 +1,3 @@
+---
+from: http://rosettacode.org/wiki/Monte_Carlo_methods
+note: Probability and statistics

Task/Monte-Carlo-methods/00-TASK.txt

@@ -0,0 +1,27 @@
+A '''Monte Carlo Simulation''' is a way of approximating the value of a function 
+where calculating the actual value is difficult or impossible. <br>
+It uses random sampling to define constraints on the value 
+and then makes a sort of "best guess."
+
+A simple Monte Carlo Simulation can be used to calculate the value for <big><math>\pi</math></big>. 
+
+If you had a circle and a square where the length of a side of the square 
+was the same as the diameter of the circle, the ratio of the area of the circle 
+to the area of the square would be <big><math>\pi/4</math></big>.
+ 
+So, if you put this circle inside the square and select many random points 
+inside the square, the number of points inside the circle 
+divided by the number of points inside the square and the circle 
+would be approximately <big><math>\pi/4</math></big>.
+
+
+;Task:
+Write a function to run a simulation like this, with a variable number of random points to select.
+
+Also, show the results of a few different sample sizes.
+
+For software where the number <big><math>\pi</math></big> is not built-in, 
+we give <big><math>\pi</math></big> as a number of digits: 
+             3.141592653589793238462643383280
+<br><br>
+

Task/Monte-Carlo-methods/11l/monte-carlo-methods.11l

@@ -0,0 +1,10 @@
+F monte_carlo_pi(n)
+   V inside = 0
+   L 1..n
+      V x = random:()
+      V y = random:()
+      I x * x + y * y <= 1
+         inside++
+   R 4.0 * inside / n
+
+print(monte_carlo_pi(1000000))

Task/Monte-Carlo-methods/360-Assembly/monte-carlo-methods.360

@@ -0,0 +1,82 @@
+*        Monte Carlo methods       08/03/2017
+MONTECAR CSECT
+         USING  MONTECAR,R13       base register
+         B      72(R15)            skip savearea
+         DC     17F'0'             savearea
+         STM    R14,R12,12(R13)    save previous context
+         ST     R13,4(R15)         link backward
+         ST     R15,8(R13)         link forward
+         LR     R13,R15            set addressability
+         LA     R8,1000            isamples=1000
+         LA     R6,4               i=4
+       DO WHILE=(C,R6,LE,=F'7')    do i=4 to 7
+         MH     R8,=H'10'            isamples=isamples*10
+         ZAP    HITS,=P'0'           hits=0
+         LA     R7,1                 j=1
+       DO WHILE=(CR,R7,LE,R8)        do j=1 to isamples
+         BAL    R14,RNDPK              call random
+         ZAP    X,RND                  x=rnd
+         BAL    R14,RNDPK              call random
+         ZAP    Y,RND                  y=rnd
+         ZAP    WP,X                   x
+         MP     WP,X                   x**2
+         DP     WP,ONE                 ~
+         ZAP    XX,WP(8)               x**2   normalized
+         ZAP    WP,Y                   y
+         MP     WP,Y                   y**2
+         DP     WP,ONE                 ~
+         ZAP    YY,WP(8)               y**2   normalized
+         AP     XX,YY                  xx=x**2+y**2
+       IF CP,XX,LT,ONE THEN            if x**2+y**2<1 then
+         AP     HITS,=P'1'               hits=hits+1
+       ENDIF    ,                      endif
+         LA     R7,1(R7)               j++
+       ENDDO    ,                    enddo j
+         CVD    R8,PSAMPLES          psamples=isamples
+         ZAP    WP,=P'4'             4
+         MP     WP,ONE               ~
+         MP     WP,HITS              *hits
+         DP     WP,PSAMPLES          /psamples
+         ZAP    MCPI,WP(8)           mcpi=4*hits/psamples
+         XDECO  R6,WC                edit i
+         MVC    PG+4(1),WC+11        output i
+         MVC    WC,MASK              load mask
+         ED     WC,PSAMPLES          edit psamples
+         MVC    PG+6(8),WC+8         output psamples
+         UNPK   WC,MCPI              unpack mcpi
+         OI     WC+15,X'F0'          zap sign
+         MVC    PG+31(1),WC+6        output mcpi
+         MVC    PG+33(6),WC+7        output mcpi decimals
+         XPRNT  PG,L'PG              print buffer
+         LA     R6,1(R6)             i++
+       ENDDO    ,                  enddo i
+         L      R13,4(0,R13)       restore previous savearea pointer
+         LM     R14,R12,12(R13)    restore previous context
+         XR     R15,R15            rc=0
+         BR     R14                exit
+RNDPK    EQU    *             ---- random number generator
+         ZAP    WP,RNDSEED         w=seed
+         MP     WP,RNDCNSTA        w*=cnsta
+         AP     WP,RNDCNSTB        w+=cnstb
+         MVC    RNDSEED,WP+8       seed=w mod 10**15
+         MVC    RND,=PL8'0'        0<=rnd<1
+         MVC    RND+3(5),RNDSEED+3 return rnd
+         BR     R14           ---- return
+PSAMPLES DS     0D,PL8             F(15,0)
+RNDSEED  DC     PL8'613058151221121'  linear congruential constant
+RNDCNSTA DC     PL8'944021285986747'  "
+RNDCNSTB DC     PL8'852529586767995'  "
+RND      DS     PL8                fixed(15,9)
+ONE      DC     PL8'1.000000000'   1 fixed(15,9)
+HITS     DS     PL8                fixed(15,0)
+X        DS     PL8                fixed(15,9)
+Y        DS     PL8                fixed(15,9)
+MCPI     DS     PL8                fixed(15,9)
+XX       DS     PL8                fixed(15,9)
+YY       DS     PL8                fixed(15,9)
+PG       DC     CL80'10**x xxxxxxxx samples give Pi=x.xxxxxx'  buffer
+MASK     DC     X'40202020202020202020202020202120'  mask CL16 15num
+WC       DS     PL16               character 16
+WP       DS     PL16               packed decimal 16
+         YREGS
+         END    MONTECAR

Task/Monte-Carlo-methods/ALGOL-68/monte-carlo-methods.alg

@@ -0,0 +1,16 @@
+PROC pi = (INT throws)REAL:
+BEGIN
+   INT inside := 0;
+   TO throws DO
+      IF random ** 2 + random ** 2 <= 1 THEN
+         inside +:= 1
+      FI
+   OD;
+   4 * inside / throws
+END # pi #;
+
+print (("     10 000:",pi (     10 000),new line));
+print (("    100 000:",pi (    100 000),new line));
+print (("  1 000 000:",pi (  1 000 000),new line));
+print ((" 10 000 000:",pi ( 10 000 000),new line));
+print (("100 000 000:",pi (100 000 000),new line))

Task/Monte-Carlo-methods/AWK/monte-carlo-methods.awk

@@ -0,0 +1,10 @@
+# --- with command line argument "throws" ---
+
+BEGIN{ th=ARGV[1];
+ for(i=0; i<th; i++) cin += (rand()^2 + rand()^2) < 1
+ printf("Pi = %8.5f\n",4*cin/th)
+}
+
+usage: awk -f pi 2300
+
+Pi =  3.14333

Task/Monte-Carlo-methods/Action-/monte-carlo-methods.action

@@ -0,0 +1,81 @@
+INCLUDE "H6:REALMATH.ACT"
+
+DEFINE PTR="CARD"
+DEFINE REAL_SIZE="6"
+BYTE ARRAY realArray(1536)
+
+PTR FUNC RealArrayPointer(BYTE i)
+  PTR p
+
+  p=realArray+i*REAL_SIZE
+RETURN (p)
+
+PROC InitRealArray()
+  REAL r2,r255,ri,div
+  REAL POINTER pow
+  INT i
+
+  IntToReal(2,r2)
+  IntToReal(255,r255)
+
+  FOR i=0 TO 255
+  DO
+    IntToReal(i,ri)
+    RealDiv(ri,r255,div)
+    pow=RealArrayPointer(i)
+    Power(div,r2,pow)
+  OD
+RETURN
+
+PROC CalcPi(INT n REAL POINTER pi)
+  BYTE x,y
+  INT i,counter
+  REAL tmp1,tmp2,tmp3,r1,r4
+  REAL POINTER pow
+
+  counter=0
+  IntToReal(1,r1)
+  IntToReal(4,r4)
+
+  FOR i=1 TO n
+  DO
+    x=Rand(0)
+    pow=RealArrayPointer(x)
+    RealAssign(pow,tmp1)
+
+    y=Rand(0)
+    pow=RealArrayPointer(y)
+    RealAssign(pow,tmp2)
+
+    RealAdd(tmp1,tmp2,tmp3)
+
+    IF RealGreaterOrEqual(tmp3,r1)=0 THEN
+      counter==+1
+    FI
+  OD
+
+  IntToReal(counter,tmp1)
+  RealMult(r4,tmp1,tmp2)
+  IntToReal(n,tmp3)
+  RealDiv(tmp2,tmp3,pi)
+RETURN
+
+PROC Test(INT n)
+  REAL pi
+
+  PrintF("%I samples -> ",n)
+  CalcPi(n,pi)
+  PrintRE(pi)
+RETURN
+
+PROC Main()
+  Put(125) PutE() ;clear the screen
+
+  PrintE("Initialization of data...")
+  InitRealArray()
+
+  Test(10)
+  Test(100)
+  Test(1000)
+  Test(10000)
+RETURN

Task/Monte-Carlo-methods/Ada/monte-carlo-methods.ada

@@ -0,0 +1,23 @@
+with Ada.Text_IO;                use Ada.Text_IO;
+with Ada.Numerics.Float_Random;  use Ada.Numerics.Float_Random;
+
+procedure Test_Monte_Carlo is
+   Dice : Generator;
+
+   function Pi (Throws : Positive) return Float is
+      Inside : Natural := 0;
+   begin
+      for Throw in 1..Throws loop
+         if Random (Dice) ** 2 + Random (Dice) ** 2 <= 1.0 then
+            Inside := Inside + 1;
+         end if;
+      end loop;
+      return 4.0 * Float (Inside) / Float (Throws);
+   end Pi;
+begin
+   Put_Line ("     10_000:" & Float'Image (Pi (     10_000)));
+   Put_Line ("    100_000:" & Float'Image (Pi (    100_000)));
+   Put_Line ("  1_000_000:" & Float'Image (Pi (  1_000_000)));
+   Put_Line (" 10_000_000:" & Float'Image (Pi ( 10_000_000)));
+   Put_Line ("100_000_000:" & Float'Image (Pi (100_000_000)));
+end Test_Monte_Carlo;

Task/Monte-Carlo-methods/Arturo/monte-carlo-methods.arturo

@@ -0,0 +1,10 @@
+Pi: function [throws][
+    inside: new 0.0
+    do.times: throws [
+        if 1 > hypot random 0 1.0 random 0 1.0 -> inc 'inside
+    ]
+    return 4 * inside / throws
+]
+
+loop [100 1000 10000 100000 1000000] 'n ->
+    print [pad to :string n 8 "=>" Pi n]

Task/Monte-Carlo-methods/AutoHotkey/monte-carlo-methods.ahk

@@ -0,0 +1,12 @@
+MsgBox % MontePi(10000)   ; 3.154400
+MsgBox % MontePi(100000)  ; 3.142040
+MsgBox % MontePi(1000000) ; 3.142096
+
+MontePi(n) {
+   Loop %n% {
+      Random x, -1, 1.0
+      Random y, -1, 1.0
+      p += x*x+y*y < 1
+   }
+   Return 4*p/n
+}

Task/Monte-Carlo-methods/BASIC/monte-carlo-methods.basic

@@ -0,0 +1,22 @@
+DECLARE FUNCTION getPi! (throws!)
+CLS
+PRINT getPi(10000)
+PRINT getPi(100000)
+PRINT getPi(1000000)
+PRINT getPi(10000000)
+
+FUNCTION getPi (throws)
+	inCircle = 0
+		FOR i = 1 TO throws
+			'a square with a side of length 2 centered at 0 has
+			'x and y range of -1 to 1
+			randX = (RND * 2) - 1'range -1 to 1
+			randY = (RND * 2) - 1'range -1 to 1
+			'distance from (0,0) = sqrt((x-0)^2+(y-0)^2)
+			dist = SQR(randX ^ 2 + randY ^ 2)
+			IF dist < 1 THEN 'circle with diameter of 2 has radius of 1
+				inCircle = inCircle + 1
+			END IF
+		NEXT i
+	getPi = 4! * inCircle / throws
+END FUNCTION

Task/Monte-Carlo-methods/BASIC256/monte-carlo-methods-1.basic

@@ -0,0 +1,22 @@
+# Monte Carlo Simulator
+# Determine value of pi
+# 21010513
+
+
+tosses = 1000
+in_c = 0
+i = 0
+
+for i = 1 to tosses
+     x = rand
+     y = rand
+     x2 = x * x
+     y2 = y * y
+     xy = x2 + y2
+     d_xy = sqr(xy)
+     if d_xy <= 1 then
+         in_c += 1
+     endif
+next i
+
+print float(4*in_c/tosses)

Task/Monte-Carlo-methods/BASIC256/monte-carlo-methods-2.basic

@@ -0,0 +1,17 @@
+print " Number of throws   Ratio (Pi)      Error"
+
+for pow = 2 to 8
+	n = 10 ^ pow
+	pi_ = getPi(n)
+	error_ = 3.141592653589793238462643383280 - pi_
+	print rjust(string(int(n)), 17); "   "; ljust(string(pi_), 13); "   "; ljust(string(error_), 13)
+next
+end
+
+function getPi(n)
+	incircle = 0.0
+	for throws = 0 to n
+		incircle = incircle + (rand()^2 + rand()^2 < 1)
+	next
+	return 4.0 * incircle / throws
+end function

Task/Monte-Carlo-methods/BBC-BASIC/monte-carlo-methods.basic

@@ -0,0 +1,13 @@
+      PRINT FNmontecarlo(1000)
+      PRINT FNmontecarlo(10000)
+      PRINT FNmontecarlo(100000)
+      PRINT FNmontecarlo(1000000)
+      PRINT FNmontecarlo(10000000)
+      END
+
+      DEF FNmontecarlo(t%)
+      LOCAL i%, n%
+      FOR i% = 1 TO t%
+        IF RND(1)^2 + RND(1)^2 < 1 n% += 1
+      NEXT
+      = 4 * n% / t%

Task/Monte-Carlo-methods/C++/monte-carlo-methods.cpp

@@ -0,0 +1,21 @@
+#include<iostream>
+#include<math.h>
+#include<stdlib.h>
+#include<time.h>
+
+using namespace std;
+int main(){
+    int jmax=1000; // maximum value of HIT number. (Length of output file)
+    int imax=1000; // maximum value of random numbers for producing HITs.
+    double x,y;    // Coordinates
+    int hit;       // storage variable of number of HITs
+    srand(time(0));
+    for (int j=0;j<jmax;j++){
+        hit=0;
+        x=0; y=0;
+        for(int i=0;i<imax;i++){
+            x=double(rand())/double(RAND_MAX);
+            y=double(rand())/double(RAND_MAX);
+        if(y<=sqrt(1-pow(x,2))) hit+=1; }          //Choosing HITs according to analytic formula of circle
+    cout<<""<<4*double(hit)/double(imax)<<endl; }  // Print out Pi number
+}

Task/Monte-Carlo-methods/C-sharp/monte-carlo-methods.cs

@@ -0,0 +1,24 @@
+using System;
+
+class Program {
+    static double MonteCarloPi(int n) {
+        int inside = 0;
+        Random r = new Random();
+
+        for (int i = 0; i < n; i++) {
+            if (Math.Pow(r.NextDouble(), 2)+ Math.Pow(r.NextDouble(), 2) <= 1) {
+                inside++;
+            }
+        }
+
+        return 4.0 * inside / n;
+    }
+
+    static void Main(string[] args) {
+        int value = 1000;
+        for (int n = 0; n < 5; n++) {
+            value *= 10;
+            Console.WriteLine("{0}:{1}", value.ToString("#,###").PadLeft(11, ' '), MonteCarloPi(value));
+        }
+    }
+}

Task/Monte-Carlo-methods/C/monte-carlo-methods.c

@@ -0,0 +1,36 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+double pi(double tolerance)
+{
+	double x, y, val, error;
+	unsigned long sampled = 0, hit = 0, i;
+
+	do {
+		/* don't check error every turn, make loop tight */
+		for (i = 1000000; i; i--, sampled++) {
+			x = rand() / (RAND_MAX + 1.0);
+			y = rand() / (RAND_MAX + 1.0);
+			if (x * x + y * y < 1) hit ++;
+		}
+
+		val = (double) hit / sampled;
+		error = sqrt(val * (1 - val) / sampled) * 4;
+		val *= 4;
+
+		/* some feedback, or user gets bored */
+		fprintf(stderr, "Pi = %f +/- %5.3e at %ldM samples.\r",
+			val, error, sampled/1000000);
+	} while (!hit || error > tolerance);
+              /* !hit is for completeness's sake; if no hit after 1M samples,
+                 your rand() is BROKEN */
+
+	return val;
+}
+
+int main()
+{
+	printf("Pi is %f\n", pi(3e-4)); /* set to 1e-4 for some fun */
+	return 0;
+}

Task/Monte-Carlo-methods/Clojure/monte-carlo-methods-1.clj

@@ -0,0 +1,7 @@
+(defn calc-pi [iterations]
+  (loop [x (rand) y (rand) in 0 total 1]
+    (if (< total iterations)
+      (recur (rand) (rand) (if (<= (+ (* x x) (* y y)) 1) (inc in) in) (inc total))
+      (double (* (/ in total) 4)))))
+
+(doseq [x (take 5 (iterate #(* 10 %) 10))] (println (str (format "% 8d" x) ": " (calc-pi x))))

Task/Monte-Carlo-methods/Clojure/monte-carlo-methods-2.clj

@@ -0,0 +1,9 @@
+(defn experiment
+  []
+  (if (<= (+ (Math/pow (rand) 2) (Math/pow (rand) 2)) 1) 1 0))
+
+(defn pi-estimate
+  [n]
+  (* 4 (float (/ (reduce + (take n (repeatedly experiment))) n))))
+
+(pi-estimate 10000)

Task/Monte-Carlo-methods/Common-Lisp/monte-carlo-methods.lisp

@@ -0,0 +1,5 @@
+(defun approximate-pi (n)
+  (/ (loop repeat n count (<= (abs (complex (random 1.0) (random 1.0))) 1.0)) n 0.25))
+
+(dolist (n (loop repeat 5 for n = 1000 then (* n 10) collect n))
+  (format t "~%~8d -> ~f" n (approximate-pi n)))

Task/Monte-Carlo-methods/Crystal/monte-carlo-methods.crystal

@@ -0,0 +1,8 @@
+def approx_pi(throws)
+  times_inside = throws.times.count {Math.hypot(rand, rand) <= 1.0}
+  4.0 * times_inside / throws
+end
+
+[1000, 10_000, 100_000, 1_000_000, 10_000_000].each do |n|
+   puts "%8d samples: PI = %s" % [n, approx_pi(n)]
+end

Task/Monte-Carlo-methods/D/monte-carlo-methods-1.d

@@ -0,0 +1,14 @@
+import std.stdio, std.random, std.math;
+
+double pi(in uint nthrows) /*nothrow*/ @safe /*@nogc*/ {
+    uint inside;
+    foreach (immutable i; 0 .. nthrows)
+        if (hypot(uniform01, uniform01) <= 1)
+            inside++;
+    return 4.0 * inside / nthrows;
+}
+
+void main() {
+    foreach (immutable p; 1 .. 8)
+        writefln("%10s: %07f", 10 ^^ p, pi(10 ^^ p));
+}

Task/Monte-Carlo-methods/D/monte-carlo-methods-2.d

@@ -0,0 +1,9 @@
+void main() {
+    import std.stdio, std.random, std.math, std.algorithm, std.range;
+
+    immutable isIn = (int) => hypot(uniform01, uniform01) <= 1;
+    immutable pi = (in int n)  => 4.0 * n.iota.count!isIn / n;
+
+    foreach (immutable p; 1 .. 8)
+        writefln("%10s: %07f", 10 ^^ p, pi(10 ^^ p));
+}

Task/Monte-Carlo-methods/Dart/monte-carlo-methods.dart

@@ -0,0 +1,50 @@
+import 'dart:async';
+import 'dart:html';
+import 'dart:math' show Random;
+
+// We changed 5 lines of code to make this sample nicer on
+// the web (so that the execution waits for animation frame,
+// the number gets updated in the DOM, and the program ends
+// after 500 iterations).
+
+main() async {
+  print('Compute π using the Monte Carlo method.');
+  var output = querySelector("#output");
+  await for (var estimate in computePi().take(500)) {
+    print('π ≅ $estimate');
+    output.text = estimate.toStringAsFixed(5);
+    await window.animationFrame;
+  }
+}
+
+/// Generates a stream of increasingly accurate estimates of π.
+Stream<double> computePi({int batch: 100000}) async* {
+  var total = 0;
+  var count = 0;
+  while (true) {
+    var points = generateRandom().take(batch);
+    var inside = points.where((p) => p.isInsideUnitCircle);
+    total += batch;
+    count += inside.length;
+    var ratio = count / total;
+    // Area of a circle is A = π⋅r², therefore π = A/r².
+    // So, when given random points with x ∈ <0,1>,
+    // y ∈ <0,1>, the ratio of those inside a unit circle
+    // should approach π / 4. Therefore, the value of π
+    // should be:
+    yield ratio * 4;
+  }
+}
+
+Iterable<Point> generateRandom([int seed]) sync* {
+  final random = new Random(seed);
+  while (true) {
+    yield new Point(random.nextDouble(), random.nextDouble());
+  }
+}
+
+class Point {
+  final double x, y;
+  const Point(this.x, this.y);
+  bool get isInsideUnitCircle => x * x + y * y <= 1;
+}

Task/Monte-Carlo-methods/Delphi/monte-carlo-methods.delphi

@@ -0,0 +1,36 @@
+function MonteCarloPi(N: cardinal): double;
+{Approximate Pi by seeing if points fall inside circle}
+var I,InsideCnt: integer;
+var X,Y: double;
+begin
+InsideCnt:=0;
+for I:=1 to N do
+	begin
+	{Random X,Y = 0..1}
+	X:=Random;
+	Y:=Random;
+	{See if it falls in Unit Circle}
+	if X*X + Y*Y <= 1 then Inc(InsideCnt);
+	end;
+{Because X and Y are squared, they only fall with 1/4 of the circle}
+Result:=4 * InsideCnt / N;
+end;
+
+
+procedure ShowOneSimulation(Memo: TMemo; N: cardinal);
+var MyPi: double;
+begin
+MyPi:=MonteCarloPi(N);
+Memo.Lines.Add(Format('Samples: %15.0n   Pi= %2.15f',[N+0.0,MyPi]));
+end;
+
+
+procedure ShowMonteCarloPi(Memo: TMemo);
+begin
+ShowOneSimulation(Memo,1000);
+ShowOneSimulation(Memo,10000);
+ShowOneSimulation(Memo,100000);
+ShowOneSimulation(Memo,1000000);
+ShowOneSimulation(Memo,10000000);
+ShowOneSimulation(Memo,100000000);
+end;

Task/Monte-Carlo-methods/E/monte-carlo-methods.e

@@ -0,0 +1,7 @@
+def pi(n) {
+    var inside := 0
+    for _ ? (entropy.nextFloat() ** 2 + entropy.nextFloat() ** 2 < 1) in 1..n {
+         inside += 1
+    }
+    return inside * 4 / n
+}

Task/Monte-Carlo-methods/EDSAC-order-code/monte-carlo-methods.edsac

@@ -0,0 +1,115 @@
+[Monte Carlo solution for Rosetta Code.]
+[EDSAC program, Initial Orders 2.]
+
+  [Arrange the storage]
+          T45K P56F     [H parameter: library s/r P1 to print real number]
+          T46K P78F     [N parameter: library s/r P7 to print integer]
+          T47K P210F    [M parameter: main routine]
+          T48K P114F    [& (delta) parameter: library s/r C6 (division)]
+          T49K P150F    [L parameter: library subroutine R4 to read data]
+          T51K P172F    [G parameter: generator for pseudo-random numbers]
+
+[Library subroutine M3, runs at load time and is then overwritten.
+ Prints header; here the header sets teleprinter to figures.]
+      PFGKIFAFRDLFUFOFE@A6FG@E8FEZPF
+      *!!!!TRIALS!!EST!PI#X10@&..
+          PK            [after header, blank tape and PK (WWG, 1951, page 91)]
+
+[================ Main routine ====================]
+          E25K TM GK
+[Variables]
+    [0]   PF PF         [target count: print result when count = target]
+    [2]   PF PF         [count of points]
+    [4]   PF PF         [count of hits (point inside circle)]
+    [6]   PF PF         [x-coordinate - 1/2]
+[Constants]
+          T8#Z PF T10#Z PF [clear sandwich bits in 35-bit constants]
+          T8Z           [resume normal loading]
+    [8]   PD PF         [35-bit constant 1]
+   [10]   L1229F Y819F  [35-bit constant 2/5 (near enough)]
+   [12]   IF            [1/2]
+   [13]   RF            [1/4]
+   [14]   #F            [figures shift]
+   [15]   MF            [dot (decimal point) in figures mode]
+   [16]   @F            [carriage return]
+   [17]   &F            [line feed]
+   [18]   !F            [space]
+
+ [Enter with acc = 0]
+   [19]   A19@ GL       [read seed for LCG into 0D]
+          AD T4D        [pass seed to LCG in 4D]
+   [23]   A23@ GG       [initialize LCG]
+          T2#@ T4#@     [zero trials and hits]
+[Outer loop: round target counts]
+   [27]   TF            [clear acc]
+   [28]   A28@ GL       [read next target count into 0D]
+          SD            [acc := -target]
+          E85@          [exit if target = 0]
+          T#@           [store negated target]
+[Inner loop : round points in the square]
+   [33]   TF T4D        [pass LCG range = 0 to return random real in [0,1)]
+   [35]   A35@ G1G      [call LCG, 0D := random x]
+          AD S12@ T6#@  [store x - 1/2 over next call]
+          T4D
+   [41]   A41@ G1G      [call LCG, 0D := random y]
+          AD S12@ TD    [store y - 1/2]
+          H6#@ V6#@     [acc := (x - 1/2)^2]
+          HD VD         [acc := acc := (x - 1/2)^2 + (y - 1/2)^2]
+          S13@          [test for point inside circle, i.e. acc < 1/4]
+          E56@          [skip if not]
+          TF A4#@ A8#@ T4#@ [inc number of hits]
+   [56]   TF A2#@ A8#@ U2#@ [inc number of trials]
+          A#@           [add negated target]
+          G33@          [if not reached target, loop back]
+          A2#@ TD       [pass number of trials to print s/r]
+   [64]   A64@ GN       [print number of trials]
+          A4#@ TD A2#@ T4D [pass hits and trials to division s/r]
+   [70]   A70@ G&       [0D := hits/trials, estimated value of pi/4]
+          HD V10#@ TD   [times 2/5; pass estimated pi/10 to print s/r]
+          O18@ O18@ O8@ O15@ [print '  0.']
+   [79]   A79@ GH P5F   [print estimated pi/10 to 5 decimals]
+          O16@ O17@     [print CR, LF]
+          E27@          [loop back for new target]
+   [85]   O14@          [exit: print dummy character to flush printer buffer]
+          ZF            [halt program]
+
+[==================== Generator for pseudo-random numbers ===========]
+[Linear congruential generator, same algorithm as Delphi 7 LCG.
+ 38 locations]
+          E25K TG
+          GK G10@ G15@ T2#Z PF T2Z I514D P257F T4#Z PF T4Z PD PF T6#Z PF T6Z PF RF A6#@ S4#@ T6#@ E25F E8Z PF T8Z PF PF A3F T14@ A4D T8#@ ZF A3F T37@ H2#@ V8#@ L512F L512F L1024F A4#@ T8#@ H6#@ C8#@ T8#@ S4D G32@ TD A8#@ E35@ H4D TD V8#@ L1F TD ZF
+
+[==================== LIBRARY SUBROUTINES ============================]
+[D6: Division, accurate, fast.
+ 36 locations, workspace 6D and 8D.
+ 0D := 0D/4D, where 4D <> 0, -1.]
+          E25K T& GK
+          GKA3FT34@S4DE13@T4DSDTDE2@T4DADLDTDA4DLDE8@RDU4DLDA35@
+          T6DE25@U8DN8DA6DT6DH6DS6DN4DA4DYFG21@SDVDTDEFW1526D
+
+[R4: Input of one signed integer at runtime.
+ 22 storage locations; working positions 4, 5, and 6.]
+          E25K TL
+          GKA3FT21@T4DH6@E11@P5DJFT6FVDL4FA4DTDI4FA4FS5@G7@S5@G20@SDTDT6FEF
+
+[P1: Prints non-negative fraction in 0D, without '0.']
+          E25K TH
+          GKA18@U17@S20@T5@H19@PFT5@VDUFOFFFSFL4FTDA5@A2FG6@EFU3FJFM1F
+
+[P7, prints long strictly positive integer;
+ 10 characters, right justified, padded left with spaces.
+ Even address; 35 storage locations; working position 4D.]
+          E25K TN
+          GKA3FT26@H28#@NDYFLDT4DS27@TFH8@S8@T1FV4DAFG31@SFLDUFOFFFSF
+          L4FT4DA1FA27@G11@XFT28#ZPFT27ZP1024FP610D@524D!FO30@SFL8FE22@
+
+[===================================================================]
+[The following, without the comments and white space, might have
+ been input from a separate tape.]
+          E25K TM GK
+          E19Z          [define entry point]
+          PF            [acc = 0 on entry]
+[Integers supplied by user: (1) seed for LCG; (2) list of numbers of trials
+ for which to print result; increasing order, terminated by 0.
+ To be read by library subroutine R4; sign comes after value.]
+          987654321+100+1000+10000+100000+0+

Task/Monte-Carlo-methods/ERRE/monte-carlo-methods.erre

@@ -0,0 +1,24 @@
+PROGRAM RANDOM_PI
+
+!
+! for rosettacode.org
+!
+
+!$DOUBLE
+
+PROCEDURE MONTECARLO(T->RES)
+      LOCAL I,N
+      FOR I=1 TO T DO
+        IF RND(1)^2+RND(1)^2<1 THEN N+=1 END IF
+      END FOR
+      RES=4*N/T
+END PROCEDURE
+
+BEGIN
+      RANDOMIZE(TIMER) ! init rnd number generator
+      MONTECARLO(1000->RES)     PRINT(RES)
+      MONTECARLO(10000->RES)    PRINT(RES)
+      MONTECARLO(100000->RES)   PRINT(RES)
+      MONTECARLO(1000000->RES)  PRINT(RES)
+      MONTECARLO(10000000->RES) PRINT(RES)
+END PROGRAM

Task/Monte-Carlo-methods/EasyLang/monte-carlo-methods.easy

@@ -0,0 +1,15 @@
+proc mc n . .
+   for i = 1 to n
+      x = randomf
+      y = randomf
+      if x * x + y * y < 1
+         hit += 1
+      .
+   .
+   print 4.0 * hit / n
+.
+numfmt 4 0
+call mc 10000
+call mc 100000
+call mc 1000000
+call mc 10000000

Task/Monte-Carlo-methods/Elixir/monte-carlo-methods.elixir

@@ -0,0 +1,14 @@
+defmodule MonteCarlo do
+  def pi(n) do
+    count = Enum.count(1..n, fn _ ->
+      x = :rand.uniform
+      y = :rand.uniform
+      :math.sqrt(x*x + y*y) <= 1
+    end)
+    4 * count / n
+  end
+end
+
+Enum.each([1000, 10000, 100000, 1000000, 10000000], fn n ->
+  :io.format "~8w samples: PI = ~f~n", [n, MonteCarlo.pi(n)]
+end)

Task/Monte-Carlo-methods/Erlang/monte-carlo-methods-1.erl

@@ -0,0 +1,17 @@
+-module(monte).
+-export([main/1]).
+
+monte(N)->
+    monte(N,0,0).
+
+monte(0,InCircle,NumPoints) ->
+    4 * InCircle / NumPoints;
+
+monte(N,InCircle,NumPoints)->
+    Xcoord = rand:uniform(),
+    Ycoord = rand:uniform(),
+    monte(N-1,
+          if Xcoord*Xcoord + Ycoord*Ycoord < 1 -> InCircle + 1; true -> InCircle end,
+          NumPoints + 1).
+
+main(N) -> io:format("PI: ~w~n", [ monte(N) ]).

Task/Monte-Carlo-methods/Erlang/monte-carlo-methods-2.erl

@@ -0,0 +1,20 @@
+-module(monte2).
+-export([main/1]).
+
+monte(N)->
+    monte(N,0,0).
+
+monte(0,InCircle,NumPoints) ->
+    4 * InCircle / NumPoints;
+
+monte(N,InCircle,NumPoints)->
+    X = rand:uniform(),
+    Y = rand:uniform(),
+    monte(N-1, within(X,Y,InCircle), NumPoints + 1).
+
+within(X,Y,IN)->
+          if X*X + Y*Y < 1 -> IN + 1;
+          true -> IN
+          end.
+
+main(N) -> io:format("PI: ~w~n", [ monte(N) ]).

Task/Monte-Carlo-methods/Euler/monte-carlo-methods.euler

@@ -0,0 +1,14 @@
+>function map MonteCarloPI (n,plot=false) ...
+$  X:=random(1,n);
+$  Y:=random(1,n);
+$  if plot then
+$      plot2d(X,Y,>points,style=".");
+$      plot2d("sqrt(1-x^2)",color=2,>add);
+$  endif
+$  return sum(X^2+Y^2<1)/n*4;
+$endfunction
+>MonteCarloPI(10^(1:7))
+ [ 3.6  2.96  3.224  3.1404  3.1398  3.141548  3.1421492 ]
+>pi
+ 3.14159265359
+>MonteCarloPI(10000,true):

Task/Monte-Carlo-methods/F-Sharp/monte-carlo-methods.fs

@@ -0,0 +1,19 @@
+let print x = printfn "%A" x
+
+let MonteCarloPiGreco niter =
+    let eng = System.Random()
+    let action () =
+        let x: float = eng.NextDouble()
+        let y: float = eng.NextDouble()
+        let res: float = System.Math.Sqrt(x**2.0 + y**2.0)
+        if res < 1.0 then
+            1
+        else
+            0
+    let res = [ for x in 1..niter do yield action() ]
+    let tmp: float = float(List.reduce (+) res) / float(res.Length)
+    4.0*tmp
+
+MonteCarloPiGreco 1000 |> print
+MonteCarloPiGreco 10000 |> print
+MonteCarloPiGreco 100000 |> print

Task/Monte-Carlo-methods/Factor/monte-carlo-methods-1.factor

@@ -0,0 +1,6 @@
+USING: kernel math math.functions random sequences ;
+
+: limit ( -- n ) 2 32 ^ ; inline
+: in-circle ( x y -- ? ) limit [ sq ] tri@ [ + ] [ <= ] bi* ;
+: rand ( -- r ) limit random ;
+: pi ( n -- pi ) [ [ drop rand rand in-circle ] count ] keep / 4 * >float ;

Task/Monte-Carlo-methods/Factor/monte-carlo-methods-2.factor

@@ -0,0 +1,2 @@
+10000 pi .
+3.1412

Task/Monte-Carlo-methods/Fantom/monte-carlo-methods.fantom

@@ -0,0 +1,23 @@
+class MontyCarlo
+{
+  // assume square/circle of width 1 unit
+  static Float findPi (Int samples)
+  {
+    Int insideCircle := 0
+    samples.times
+    {
+      x := Float.random
+      y := Float.random
+      if ((x*x + y*y).sqrt <= 1.0f) insideCircle += 1
+    }
+    return insideCircle * 4.0f / samples
+  }
+
+  public static Void main ()
+  {
+    [100, 1000, 10000, 1000000, 10000000].each |sample|
+    {
+      echo ("Sample size $sample gives PI as ${findPi(sample)}")
+    }
+  }
+}

Task/Monte-Carlo-methods/Fortran/monte-carlo-methods-1.f

@@ -0,0 +1,35 @@
+MODULE Simulation
+
+   IMPLICIT NONE
+
+   CONTAINS
+
+   FUNCTION Pi(samples)
+     REAL :: Pi
+     REAL :: coords(2), length
+     INTEGER :: i, in_circle, samples
+
+     in_circle = 0
+     DO i=1, samples
+       CALL RANDOM_NUMBER(coords)
+       coords = coords * 2 - 1
+       length = SQRT(coords(1)*coords(1) + coords(2)*coords(2))
+       IF (length <= 1) in_circle = in_circle + 1
+     END DO
+     Pi = 4.0 * REAL(in_circle) / REAL(samples)
+   END FUNCTION Pi
+
+ END MODULE Simulation
+
+ PROGRAM MONTE_CARLO
+
+   USE Simulation
+
+   INTEGER :: n = 10000
+
+   DO WHILE (n <= 100000000)
+     WRITE (*,*) n, Pi(n)
+     n = n * 10
+   END DO
+
+ END PROGRAM MONTE_CARLO

Task/Monte-Carlo-methods/Fortran/monte-carlo-methods-2.f

@@ -0,0 +1,16 @@
+        program mc
+        integer :: n,i
+        real(8) :: pi
+        n=10000
+        do i=1,5
+          print*,n,pi(n)
+          n = n * 10
+        end do
+        end program
+
+        function  pi(n)
+        integer :: n
+        real(8) :: x(2,n),pi
+        call random_number(x)
+        pi = 4.d0 * dble( count( hypot(x(1,:),x(2,:)) <= 1.d0 ) ) / n
+        end function

Task/Monte-Carlo-methods/FreeBASIC/monte-carlo-methods.basic

@@ -0,0 +1,33 @@
+' version 23-10-2016
+' compile with: fbc -s console
+
+Randomize Timer  'seed the random function
+
+Dim As Double x, y, pi, error_
+Dim As UInteger m = 10, n, n_start, n_stop = m, p
+
+Print
+Print " Mumber of throws  Ratio (Pi)     Error"
+Print
+
+Do
+    For n = n_start To n_stop -1
+        x = Rnd
+        y = Rnd
+        If (x * x + y * y) <= 1 Then p = p +1
+    Next
+    Print Using "    ############,  "; m ;
+    pi = p * 4 / m
+    error_ = 3.141592653589793238462643383280 - pi
+    Print RTrim(Str(pi),"0");Tab(35); Using "##.#############"; error_
+    m = m * 10
+    n_start = n_stop
+    n_stop = m
+Loop Until m > 1000000000 ' 1,000,000,000
+
+
+' empty keyboard buffer
+While Inkey <> "" : Wend
+Print : Print "hit any key to end program"
+Sleep
+End

Task/Monte-Carlo-methods/Futhark/monte-carlo-methods.futhark

@@ -0,0 +1,48 @@
+import "futlib/math"
+
+default(f32)
+
+fun dirvcts(): [2][30]i32 =
+    [
+            [
+                536870912, 268435456, 134217728, 67108864, 33554432, 16777216, 8388608, 4194304, 2097152, 1048576, 524288, 262144, 131072, 65536, 32768, 16384, 8192, 4096, 2048, 1024, 512, 256, 128, 64, 32, 16, 8, 4, 2, 1
+            ],
+            [
+                536870912, 805306368, 671088640, 1006632960, 570425344, 855638016, 713031680, 1069547520, 538968064, 808452096, 673710080, 1010565120, 572653568, 858980352, 715816960, 1073725440, 536879104, 805318656, 671098880, 1006648320, 570434048, 855651072, 713042560, 1069563840, 538976288, 808464432, 673720360, 1010580540, 572662306, 858993459
+            ]
+    ]
+
+
+fun grayCode(x: i32): i32 = (x >> 1) ^ x
+
+----------------------------------------
+--- Sobol Generator
+----------------------------------------
+fun testBit(n: i32, ind: i32): bool =
+    let t = (1 << ind) in (n & t) == t
+
+fun xorInds(n: i32) (dir_vs: [num_bits]i32): i32 =
+    let reldv_vals = zipWith (\ dv i  ->
+                                if testBit(grayCode n,i)
+                                then dv else 0)
+                             dir_vs (iota num_bits)
+    in reduce (^) 0 reldv_vals
+
+fun sobolIndI (dir_vs: [m][num_bits]i32, n: i32): [m]i32 =
+    map (xorInds n) dir_vs
+
+fun sobolIndR(dir_vs:  [m][num_bits]i32) (n: i32 ): [m]f32 =
+    let divisor = 2.0 ** f32(num_bits)
+    let arri    = sobolIndI( dir_vs, n )
+    in map (\ (x: i32): f32  -> f32(x) / divisor) arri
+
+fun main(n: i32): f32 =
+    let rand_nums = map (sobolIndR (dirvcts())) (iota n)
+    let dists     = map (\xy ->
+                           let (x,y) = (xy[0],xy[1]) in f32.sqrt(x*x + y*y))
+                        rand_nums
+
+    let bs        = map (\d -> if d <= 1.0f32 then 1 else 0) dists
+
+    let inside    = reduce (+) 0 bs
+    in 4.0f32*f32(inside)/f32(n)

Task/Monte-Carlo-methods/Go/monte-carlo-methods-1.go

@@ -0,0 +1,33 @@
+package main
+
+import (
+    "fmt"
+    "math"
+    "math/rand"
+    "time"
+)
+
+func getPi(numThrows int) float64 {
+    inCircle := 0
+    for i := 0; i < numThrows; i++ {
+        //a square with a side of length 2 centered at 0 has
+        //x and y range of -1 to 1
+        randX := rand.Float64()*2 - 1 //range -1 to 1
+        randY := rand.Float64()*2 - 1 //range -1 to 1
+        //distance from (0,0) = sqrt((x-0)^2+(y-0)^2)
+        dist := math.Hypot(randX, randY)
+        if dist < 1 { //circle with diameter of 2 has radius of 1
+            inCircle++
+        }
+    }
+    return 4 * float64(inCircle) / float64(numThrows)
+}
+
+func main() {
+    rand.Seed(time.Now().UnixNano())
+    fmt.Println(getPi(10000))
+    fmt.Println(getPi(100000))
+    fmt.Println(getPi(1000000))
+    fmt.Println(getPi(10000000))
+    fmt.Println(getPi(100000000))
+}

Task/Monte-Carlo-methods/Go/monte-carlo-methods-2.go

@@ -0,0 +1,34 @@
+package main
+
+import (
+    "fmt"
+    "math"
+    "time"
+
+    "golang.org/x/exp/rand"
+)
+
+func getPi(numThrows int) float64 {
+    inCircle := 0
+    for i := 0; i < numThrows; i++ {
+        //a square with a side of length 2 centered at 0 has
+        //x and y range of -1 to 1
+        randX := rand.Float64()*2 - 1 //range -1 to 1
+        randY := rand.Float64()*2 - 1 //range -1 to 1
+        //distance from (0,0) = sqrt((x-0)^2+(y-0)^2)
+        dist := math.Hypot(randX, randY)
+        if dist < 1 { //circle with diameter of 2 has radius of 1
+            inCircle++
+        }
+    }
+    return 4 * float64(inCircle) / float64(numThrows)
+}
+
+func main() {
+    rand.Seed(uint64(time.Now().UnixNano()))
+    fmt.Println(getPi(10000))
+    fmt.Println(getPi(100000))
+    fmt.Println(getPi(1000000))
+    fmt.Println(getPi(10000000))
+    fmt.Println(getPi(100000000))
+}

Task/Monte-Carlo-methods/Haskell/monte-carlo-methods-1.hs

@@ -0,0 +1,13 @@
+import Control.Monad
+import System.Random
+
+getPi throws = do
+  results <- replicateM throws one_trial
+  return (4 * fromIntegral (sum results) / fromIntegral throws)
+  where
+    one_trial = do
+      rand_x <- randomRIO (-1, 1)
+      rand_y <- randomRIO (-1, 1)
+      let dist :: Double
+          dist = sqrt (rand_x * rand_x + rand_y * rand_y)
+      return (if dist < 1 then 1 else 0)

Task/Monte-Carlo-methods/Haskell/monte-carlo-methods-2.hs

@@ -0,0 +1,23 @@
+import Control.Monad (foldM, (>=>))
+import System.Random (randomRIO)
+import Data.Functor ((<&>))
+
+------- APPROXIMATION TO PI BY A MONTE CARLO METHOD ------
+
+monteCarloPi :: Int -> IO Double
+monteCarloPi n =
+  (/ fromIntegral n) . (4 *) . fromIntegral
+    <$> foldM go 0 [1 .. n]
+  where
+    rnd = randomRIO (0, 1) :: IO Double
+    go a _ = rnd >>= ((<&>) rnd . f a)
+    f a x y
+      | 1 > x ** 2 + y ** 2 = succ a
+      | otherwise = a
+
+--------------------------- TEST -------------------------
+main :: IO ()
+main =
+  mapM_
+    (monteCarloPi >=> print)
+    [1000, 10000, 100000, 1000000]

Task/Monte-Carlo-methods/HicEst/monte-carlo-methods.hicest

@@ -0,0 +1,12 @@
+FUNCTION Pi(samples)
+   inside = 0
+   DO i = 1, samples
+      inside = inside + ( (RAN(1)^2 + RAN(1)^2)^0.5 <= 1)
+   ENDDO
+   Pi = 4 * inside / samples
+END
+
+   WRITE(ClipBoard) Pi(1E4) ! 3.1504
+   WRITE(ClipBoard) Pi(1E5) ! 3.14204
+   WRITE(ClipBoard) Pi(1E6) ! 3.141672
+   WRITE(ClipBoard) Pi(1E7) ! 3.1412856

Task/Monte-Carlo-methods/Icon/monte-carlo-methods.icon

@@ -0,0 +1,14 @@
+procedure main()
+  every t := 10 ^ ( 5 to 9 ) do
+     printf("Rounds=%d Pi ~ %r\n",t,getPi(t))
+end
+
+link printf
+
+procedure getPi(rounds)
+   incircle := 0.
+   every 1 to rounds do
+      if 1 > sqrt((?0 * 2 - 1) ^ 2 + (?0 * 2 - 1) ^ 2) then
+         incircle +:= 1
+   return 4 * incircle / rounds
+end

Task/Monte-Carlo-methods/J/monte-carlo-methods-1.j

@@ -0,0 +1,3 @@
+piMC=: monad define "0
+  4* y%~ +/ 1>: %: +/ *: <: +: (2,y) ?@$ 0
+)

Task/Monte-Carlo-methods/J/monte-carlo-methods-2.j

@@ -0,0 +1 @@
+piMCt=: (0.25&* %~ +/@(1 >: [: +/&.:*: _1 2 p. 0 ?@$~ 2&,))"0

Task/Monte-Carlo-methods/J/monte-carlo-methods-3.j

@@ -0,0 +1,4 @@
+   piMC 1e6
+3.1426
+   piMC 10^i.7
+4 2.8 3.24 3.168 3.1432 3.14256 3.14014

Task/Monte-Carlo-methods/Java/monte-carlo-methods-1.java

@@ -0,0 +1,26 @@
+public class MC {
+	public static void main(String[] args) {
+		System.out.println(getPi(10000));
+		System.out.println(getPi(100000));
+		System.out.println(getPi(1000000));
+		System.out.println(getPi(10000000));
+		System.out.println(getPi(100000000));
+		
+	}
+	public static double getPi(int numThrows){
+		int inCircle= 0;
+		for(int i= 0;i < numThrows;i++){
+			//a square with a side of length 2 centered at 0 has
+			//x and y range of -1 to 1
+			double randX= (Math.random() * 2) - 1;//range -1 to 1
+			double randY= (Math.random() * 2) - 1;//range -1 to 1
+			//distance from (0,0) = sqrt((x-0)^2+(y-0)^2)
+			double dist= Math.sqrt(randX * randX + randY * randY);
+			//^ or in Java 1.5+: double dist= Math.hypot(randX, randY);
+			if(dist < 1){//circle with diameter of 2 has radius of 1
+				inCircle++;
+			}
+		}
+		return 4.0 * inCircle / numThrows;
+	}
+}

Task/Monte-Carlo-methods/Java/monte-carlo-methods-2.java

@@ -0,0 +1,44 @@
+package montecarlo;
+
+import java.util.stream.IntStream;
+import java.util.stream.DoubleStream;
+
+import static java.lang.Math.random;
+import static java.lang.Math.hypot;
+import static java.lang.System.out;
+
+public interface MonteCarlo {
+  public static void main(String... arguments) {
+    IntStream.of(
+      10000,
+      100000,
+      1000000,
+      10000000,
+      100000000
+    )
+      .mapToDouble(MonteCarlo::pi)
+      .forEach(out::println)
+    ;
+  }
+
+  public static double range() {
+    //a square with a side of length 2 centered at 0 has
+    //x and y range of -1 to 1
+    return (random() * 2) - 1;
+  }
+
+  public static double pi(int numThrows){
+    long inCircle = DoubleStream.generate(
+      //distance from (0,0) = hypot(x, y)
+      () -> hypot(range(), range())
+    )
+      .limit(numThrows)
+      .unordered()
+      .parallel()
+      //circle with diameter of 2 has radius of 1
+      .filter(d -> d < 1)
+      .count()
+    ;
+    return (4.0 * inCircle) / numThrows;
+  }
+}

Task/Monte-Carlo-methods/JavaScript/monte-carlo-methods-1.js

@@ -0,0 +1,20 @@
+function mcpi(n) {
+    var x, y, m = 0;
+
+    for (var i = 0; i < n; i += 1) {
+        x = Math.random();
+        y = Math.random();
+
+        if (x * x + y * y < 1) {
+            m += 1;
+        }
+    }
+
+    return 4 * m / n;
+}
+
+console.log(mcpi(1000));
+console.log(mcpi(10000));
+console.log(mcpi(100000));
+console.log(mcpi(1000000));
+console.log(mcpi(10000000));

Task/Monte-Carlo-methods/JavaScript/monte-carlo-methods-2.js

@@ -0,0 +1,39 @@
+(() => {
+    "use strict";
+
+    // --- APPROXIMATION OF PI BY A MONTE CARLO METHOD ---
+
+    // monteCarloPi :: Int -> Float
+    const monteCarloPi = n =>
+        4 * enumFromTo(1)(n).reduce(a => {
+            const [x, y] = [rnd(), rnd()];
+
+            return (x ** 2) + (y ** 2) < 1 ? (
+                1 + a
+            ) : a;
+        }, 0) / n;
+
+
+    // --------------------- GENERIC ---------------------
+
+    // enumFromTo :: Int -> Int -> [Int]
+    const enumFromTo = m =>
+        n => Array.from({
+            length: 1 + n - m
+        }, (_, i) => m + i);
+
+
+    // rnd :: () -> Float
+    const rnd = Math.random;
+
+
+    // ---------------------- TEST -----------------------
+    // From 1000 samples to 10E7 samples
+    return enumFromTo(3)(7).forEach(x => {
+        const nSamples = 10 ** x;
+
+        console.log(
+            `${nSamples} samples: ${monteCarloPi(nSamples)}`
+        );
+    });
+})();

Task/Monte-Carlo-methods/Jq/monte-carlo-methods-1.jq

@@ -0,0 +1,6 @@
+# In case gojq is used, trim leading 0s:
+function prng {
+    cat /dev/urandom | tr -cd '0-9' | fold -w 10 | sed 's/^0*\(.*\)*\(.\)*$/\1\2/'
+}
+
+prng | jq -nMr -f program.jq

Task/Monte-Carlo-methods/Jq/monte-carlo-methods-2.jq

@@ -0,0 +1,24 @@
+def lpad($len): tostring | ($len - length) as $l | (" " * $l)[:$l] + .;
+
+def percent: "\(100000 * . | round / 1000)%";
+
+def pi: 4* (1|atan);
+
+def rfloat: input/1E10;
+
+def mcPi:
+  . as $n
+  | reduce range(0; $n) as $i (0;
+      rfloat as $x
+      | rfloat as $y
+      | if ($x*$x + $y*$y <= 1) then . + 1 else . end)
+   | 4 * . / $n ;
+
+"Iterations -> Approx Pi  -> Error",
+"----------    ----------    ------",
+( pi as $pi
+ | range(1; 7)
+ | pow(10;.) as $p
+ | ($p | mcPi) as $mcpi
+ | ((($pi - $mcpi)|length) / $pi) as $error
+ | "\($p|lpad(10))    \($mcpi|lpad(10))    \($error|percent|lpad(6))" )

Task/Monte-Carlo-methods/Jsish/monte-carlo-methods.jsish

@@ -0,0 +1,32 @@
+/* Monte Carlo methods, in Jsish */
+function mcpi(n) {
+    var x, y, m = 0;
+
+    for (var i = 0; i < n; i += 1) {
+        x = Math.random();
+        y = Math.random();
+
+        if (x * x + y * y < 1) {
+            m += 1;
+        }
+    }
+
+    return 4 * m / n;
+}
+
+if (Interp.conf('unitTest')) {
+    Math.srand(0);
+;    mcpi(1000);
+;    mcpi(10000);
+;    mcpi(100000);
+;    mcpi(1000000);
+}
+
+/*
+=!EXPECTSTART!=
+mcpi(1000) ==> 3.108
+mcpi(10000) ==> 3.1236
+mcpi(100000) ==> 3.13732
+mcpi(1000000) ==> 3.142124
+=!EXPECTEND!=
+*/

Task/Monte-Carlo-methods/Julia/monte-carlo-methods.julia

@@ -0,0 +1,11 @@
+using Printf
+
+function monteπ(n)
+    s = count(rand() ^ 2 + rand() ^ 2 < 1 for _ in 1:n)
+    return 4s / n
+end
+
+for n in 10 .^ (3:8)
+    p = monteπ(n)
+    println("$(lpad(n, 9)): π ≈ $(lpad(p, 10)), pct.err = ", @sprintf("%2.5f%%", 100 * abs(p - π) / π))
+end

Task/Monte-Carlo-methods/K/monte-carlo-methods.k

@@ -0,0 +1,7 @@
+   sim:{4*(+/{~1<+/(2_draw 0)^2}'!x)%x}
+
+   sim 10000
+3.103
+
+   sim'10^!8
+4 2.8 3.4 3.072 3.1212 3.14104 3.14366 3.1413

Task/Monte-Carlo-methods/Kotlin/monte-carlo-methods.kotlin

@@ -0,0 +1,23 @@
+// version 1.1.0
+
+fun mcPi(n: Int): Double {
+    var inside = 0
+    (1..n).forEach {
+        val x = Math.random()
+        val y = Math.random()
+        if (x * x + y * y <= 1.0) inside++
+    }
+    return 4.0 * inside / n
+}
+
+fun main(args: Array<String>) {
+    println("Iterations -> Approx Pi  -> Error%")
+    println("----------    ----------    ------")
+    var n = 1_000
+    while (n <= 100_000_000) {
+        val pi = mcPi(n)
+        val err = Math.abs(Math.PI - pi) / Math.PI * 100.0
+        println(String.format("%9d  -> %10.8f -> %6.4f", n, pi, err))
+        n *= 10
+    }
+}

Task/Monte-Carlo-methods/LSL/monte-carlo-methods.lsl

@@ -0,0 +1,22 @@
+integer iMIN_SAMPLE_POWER = 0;
+integer iMAX_SAMPLE_POWER = 6;
+default {
+	state_entry() {
+		llOwnerSay("Estimating Pi ("+(string)PI+")");
+		integer iSample = 0;
+		for(iSample=iMIN_SAMPLE_POWER ; iSample<=iMAX_SAMPLE_POWER  ; iSample++) {
+			integer iInCircle = 0;
+			integer x = 0;
+			integer iMaxSamples = (integer)llPow(10, iSample);
+			for(x=0 ; x<iMaxSamples ; x++) {
+				if(llSqrt(llPow(llFrand(2.0)-1.0, 2.0)+llPow(llFrand(2.0)-1.0, 2.0))<1.0) {
+					iInCircle++;
+				}
+			}
+			float fPi = ((4.0*iInCircle)/llPow(10, iSample));
+			float fError = llFabs(100.0*(PI-fPi)/PI);
+			llOwnerSay((string)iSample+": "+(string)iMaxSamples+" = "+(string)fPi+", Error = "+(string)fError+"%");
+		}
+		llOwnerSay("Done.");
+	}
+}

Task/Monte-Carlo-methods/Liberty-BASIC/monte-carlo-methods.basic

@@ -0,0 +1,15 @@
+ for pow = 2 to 6
+    n = 10^pow
+    print n, getPi(n)
+next
+
+end
+
+function getPi(n)
+    incircle = 0
+    for throws=0 to n
+        scan
+        incircle = incircle + (rnd(1)^2+rnd(1)^2 < 1)
+    next
+    getPi = 4*incircle/throws
+end function

Task/Monte-Carlo-methods/Locomotive-Basic/monte-carlo-methods.basic

@@ -0,0 +1,16 @@
+10 mode 1:randomize time:defint a-z
+20 input "How many samples";n
+30 u=n/100+1
+40 r=100
+50 for i=1 to n
+60 if i mod u=0 then locate 1,3:print using "##% done"; i/n*100
+70 x=rnd*2*r-r
+80 y=rnd*2*r-r
+90 if sqr(x*x+y*y)<r then m=m+1
+100 next
+110 pi2!=4*m/n
+120 locate 1,3
+130 print m;"points in circle"
+140 print "Computed value of pi:"pi2!
+150 print "Difference to real value of pi: ";
+160 print using "+#.##%"; (pi2!-pi)/pi*100

Task/Monte-Carlo-methods/Logo/monte-carlo-methods.logo

@@ -0,0 +1,16 @@
+to square :n
+  output :n * :n
+end
+to trial :r
+  output less? sum square random :r square random :r  square :r
+end
+to sim :n :r
+  make "hits 0
+  repeat :n [if trial :r [make "hits :hits + 1]]
+  output 4 * :hits / :n
+end
+
+show sim    1000 10000  ; 3.18
+show sim   10000 10000  ; 3.1612
+show sim  100000 10000  ; 3.145
+show sim 1000000 10000  ; 3.140828

Task/Monte-Carlo-methods/Lua/monte-carlo-methods.lua

@@ -0,0 +1,17 @@
+function MonteCarlo ( n_throws )
+    math.randomseed( os.time() )
+
+    n_inside = 0
+    for i = 1, n_throws do
+    	if math.random()^2 + math.random()^2 <= 1.0 then
+            n_inside = n_inside + 1
+    	end
+    end
+
+    return 4 * n_inside / n_throws
+end
+
+print( MonteCarlo( 10000 ) )
+print( MonteCarlo( 100000 ) )
+print( MonteCarlo( 1000000 ) )
+print( MonteCarlo( 10000000 ) )

Task/Monte-Carlo-methods/MATLAB/monte-carlo-methods-1.m

@@ -0,0 +1,16 @@
+function piEstimate = monteCarloPi(numDarts)
+
+    %The square has a sides of length 2, which means the circle has radius
+    %1.
+
+    %Generate a table of random x-y value pairs in the range [0,1] sampled
+    %from the uniform distribution for each axis.
+    darts = rand(numDarts,2);
+
+    %Any darts that are in the circle will have position vector whose
+    %length is less than or equal to 1 squared.
+    dartsInside = ( sum(darts.^2,2) <= 1 );
+
+    piEstimate = 4*sum(dartsInside)/numDarts;
+
+end

Task/Monte-Carlo-methods/MATLAB/monte-carlo-methods-2.m

@@ -0,0 +1,5 @@
+function piEstimate = monteCarloPi(numDarts)
+
+    piEstimate = 4*sum( sum(rand(numDarts,2).^2,2) <= 1 )/numDarts;
+
+end

Task/Monte-Carlo-methods/MATLAB/monte-carlo-methods-3.m

@@ -0,0 +1,5 @@
+>> monteCarloPi(7000000)
+
+ans =
+
+   3.141512000000000

Task/Monte-Carlo-methods/Mathematica/monte-carlo-methods-1.math

@@ -0,0 +1 @@
+MonteCarloPi[samplesize_Integer] := N[4Mean[If[# > 1, 0, 1] & /@ Norm /@ RandomReal[1, {samplesize, 2}]]]

Task/Monte-Carlo-methods/Mathematica/monte-carlo-methods-2.math

@@ -0,0 +1 @@
+{#, MonteCarloPi[#]} & /@ (10^Range[1, 7]) // Grid

Task/Monte-Carlo-methods/Mathematica/monte-carlo-methods-3.math

@@ -0,0 +1,2 @@
+monteCarloPi = 4. Mean[UnitStep[1 - Total[RandomReal[1, {2, #}]^2]]] &;
+monteCarloPi /@ (10^Range@6)

Task/Monte-Carlo-methods/Mathematica/monte-carlo-methods-4.math

@@ -0,0 +1,4 @@
+MonkeyDartsPi[numberOfThrows_] := (
+xyCoordinates = RandomReal[{0, 1}, {numberOfThrows, 2}];
+InsideCircle = Length[Select[Total[xyCoordinates^2, {2}],#<=1&]] ;
+4*N[InsideCircle / Length[xyCoordinates],1+Log10[numberOfThrows]])

Task/Monte-Carlo-methods/Mathematica/monte-carlo-methods-5.math

@@ -0,0 +1 @@
+Grid[Table[{n, MonkeyDartsPi[n]}, {n, 10^Range[7]} ], Alignment -> Left]

Task/Monte-Carlo-methods/Maxima/monte-carlo-methods.maxima

@@ -0,0 +1,10 @@
+load("distrib");
+approx_pi(n):= block(
+  [x: random_continuous_uniform(0, 1, n),
+   y: random_continuous_uniform(0, 1, n),
+   r, cin: 0, listarith: true],
+   r: x^2 + y^2,
+   for r0 in r do if r0<1 then cin: cin + 1,
+   4*cin/n);
+
+float(approx_pi(100));

Task/Monte-Carlo-methods/Nim/monte-carlo-methods.nim

@@ -0,0 +1,13 @@
+import math, random
+
+randomize()
+
+proc pi(nthrows: float): float =
+  var inside = 0.0
+  for i in 1..int64(nthrows):
+    if hypot(rand(1.0), rand(1.0)) < 1:
+      inside += 1
+  result = 4 * inside / nthrows
+
+for n in [10e4, 10e6, 10e7, 10e8]:
+  echo pi(n)

Task/Monte-Carlo-methods/OCaml/monte-carlo-methods.ocaml

@@ -0,0 +1,12 @@
+let get_pi throws =
+  let rec helper i count =
+    if i = throws then count
+    else
+      let rand_x = Random.float 2.0 -. 1.0
+      and rand_y = Random.float 2.0 -. 1.0 in
+      let dist = sqrt (rand_x *. rand_x +. rand_y *. rand_y) in
+      if dist < 1.0 then
+        helper (i+1) (count+1)
+      else
+        helper (i+1) count
+  in float (4 * helper 0 0) /. float throws

Task/Monte-Carlo-methods/Octave/monte-carlo-methods-1.octave

@@ -0,0 +1,16 @@
+function p = montepi(samples)
+  in_circle = 0;
+  for samp = 1:samples
+    v = [ unifrnd(-1,1), unifrnd(-1,1) ];
+    if ( v*v.' <= 1.0 )
+      in_circle++;
+    endif
+  endfor
+  p = 4*in_circle/samples;
+endfunction
+
+l = 1e4;
+while (l < 1e7)
+  disp(montepi(l));
+  l *= 10;
+endwhile

Task/Monte-Carlo-methods/Octave/monte-carlo-methods-2.octave

@@ -0,0 +1,3 @@
+function result = montepi(n)
+  result = sum(rand(1,n).^2+rand(1,n).^2<1)/n*4;
+endfunction

Task/Monte-Carlo-methods/PARI-GP/monte-carlo-methods.parigp

@@ -0,0 +1 @@
+MonteCarloPi(tests)=4.*sum(i=1,tests,norml2([random(1.),random(1.)])<1)/tests;

Task/Monte-Carlo-methods/PHP/monte-carlo-methods.php

@@ -0,0 +1,10 @@
+<?
+$loop = 1000000; # loop to 1,000,000
+$count = 0;
+for ($i=0; $i<$loop; $i++) {
+  $x = rand() / getrandmax();
+  $y = rand() / getrandmax();
+  if(($x*$x) + ($y*$y)<=1) $count++;
+}
+echo "loop=".number_format($loop).", count=".number_format($count).", pi=".($count/$loop*4);
+?>

Task/Monte-Carlo-methods/Pascal/monte-carlo-methods.pas

@@ -0,0 +1,29 @@
+Program MonteCarlo(output);
+
+uses
+  Math;
+
+function MC_Pi(expo: integer): real;
+  var
+    x, y: real;
+    i, hits, samples: longint;
+  begin
+    samples := 10**expo;
+    hits := 0;
+    randomize;
+    for i := 1 to samples do
+    begin
+      x := random;
+      y := random;
+      if sqrt(x*x + y*y) < 1.0 then
+        inc(hits);
+    end;
+    MC_Pi := 4.0 * hits / samples;
+  end;
+
+var
+  i: integer;
+begin
+  for i := 4 to 8 do
+    writeln (10**i, ' samples give ', MC_Pi(i):7:5, ' as pi.');
+end.

Task/Monte-Carlo-methods/Perl/monte-carlo-methods.pl

@@ -0,0 +1,14 @@
+sub pi {
+  my $nthrows = shift;
+  my $inside = 0;
+  foreach (1 .. $nthrows) {
+    my $x = rand() * 2 - 1;
+    my $y = rand() * 2 - 1;
+    if (sqrt($x*$x + $y*$y) < 1) {
+      $inside++;
+    }
+  }
+  return 4 * $inside / $nthrows;
+}
+
+printf "%9d: %07f\n", $_, pi($_) for 10**4, 10**6;

Task/Monte-Carlo-methods/Phix/monte-carlo-methods.phix

@@ -0,0 +1,14 @@
+(phixonline)-->
+ <span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
+ <span style="color: #004080;">integer</span> <span style="color: #000000;">N</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">100</span>
+ <span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">6</span> <span style="color: #008080;">do</span>
+     <span style="color: #004080;">integer</span> <span style="color: #000000;">inside</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span>
+     <span style="color: #008080;">for</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">N</span> <span style="color: #008080;">do</span>
+         <span style="color: #004080;">integer</span> <span style="color: #000000;">x</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">rand</span><span style="color: #0000FF;">(</span><span style="color: #000000;">N</span><span style="color: #0000FF;">),</span>
+                 <span style="color: #000000;">y</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">rand</span><span style="color: #0000FF;">(</span><span style="color: #000000;">N</span><span style="color: #0000FF;">)</span>
+         <span style="color: #000000;">inside</span> <span style="color: #0000FF;">+=</span> <span style="color: #0000FF;">(</span><span style="color: #000000;">x</span><span style="color: #0000FF;">*</span><span style="color: #000000;">x</span><span style="color: #0000FF;">+</span><span style="color: #000000;">y</span><span style="color: #0000FF;">*</span><span style="color: #000000;">y</span><span style="color: #0000FF;"><</span><span style="color: #000000;">N</span><span style="color: #0000FF;">*</span><span style="color: #000000;">N</span><span style="color: #0000FF;">)</span>
+     <span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
+     <span style="color: #7060A8;">pp</span><span style="color: #0000FF;">({</span><span style="color: #000000;">N</span><span style="color: #0000FF;">,</span><span style="color: #000000;">4</span><span style="color: #0000FF;">*</span><span style="color: #000000;">inside</span><span style="color: #0000FF;">/</span><span style="color: #000000;">N</span><span style="color: #0000FF;">})</span>
+     <span style="color: #000000;">N</span> <span style="color: #0000FF;">*=</span> <span style="color: #000000;">10</span>
+ <span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
+<!--

Task/Monte-Carlo-methods/Picat/monte-carlo-methods-1.picat

@@ -0,0 +1,7 @@
+sim1(N, F) = C =>
+  C = 0,
+  I = 0,
+  while (I <= N)
+    C := C + apply(F),
+    I := I + 1
+  end.

Task/Monte-Carlo-methods/Picat/monte-carlo-methods-2.picat

@@ -0,0 +1 @@
+sim2(N, F) = sum([apply(F) : _I in 1..N]).

Task/Monte-Carlo-methods/Picat/monte-carlo-methods-3.picat

@@ -0,0 +1,6 @@
+sim_rec(N,F) = S =>
+  sim_rec(N,N,F,0,S).
+sim_rec(0,_N,_F,S,S).
+sim_rec(C,N,F,S0,S) :-
+  S1 = S0 + apply(F),
+  sim_rec(C-1,N,F,S1,S).

Task/Monte-Carlo-methods/Picat/monte-carlo-methods-4.picat

@@ -0,0 +1,16 @@
+go =>
+   foreach(N in 0..7)
+     sim_pi(10**N)
+   end,
+   nl.
+
+% The specific pi simulation
+sim_pi(N) =>
+  Inside = sim(N,pi_f),
+  MyPi = 4.0*Inside/N,
+  Pi = math.pi,
+  println([n=N, myPi=MyPi, diff=Pi-MyPi]).
+
+% The simulation function:
+%   returns 1 if success, 0 otherwise
+pi_f() = cond(frand()**2 + frand()**2 <= 1, 1, 0).

Task/Monte-Carlo-methods/PicoLisp/monte-carlo-methods.l

@@ -0,0 +1,10 @@
+(de carloPi (Scl)
+   (let (Dim (** 10 Scl)  Dim2 (* Dim Dim)  Pi 0)
+      (do (* 4 Dim)
+         (let (X (rand 0 Dim)  Y (rand 0 Dim))
+            (when (>= Dim2 (+ (* X X) (* Y Y)))
+               (inc 'Pi) ) ) )
+      (format Pi Scl) ) )
+
+(for N 6
+   (prinl (carloPi N)) )

Task/Monte-Carlo-methods/PowerShell/monte-carlo-methods.psh

@@ -0,0 +1,17 @@
+function Get-Pi ($Iterations = 10000) {
+    $InCircle = 0
+    for ($i = 0; $i -lt $Iterations; $i++) {
+        $x = Get-Random 1.0
+        $y = Get-Random 1.0
+        if ([Math]::Sqrt($x * $x + $y * $y) -le 1) {
+            $InCircle++
+        }
+    }
+    $Pi = [decimal] $InCircle / $Iterations * 4
+    $RealPi = [decimal] "3.141592653589793238462643383280"
+    $Diff = [Math]::Abs(($Pi - $RealPi) / $RealPi * 100)
+    New-Object PSObject `
+        | Add-Member -PassThru NoteProperty Iterations $Iterations `
+        | Add-Member -PassThru NoteProperty Pi $Pi `
+        | Add-Member -PassThru NoteProperty "% Difference" $Diff
+}

Task/Monte-Carlo-methods/PureBasic/monte-carlo-methods.basic

@@ -0,0 +1,24 @@
+OpenConsole()
+
+Procedure.d MonteCarloPi(throws.d)
+	inCircle.d = 0
+		For i = 1 To throws.d
+			randX.d = (Random(2147483647)/2147483647)*2-1
+			randY.d = (Random(2147483647)/2147483647)*2-1
+			dist.d  = Sqr(randX.d*randX.d + randY.d*randY.d)
+			If dist.d < 1
+				inCircle = inCircle + 1
+			EndIf
+		Next i
+	pi.d = (4 * inCircle / throws.d)	
+	ProcedureReturn pi.d
+	
+EndProcedure
+
+PrintN ("'built-in' #Pi         = " + StrD(#PI,20))
+PrintN ("MonteCarloPi(10000)    = " + StrD(MonteCarloPi(10000),20))
+PrintN ("MonteCarloPi(100000)   = " + StrD(MonteCarloPi(100000),20))
+PrintN ("MonteCarloPi(1000000)  = " + StrD(MonteCarloPi(1000000),20))
+PrintN ("MonteCarloPi(10000000) = " + StrD(MonteCarloPi(10000000),20))
+
+PrintN("Press any key"): Repeat: Until Inkey() <> ""

Task/Monte-Carlo-methods/Python/monte-carlo-methods-1.py

@@ -0,0 +1,16 @@
+>>> import random, math
+>>> throws = 1000
+>>> 4.0 * sum(math.hypot(*[random.random()*2-1
+	                 for q in [0,1]]) < 1
+              for p in xrange(throws)) / float(throws)
+3.1520000000000001
+>>> throws = 1000000
+>>> 4.0 * sum(math.hypot(*[random.random()*2-1
+	                 for q in [0,1]]) < 1
+              for p in xrange(throws)) / float(throws)
+3.1396359999999999
+>>> throws = 100000000
+>>> 4.0 * sum(math.hypot(*[random.random()*2-1
+	                 for q in [0,1]]) < 1
+              for p in xrange(throws)) / float(throws)
+3.1415666400000002

Task/Monte-Carlo-methods/Python/monte-carlo-methods-2.py

@@ -0,0 +1,17 @@
+from random import random
+from math import hypot
+try:
+    import psyco
+    psyco.full()
+except:
+    pass
+
+def pi(nthrows):
+    inside = 0
+    for i in xrange(nthrows):
+        if hypot(random(), random()) < 1:
+            inside += 1
+    return 4.0 * inside / nthrows
+
+for n in [10**4, 10**6, 10**7, 10**8]:
+    print "%9d: %07f" % (n, pi(n))

Task/Monte-Carlo-methods/Python/monte-carlo-methods-3.py

@@ -0,0 +1,4 @@
+import numpy as np
+
+n = input('Number of samples: ')
+print np.sum(np.random.rand(n)**2+np.random.rand(n)**2<1)/float(n)*4

Task/Monte-Carlo-methods/Quackery/monte-carlo-methods.quackery

@@ -0,0 +1,15 @@
+  [ $ "bigrat.qky" loadfile ] now!
+
+  [ [ 64 bit ] constant
+    dup random dup *
+    over random dup * +
+    swap dup * < ]            is hit    (   --> b )
+
+  [ 0 swap times
+      [ hit if 1+ ] ]         is sims   ( n --> n )
+
+  [ dup echo say " trials "
+    dup sims 4 *
+    swap 20 point$ echo$ cr ] is trials ( n -->   )
+
+' [ 10 100 1000 10000 100000 1000000 ] witheach trials

Task/Monte-Carlo-methods/R/monte-carlo-methods.r

@@ -0,0 +1,27 @@
+# nice but not suitable for big samples!
+monteCarloPi <- function(samples) {
+  x <- runif(samples, -1, 1) # for big samples, you need a lot of memory!
+  y <- runif(samples, -1, 1)
+  l <- sqrt(x*x + y*y)
+  return(4*sum(l<=1)/samples)
+}
+
+# this second function changes the samples number to be
+# multiple of group parameter (default 100).
+monteCarlo2Pi <- function(samples, group=100) {
+  lim <- ceiling(samples/group)
+  olim <- lim
+  c <- 0
+  while(lim > 0) {
+    x <- runif(group, -1, 1)
+    y <- runif(group, -1, 1)
+    l <- sqrt(x*x + y*y)
+    c <- c + sum(l <= 1)
+    lim <- lim - 1
+  }
+  return(4*c/(olim*group))
+}
+
+print(monteCarloPi(1e4))
+print(monteCarloPi(1e5))
+print(monteCarlo2Pi(1e7))

Task/Monte-Carlo-methods/REXX/monte-carlo-methods.rexx

@@ -0,0 +1,34 @@
+/*REXX program computes and displays the value of  pi÷4  using the Monte Carlo algorithm*/
+numeric digits 20                                /*use 20 decimal digits to handle args.*/
+parse arg times chunk digs r? .                  /*does user want a specific number?    */
+if times=='' | times==","  then times=   5e12    /*five trillion should do it, hopefully*/
+if chunk=='' | chunk==","  then chunk= 100000    /*perform Monte Carlo in  100k  chunks.*/
+if digs =='' |  digs==","  then  digs=     99    /*indicates to use length of  PI - 1.  */
+if datatype(r?, 'W')       then call random ,,r? /*Is there a random seed?  Then use it.*/
+                                                 /* [↓]  pi meant to line─up with a SAY.*/
+           pi= 3.141592653589793238462643383279502884197169399375105820974944592307816406
+pi= strip( left(pi, digs + length(.) ) )         /*obtain length of pi to what's wanted.*/
+numeric digits length(pi) - 1                    /*define decimal digits as length PI -1*/
+say '                    1         2         3         4         5         6         7   '
+say 'scale:    1·234567890123456789012345678901234567890123456789012345678901234567890123'
+say                                              /* [↑]  a two─line scale for showing pi*/
+say 'true pi= '       pi"+"                      /*we might as well brag about true  pi.*/
+say                                              /*display a blank line for separation. */
+limit   = 10000 - 1                              /*REXX random generates only integers. */
+limitSq = limit **2                              /*··· so, instead of one, use limit**2.*/
+accuracy= 0                                      /*accuracy of Monte Carlo pi  (so far).*/
+@reps= 'repetitions:  Monte Carlo  pi  is'       /*a handy─dandy short literal for a SAY*/
+!= 0                                             /*!:  is the accuracy of pi  (so far). */
+       do j=1  for times % chunk
+                     do chunk                    /*do Monte Carlo, one chunk at─a─time. */
+                     if random(, limit)**2 + random(, limit)**2 <= limitSq   then != ! + 1
+                     end   /*chunk*/
+       reps= chunk * j                           /*calculate the number of repetitions. */
+       _= compare(4*! / reps, pi)                /*compare apples and  ···  crabapples. */
+       if _<=accuracy  then iterate              /*Not better accuracy?  Keep truckin'. */
+       say right(commas(reps), 20) @reps  'accurate to'  _-1  "places."  /*─1≡dec. point*/
+       accuracy= _                               /*use this accuracy for next baseline. */
+       end   /*j*/
+exit 0                                           /*stick a fork in it,  we're all done. */
+/*──────────────────────────────────────────────────────────────────────────────────────*/
+commas: procedure; arg _; do k=length(_)-3  to 1  by -3; _=insert(',',_,k); end;  return _

Task/Monte-Carlo-methods/Racket/monte-carlo-methods-1.rkt

@@ -0,0 +1,32 @@
+#lang racket
+
+(define (in-unit-circle? x y) (<= (sqrt (+ (sqr x) (sqr y))) 1))
+;; point in ([-1,1], [-1,1])
+(define (random-point-in-2x2-square) (values (* 2 (- (random) 1/2)) (* 2 (- (random) 1/2))))
+
+;; Area of circle is (pi r^2). r is 1, area of circle is pi
+;; Area of square is 2^2 = 4
+;; There is a pi/4 chance of landing in circle
+;; .: pi = 4*(proportion passed) = 4*(passed/samples)
+(define (passed:samples->pi passed samples) (* 4 (/ passed samples)))
+
+;; generic kind of monte-carlo simulation
+(define (monte-carlo run-length report-frequency
+                     sample-generator pass?
+                     interpret-result)
+  (let inner ((samples 0) (passed 0) (cnt report-frequency))
+    (cond
+      [(= samples run-length) (interpret-result passed samples)]
+      [(zero? cnt) ; intermediate report
+       (printf "~a samples of ~a: ~a passed -> ~a~%"
+               samples run-length passed (interpret-result passed samples))
+       (inner samples passed report-frequency)]
+      [else
+       (inner (add1 samples)
+              (if (call-with-values sample-generator pass?)
+                  (add1 passed) passed) (sub1 cnt))])))
+
+;; (monte-carlo ...) gives an "exact" result... which will be a fraction.
+;; to see how it looks as a decimal we can exact->inexact it
+(let ((mc (monte-carlo 10000000 1000000 random-point-in-2x2-square in-unit-circle? passed:samples->pi)))
+  (printf "exact = ~a~%inexact = ~a~%(pi - guess) = ~a~%" mc (exact->inexact mc) (- pi mc)))

Task/Monte-Carlo-methods/Racket/monte-carlo-methods-2.rkt

@@ -0,0 +1,28 @@
+#lang racket
+(define (in-unit-circle? x y) (<= (sqrt (+ (sqr x) (sqr y))) 1))
+;; Good idea made in another task that:
+;;  The proportions of hits is the same in the unit square and 1/4 of a circle.
+;; point in ([0,1], [0,1])
+(define (random-point-in-unit-square) (values (random) (random)))
+;; generic kind of monte-carlo simulation
+;; Area of circle is (pi r^2). r is 1, area of circle is pi
+;; Area of square is 2^2 = 4
+;; There is a pi/4 chance of landing in circle
+;; .: pi = 4*(proportion passed) = 4*(passed/samples)
+(define (passed:samples->pi passed samples) (* 4 (/ passed samples)))
+
+(define (monte-carlo/2 run-length report-frequency sample-generator pass? interpret-result)
+  (interpret-result
+   (for/fold ((pass 0))
+     ([n (in-range run-length)]
+      #:when (when (and (not (zero? n)) (zero? (modulo n report-frequency)))
+               (printf "~a samples of ~a: ~a passed -> ~a~%"
+                       n run-length pass (interpret-result pass n)))
+      #:when (call-with-values sample-generator pass?))
+     (add1 pass))
+   run-length))
+
+;; (monte-carlo ...) gives an "exact" result... which will be a fraction.
+;; to see how it looks as a decimal we can exact->inexact it
+(let ((mc (monte-carlo/2 10000000 1000000 random-point-in-unit-square in-unit-circle? passed:samples->pi)))
+  (printf "exact = ~a~%inexact = ~a~%(pi - guess) = ~a~%" mc (exact->inexact mc) (- pi mc)))

Task/Monte-Carlo-methods/Raku/monte-carlo-methods-1.raku

@@ -0,0 +1,9 @@
+my @random_distances = ([+] rand**2 xx 2) xx *;
+
+sub approximate_pi(Int $n) {
+    4 * @random_distances[^$n].grep(* < 1) / $n
+}
+
+say "Monte-Carlo π approximation:";
+say "$_ iterations:  ", approximate_pi $_
+    for 100, 1_000, 10_000;

Task/Monte-Carlo-methods/Raku/monte-carlo-methods-2.raku

@@ -0,0 +1,2 @@
+my @pi = ([\+] 4 * (1 > [+] rand**2 xx 2) xx *) Z/ 1 .. *;
+say @pi[10, 1000, 10_000];