Percolation/Bond percolation: Difference between revisions

{{trans|Python}}

 

F nonrandom()

:seed = 1664525 * :seed + 1013904223

flood_fill(m, n + 1, &cell, hwall, vwall)

E I n == :nn - 1 & !hwall[n + 1][m]

I m & !vwall[n][m] & !cell[n][m - 1]

flood_fill(m - 1, n, &cell, hwall, vwall)

 

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

 

{{out}}

 

=={{header|C}}==

#include <stdlib.h>

#include <string.h>

free(start);

return 0;

{{out}}

<pre>

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

{{trans|D}}

#include <cstring>

#include <iostream>

 

return EXIT_SUCCESS;

 

=={{header|D}}==

{{trans|C}}

 

struct Grid {

probability, nPercolated / double(nTries));

}

{{out}}

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

=={{header|Go}}==

{{trans|C}}<!-- sort of ended up like the C version, not an actual translation -->

 

import (

}

return false

{{out}}

<pre>

 

=={{header|Haskell}}==

import Control.Monad

import Control.Monad.Random

let v = fromIntegral density / fromIntegral densityCount ]

let results = zip densities (evalRand tests g2)

 

{{out}}

"p=9/10 -> 0.0000"

"p=10/10 -> 0.0000"

</pre>

 

=={{header|Julia}}==

{{trans|Python}}

 

struct Grid

for (pr, pp) in zip(probs, percprobs)

@printf("\tp = %.3f ⇒ freq. = %5.3f\n", pr, pp)

 

{{out}}

=={{header|Kotlin}}==

{{trans|C}}

 

import java.util.Random

println("p = %3g: %.4f".format(pp, cnt.toDouble() / 10_000))

}

 

Sample output:

=={{header|Nim}}==

{{trans|Go}}

 

type

if grid.percolate(): inc count

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

 

{{out}}

=={{header|Perl}}==

{{trans|Raku}}

my $grid = 10;

my $water = '▒';

$total += percolate($p) for 1..$tests;

printf "p = %0.1f: %0.2f\n", $p, $total / $tests

{{out}}

<pre>Sample percolation at .6

 

=={{header|Phix}}==

{{out}}

<pre>

 

=={{header|Python}}==

from random import random

from pprint import pprint as pp

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

 

{{out}}

=={{header|Racket}}==

 

 

(define has-left-wall? (lambda (x) (bitwise-bit-set? x 0)))

(make/display/flood/display-bonded-grid 10 10 .25 20)

(make/display/flood/display-bonded-grid 10 10 .50 20)

 

{{out}}

Starts "filling" from the top left. Fluid flow favours directions in Down, Left, Right, Up order. I interpreted p to be porosity, so small p mean low permeability, large p means high permeability.

 

my $grid = 10;

my $geom = $grid - 1;

sub h () { rand < $prob ?? $sp !! '───' }

sub v () { rand < $prob ?? ' ' !! '│' }

{{out}}

<pre>Sample percolation at .6

{{trans|C}}

 

let filled = 1

let rightWall = 2

 

print("p = \(porosity): \(Double(count) / 10_000.0)")

 

{{out}}

{{works with|Tcl|8.6}}

{{trans|Python}}

 

# Structure the bond percolation system as a class

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

}

{{out}}

<pre>

{{trans|Kotlin}}

{{libheader|Wren-fmt}}

 

var rand = Random.new()

}

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

 

{{out}}

=={{header|zkl}}==

{{trans|C}}

const FILLED=1; // and odd

const RWALL =2; // right wall

i:=0; while(i<m and not fill(grid,i+m,m)){ i+=1; } // pour juice on top row

return(i<m); // percolated through the grid?

println("Did liquid percolate: ",percolate(grid,10)); show(grid,10,10);

 

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

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

{{out}}

<pre>