Percolation/Mean run density: Difference between revisions

{{trans|Python}}

 

F nonrandom()

:seed = 1664525 * :seed + 1013904223

 

F runs(v)

 

F mean_run_density(n, p)

V sim = sum((0 .< t).map(i -> mean_run_density(@n, :p))) / t

print(‘t=#3 p=#.2 n=#5 p(1-p)=#.3 sim=#.3 delta=#.1%’.format(

 

{{out}}

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

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

</pre>

 

=={{header|C}}==

#include <stdlib.h>

 

 

return 0;

{{out}}

<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>

 

=={{header|Factor}}==

random sequences ;

IN: rosetta-code.mean-run-density

: main ( -- ) header .1 .9 .2 <range> [ test ] each ;

 

{{out}}

<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>

=={{header|FreeBASIC}}==

{{trans|Phix}}

Dim As Integer r, l, cont = 0

Dim As Integer v, pv

Print

Next ip

<pre>Same as Phix, C, Kotlin, Wren, Pascal or zkl entry.</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:

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

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>

=={{header|Nim}}==

{{trans|Go}}

 

const T = 100

 

let k = sum / (T * n)

 

{{out}}

=={{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}}==

{{trans|Raku}}

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

my $r = join '',

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

}

{{out}}

<pre>t= 100

=={{header|Phix}}==

{{trans|zkl}}

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">function</span> <span style="color: #000000;">run_test</span><span style="color: #0000FF;">(</span><span style="color: #004080;">atom</span> <span style="color: #000000;">p</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">integer</span> <span style="color: #000000;">len</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">runs</span><span style="color: #0000FF;">)</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>

<span style="color: #000000;">main</span><span style="color: #0000FF;">()</span>

{{out}}

<pre>

 

=={{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>

=={{header|REXX}}==

{{trans|Fortran}}

Numeric Digits 20

Call random(,12345) /* make the run reproducable */

Say format(n,10)' ' format(sim,2,4)' 'format(sim-theory,2,6)

End

{{out}}

<pre>p: 0.1000 theory: 0.0900 t: 100

=={{header|Raku}}==

(formerly Perl 6)

 

say 't= ', constant t = 100;

printf " R(%6d, p)= %f\n", $n, t R/ [+] R($n, $p)/$n xx t

}

{{out}}

<pre>t= 100

=={{header|Sidef}}==

{{trans|Raku}}

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>

{{trans|Kotlin}}

{{libheader|Wren-fmt}}

 

var rand = Random.new()

}

System.print()

 

{{out}}

=={{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>