Percolation/Mean run density: Difference between revisions

;See also

* [http://mathworld.wolfram.com/s-Run.html s-Run] on Wolfram mathworld.

 

=={{header|C}}==

#include <stdlib.h>

 

 

return 0;

{{out}}

<pre>

0.9 100000 0.0900 0.0900 +0.0000 (+0.03%)

</pre>

=={{header|C++}}==

#include <random>

#include <vector>

}

return 0 ;

{{out}}

<pre>t = 100

=={{header|D}}==

{{trans|python}}

 

enum n = 100, p = 0.5, t = 500;

}

}

{{out}}

<pre>t=500, p=0.10, n= 1024, p(1-p)=0.09000, sim=0.08949, delta=0.6%

t=500, p=0.90, n= 4096, p(1-p)=0.09000, sim=0.09047, delta=0.5%

t=500, p=0.90, n=16384, p(1-p)=0.09000, sim=0.09007, delta=0.1%</pre>

 

=={{header|EchoLisp}}==

;; count 1-runs - The vector is not stored

(define (runs p n)

(for ([n '(10 100 1000)])

(printf "\t-- n %5d → %d" n (truns p n)))))

{{out}}

<pre>

-- n 100 → 0.0894

-- n 1000 → 0.0905

</pre>

 

=={{header|Fortran}}==

! loosely translated from python. We do not need to generate and store the entire vector at once.

! compilation: gfortran -Wall -std=f2008 -o thisfile thisfile.f08

 

end program percolation_mean_run_density

 

<pre>

500 0.90 16384 0.090 0.090 0.1

</pre>

 

=={{header|Go}}==

 

import (

}

}

{{out}}

<pre>

 

=={{header|Haskell}}==

import Control.Applicative

import Text.Printf

x <- newStdGen

forM_ [0.1,0.3,0.5,0.7,0.9] $ printKs x

<pre>./percolation

p= 0.1, K(p)= 0.090

The following works in both languages:

 

t := integer(A[2]) | 500

 

write(left(p,8)," ",left(n,8)," ",left(p*(1-p),10)," ",left(Ka/t, 10))

}

 

Output:

 

=={{header|J}}==

NB. translation of python

EMPTY

)

Session:

<pre>

500 0.90 4096 0.090 0.090 0.1

500 0.90 16384 0.090 0.090 0.1

</pre>

 

=={{header|Julia}}==

{{trans|Python}}

 

newv(n::Int, p::Float64) = rand(Bernoulli(p), n)

nrep, p, n, lim, sim, lim > 0 ? abs(sim - lim) / lim * 100 : sim * 100)

end

 

{{out}}

=={{header|Kotlin}}==

{{trans|C}}

 

import java.util.Random

println()

}

 

Sample output:

</pre>

 

Mean[Length[Cases[Split@#, {1, ___}]] & /@

Unitize[Chop[RandomReal[1, {trials, len}], 1 - p]]]/len

Table[{q, n, x = meanRunDensity[q, n, 100] // N,

q (1 - q) - x}, {n, {100, 1000, 10000, 100000}}], {}],

{{out}}

<pre>

0.9 100000 0.0900 -0.0000144

</pre>

 

=={{header|Pascal}}==

{{trans|C}}{{works with|Free Pascal}}

{$MODE objFPC}//for using result,parameter runs becomes for variable..

uses

ip := ip+2;

end;

Output

<pre>running 1000 tests each:

 

=={{header|Perl}}==

my ($n, $p) = @_;

my $r = join '',

printf " R(n, p)= %f\n", $r / t;

}

{{out}}

<pre>t= 100

R(n, p)= 0.096200

R(n, p)= 0.091730</pre>

 

=={{header|Phix}}==

{{trans|zkl}}

{{out}}

<pre>

0.9 10000 0.0901 0.0900 +0.0001 (+0.11%)

0.9 100000 0.0900 0.0900 +0.0000 (+0.03%)

 

=={{header|Python}}==

from random import random

from math import fsum

sim = fsum(mean_run_density(n, p) for i in range(t)) / t

print('t=%3i p=%4.2f n=%5i p(1-p)=%5.3f sim=%5.3f delta=%3.1f%%'

 

{{out}}

=={{header|Racket}}==

 

(require racket/fixnum)

(define t (make-parameter 100))

(module+ test

(require rackunit)

{{out}}

<pre>

 

</pre>

 

=={{header|Sidef}}==

n.of { 1.rand < p ? 1 : 0}.sum;

}

printf (" R(n, p)= %f\n", t.of { R(n, p) }.sum/n / t);

}

 

{{out}}

 

=={{header|Tcl}}==

for {set s ""} {[string length $s] < $length} {} {

append s [expr {rand() < $probability}]

}

puts ""

{{out}}

<pre>

t=500, p=0.90, n= 4096, p(1-p)=0.090, sim=0.090, delta=0.08%

t=500, p=0.90, n=16384, p(1-p)=0.090, sim=0.090, delta=0.09%

</pre>

 

=={{header|zkl}}==

{{trans|C}}

cnt:=0; do(runs){

pv:=0; do(len){

}

return(cnt.toFloat() / runs / len);

" p\t n\tK\tp(1-p)\t diff\n"

"-----------------------------------------------");

}

println();

{{out}}

<pre>