Percolation/Site percolation: Difference between revisions

{{trans|Python}}

F nonrandom()

:seed = 1664525 * :seed + 1013904223

L(p, c) sorted(pcount.items())

{{out}}

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

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

{{trans|Phix}}

#define EMPTY " "

#define WET "v"

Print Using "p=#.#: #.####"; p; cont/10000

Next ip

=={{header|Go}}==

import (

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

g.use(x, y-1)

{{out}}

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

=={{header|Haskell}}==

import Control.Monad

import Control.Monad.Random

let v = fromIntegral density / fromIntegral densityCount ]

results = zip densities (evalRand tests g2)

{{out}}

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>

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

=={{header|Nim}}==

{{trans|Go}}

type Grid = seq[string] # Row first, i.e. [y][x].

if grid.percolate(): inc count

echo &"p = {p:.2f}: {count / T:.4f}"

{{out}}

=={{header|Perl}}==

{{trans|Raku}}

my $water = '+';

my $pore = ' ';

}

{{out}}

<pre>Sample percolation at 0.65

=={{header|Phix}}==

{{trans|C}}

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

<span style="color: #004080;">string</span> <span style="color: #000000;">grid</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}}==

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

{{works with|Rakudo|2017.02}}

my $water = '+';

my $pore = ' ';

[$x, $y]

}

{{out}}

<pre>Sample percolation at .6

=={{header|Sidef}}==

{{trans|Raku}}

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>

{{trans|Kotlin}}

{{libheader|Wren-fmt}}

import "/fmt" for Fmt

}

Fmt.print("p = $.1f: $.4f", p, cnt / 10000)

{{out}}

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