Percolation/Site percolation: Difference between revisions

 

Show all output on this page.

 

=={{header|C}}==

#include <stdlib.h>

#include <string.h>

 

return 0;

{{out}}

<pre>

</pre>

{{trans|D}}

#include <stdlib.h>

#include <time.h>

return 0;

}

{{out}}

<pre>Percolating sample (15x15, probability = 0.40):

0.9 1.000

1.0 1.000</pre>

 

=={{header|D}}==

{{trans|Python}}

 

enum size_t nCols = 15,

writefln("\nSimulations and grid printing performed" ~

" in %3.2f seconds.", sw.peek.msecs / 1000.0);

{{out}}

<pre>Percolating sample (15x15, probability = 0.40):

 

=={{header|Factor}}==

fry generalizations io kernel math math.matrices math.order

math.ranges math.vectors prettyprint random sequences ;

] each ;

 

{{out}}

<pre>

 

Please see sample compilation and program execution in comments at top of program. Thank you. This example demonstrates recursion and integer constants of a specific kind.

! loosely translated from python.

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

 

end program percolation_site

 

=={{header|Go}}==

 

import (

g.use(x-1, y) ||

g.use(x, y-1)

{{out}}

<pre>+---------------+

p=1.00, 1.0000

</pre>

=={{header|Haskell}}==

import Control.Monad

import Control.Monad.Random

let v = fromIntegral density / fromIntegral densityCount ]

results = zip densities (evalRand tests g2)

 

{{out}}

"p=10/10 -> 1.0000"

</pre>

=={{header|J}}==

 

One approach:

 

ooze=: [ >. [ +&* [ * [: ; groups@[ <@(* * 2 < >./)/. +

percolate=: ooze/\.@|.^:2^:_@(* (1 + # {. 1:))

 

trial=: percolate@([ >: ]?@$0:)

 

Example Statistics:

┌────────┐

│ P THRU│

│0.9 1│

│ 1 1│

 

Worked sample:

 

# # # # # # # #

# # # # # # # # # # # #

. . . # . # # #

. . . . . . . # # .

 

An [[Percolation/Site_percolation/J|explanation with examples]] would be somewhat longer than the implementation.

Alternative implementation (with an incompatible internal API):

 

any =: +./

all =: *./

 

simulate =: 100&$: : ([ %~ [: +/ [: percolate"0 #) NB. return fraction of connected cases. Use: T simulate P

 

<pre>

· · · · · · · · · ·

· · · · · · · · · · · ·

</pre>

 

=={{header|Julia}}==

{{trans|Python}}

 

newgrid(p::Float64, M::Int=15, N::Int=15) = rand(Bernoulli(p), M, N)

for (pi, fi) in zip(p, f)

@printf("p = %.1f ⇛ f = %.3f\n", pi, fi)

 

{{out}}

=={{header|Kotlin}}==

{{trans|C}}

 

import java.util.Random

println("p = %.1f: %.4f".format(p, cnt / 10000.0))

}

 

Sample output:

p = 1.0: 1.0000

</pre>

 

=={{header|Perl}}==

my $water = '+';

my $pore = ' ';

}

 

{{out}}

<pre>Sample percolation at 0.65

p = 0.9: 1.00

p = 1.0: 1.00</pre>

 

=={{header|Phix}}==

{{trans|C}}

{{out}}

<pre>

 

=={{header|Python}}==

import string

from pprint import pprint as pp

print('\n p: Fraction of %i tries that percolate through\n' % t )

 

{{out}}

 

=={{header|Racket}}==

(require racket/require (only-in racket/fixnum for*/fxvector))

(require (filtered-in (lambda (name) (regexp-replace #rx"unsafe-" name ""))

((i (in-range (t))) #:when (perc-15x15-grid?! (make-15x15-grid p))) 1))

(define proportion-percolated (/ n-percolated-grids (t)))

 

{{out}}

p=9/10 -> 1.0000

p=1 -> 1.0000</pre>

 

=={{header|Sidef}}==

 

has block = '▒'

for p in (0.1..1 `by` 0.1) {

printf("p = %0.1f: %0.3f\n", p, tests.of { obj.percolate(p) }.sum / tests)

{{out}}

<pre>

=={{header|Tcl}}==

{{works with|Tcl|8.6}}

 

oo::class create SitePercolation {

puts [format "p=%.2f: %2.1f%%" $p [expr {$tot*100./$tries}]]

}

{{out}}

<pre>

p=0.90: 100.0%

p=1.00: 100.0%

</pre>

 

=={{header|zkl}}==

{{trans|C}}

grid:=Data((m+1)*(n+1)); // first row and right edges are buffers

grid.write(" "*m); grid.write("\r");

cnt:=0.0; do(10000){ cnt+=percolate(makeGrid(15,15,p),15); }

"p=%.1f: %.4f".fmt(p, cnt/10000).println();

{{out}}

<pre>