Monte Carlo methods: Difference between revisions

 

 

 

=={{header|Ada}}==

with Ada.Numerics.Float_Random; use Ada.Numerics.Float_Random;

 

Put_Line (" 10_000_000:" & Float'Image (Pi ( 10_000_000)));

Put_Line ("100_000_000:" & Float'Image (Pi (100_000_000)));

<pre>

10_000: 3.13920E+00

 

{{works with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release 1.8.8d.fc9.i386}}

BEGIN

INT inside := 0;

print ((" 1 000 000:",pi ( 1 000 000),new line));

print ((" 10 000 000:",pi ( 10 000 000),new line));

<pre>

10 000:+3.15480000000000e +0

</pre>

 

{{AutoHotkey case}}

Source: [http://www.autohotkey.com/forum/topic44657.html AutoHotkey forum] by Laszlo

MsgBox % MontePi(10000) ; 3.154400

MsgBox % MontePi(100000) ; 3.142040

Return 4*p/n

}

 

=={{header|BASIC}}==

{{works with|QuickBasic|4.5}}

{{trans|Java}}

CLS

PRINT getPi(10000)

NEXT i

getPi = 4! * inCircle / throws

<pre>

3.16

</pre>

 

 

#include <stdlib.h>

#include <math.h>

{

 

}

 

int main()

{

 

=={{header|C sharp|C#}}==

 

class Program {

}

}

 

<pre>

10,000:3.1436

100,000,000:3.1413976

</pre>

 

=={{header|Clojure}}==

(loop [x (rand) y (rand) in 0 total 1]

(if (< total iterations)

(double (* (/ in total) 4)))))

 

 

100: 3.2

1000: 3.124

100000: 3.14104

1000000: 3.141064

 

=={{header|Common Lisp}}==

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

 

<pre>

1000 -> 3.132

1000000 -> 3.142072

10000000 -> 3.1420677

</pre>

 

=={{header|D}}==

 

inside++;

return 4.0 * inside / nthrows;

 

void main() {

 

<pre>

 

=={{header|E}}==

This computes a single quadrant of the described square and circle; the effect should be the same since the other three are symmetric.

 

var inside := 0

for _ ? (entropy.nextFloat() ** 2 + entropy.nextFloat() ** 2 < 1) in 1..n {

}

return inside * 4 / n

 

Some sample runs:

? pi(100000)

# value: 3.13848

 

=={{header|Factor}}==

Since Factor lets the user choose the range of the random generator, we use 2^32.

 

 

: limit ( -- n ) 2 32 ^ ; inline

: in-circle ( x y -- ? ) limit [ sq ] tri@ [ + ] [ <= ] bi* ;

: rand ( -- r ) limit random ;

 

Example use:

 

 

=={{header|Forth}}==

=={{header|Fortran}}==

{{works with|Fortran|90 and later}}

IMPLICIT NONE

END DO

 

10000 3.12120

100000 3.13772

10000000 3.14114

100000000 3.14147

 

=={{header|Haskell}}==

import System.Random

 

where

Prelude System.Random Control.Monad> get_pi 10000

3.1352

3.15184

Prelude System.Random Control.Monad> get_pi 1000000

 

=={{header|J}}==

'''Explicit Solution:'''

 

'''Tacit Solution:'''

 

'''Examples:'''

3.1426

piMC 10^i.7

 

=={{header|Java}}==

public static void main(String[] args) {

System.out.println(getPi(10000));

//distance from (0,0) = sqrt((x-0)^2+(y-0)^2)

double dist= Math.sqrt(randX * randX + randY * randY);

if(dist < 1){//circle with diameter of 2 has radius of 1

inCircle++;

return 4.0 * inCircle / numThrows;

}

3.1396

3.14256

3.1418692

3.14168604

 

=={{header|Logo}}==

to square :n

output :n * :n

show sim 100000 10000 ; 3.145

show sim 1000000 10000 ; 3.140828

 

We define a function with variable sample size:

Example (samplesize=10,100,1000,....10000000):

gives back:

100 3.16

1000 3.152

100000 3.14872

1000000 3.1408

 

=={{header|MAXScript}}==

)

</pre>

 

=={{header|OCaml}}==

let rec helper i count =

if i = throws then count

else

helper (i+1) count

Example:

# get_pi 10000;;

=={{header|Octave}}==

 

in_circle = 0;

for samp = 1:samples

disp(montepi(l));

l *= 10;

 

Since it runs slow, I've stopped it at the second iteration, obtaining:

3.1496</pre>

 

 

 

my $nthrows = shift;

my $inside = 0;

foreach (1 .. $nthrows) {

if (sqrt($x*$x + $y*$y) < 1) {

$inside++;

}

 

 

 

}

 

 

=={{header|PowerShell}}==

{{works with|PowerShell|2}}

$InCircle = 0

for ($i = 0; $i -lt $Iterations; $i++) {

| Add-Member -PassThru NoteProperty Pi $Pi `

| Add-Member -PassThru NoteProperty "% Difference" $Diff

This returns a custom object with appropriate properties which automatically enables a nice tabular display:

<pre>PS Home:\> 10,100,1e3,1e4,1e5,1e6 | ForEach-Object { Get-Pi $_ }

100000 3,14712 0,1759409006731298209938938800

1000000 3,141364 0,0072782698142600895432451100</pre>

 

=={{header|Python}}==

 

One use of the "sum" function is to count how many times something is true (because True = 1, False = 0):

>>> throws = 1000

>>> 4.0 * sum(math.hypot(*[random.random()*2-1

for q in [0,1]]) < 1

for p in xrange(throws)) / float(throws)

 

===As a program using a function===

from random import random

from math import hypot

for n in [10**4, 10**6, 10**7, 10**8]:

print "%9d: %07f" % (n, pi(n))

 

=={{header|R}}==

monteCarloPi <- function(samples) {

x <- runif(samples, -1, 1) # for big samples, you need a lot of memory!

print(monteCarloPi(1e4))

print(monteCarloPi(1e5))

 

=={{header|Ruby}}==

end

 

[1000, 10_000, 100_000, 1_000_000, 10_000_000].each do |n|

<pre> 1000 samples: PI = 3.2

10000 samples: PI = 3.14

1000000 samples: PI = 3.145124

10000000 samples: PI = 3.1414788</pre>

 

=={{header|Tcl}}==

set i 0

set inside 0

foreach runs {1e2 1e4 1e6 1e8} {

puts "$runs => [pi $runs]"

result

<pre>PI is approx 3.141592653589793

1e6 => 3.141924

1e8 => 3.14167724</pre>