Percolation/Mean cluster density: Difference between revisions

{{trans|Nim}}

F nonrandom()

:seed = 1664525 * :seed + 1013904223

sum += clusterDensity(n, pp)

V sim = sum / tt

{{out}}

=={{header|C}}==

#include <stdlib.h>

free(map);

return 0;

{{out}}

<pre>

=={{header|D}}==

{{trans|python}}

std.range, std.ascii;

nIters, prob, side, density);

}

{{out}}

<pre>Found 26 clusters in this 15 by 15 grid:

=={{header|EchoLisp}}==

We use the canvas bit-map as 2D-matrix. For extra-extra credit, a 800x800 nice cluster tapestry image is shown here : http://www.echolalie.org/echolisp/images/rosetta-clusters-800.png.

(define-constant BLACK (rgb 0 0 0.6))

(define-constant WHITE -1)

(writeln 'n n 'Cn Cn 'density (// Cn (* n n) 5) )

(vector->pixels C)) ;; to screen

{{out}}

<pre>

=={{header|Factor}}==

math.matrices random sequences ;

IN: rosetta-code.mean-cluster-density

] each ;

{{out}}

<pre>

=={{header|Go}}==

{{trans|Python}}

import (

fmt.Printf("t=%3d p=%4.2f n=%5d sim=%7.5f\n", t, p, n, sim)

}

{{out}}

<pre>

=={{header|Haskell}}==

import Data.List

import Data.Maybe

main = newStdGen >>= mapM_ (uncurry (printf "%d\t%.5f\n")) . res

where

<pre>λ> newStdGen >>= putStrLn . showClusters . randomMatrix 15

Once we have this, we can identify clusters by propagating information in a single direction through the matrix using this operation, rotating the matrix 90 degrees, and then repeating this combination of operations four times. And, finally, by keeping at this until there's nothing more to be done.

Example:

M

1 0 0 0 0 0

71 71 0 0 0 0

0 0 0 149 0 113

We did not have to use primes there - any mechanism for assigning distinct positive integers to the 1s would work. And, in fact, it might be nice if - once we found our clusters - we assigned the smallest distinct positive integers to the clusters. This would allow us to use simple indexing to map the array to characters.

Example use:

1 0 0 0 0 0

0 0 0 2 0 0

CC....

...D.E

Now we just need a measure of cluster density. Formally cluster density seems to be defined as the number of clusters divided by the total number of elements of the matrix. Thus:

Example use:

So we can create a word that performs a simulation experiment, given a probability getting a 1 and the number of rows (and columns) of our square matrix M.

Example use:

0.1666667

0.4 experiment 6

The task wants us to perform at least five trials for sizes up to 1000 by 1000 with probability of 1 being 0.5:

Example use:

0.1111111 0.1111111 0.2222222 0.1111111 0.1111111 0.3333333

6 trials 10

0.06563333 0.06663333 0.06713333 0.06727778 0.06658889 0.06664444

6 trials 1000

Now for averages (these are different trials from the above):

mean 8 trials 3

0.1805556

0.06749861

mean 8 trials 1000

Finally, for the extra credit (thru taken from the [[Loops/Downward_for#J|Loops/Downward for]] task):

A.......B..C...

AAAA...D..E.F..

..AA..A.A...AAA

.M.A.AA.AA..AA.

'''Collected definitions'''

idclust=: $ $ [: (~. i.])&.(0&,)@,@congeal ] * 1 + i.@$

mean=:+/ % #

'''Extra Credit'''

M

0 2 3 4 0 6 0 8 0 10 11 12 0 0 15

16 16 16 0 0 17 0 15 15 15 15 15 0 15 15

16 16 16 0 17 17 17 0 0 15 0 15 0 0 0

=={{header|Julia}}==

{{trans|Python}}

newgrid(p::Float64, r::Int, c::Int=r) = rand(Bernoulli(p), r, c)

sim = mean(clusterdensity(p, n) for _ in 1:nrep)

@printf("nrep = %2i p = %.2f dim = %-13s sim = %.5f\n", nrep, p, "$n × $n", sim)

{{out}}

=={{header|Kotlin}}==

{{trans|C}}

import java.util.Random

w = w shl 1

}

Sample output:

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

In[1]:= Table[N[Max@MorphologicalComponents[

RandomVariate[BernoulliDistribution[.5], {n, n}],

(*Show a 15x15 matrix with each cluster given an incrementally higher number, Colorize instead of MatrixForm creates an image*)

=={{header|Nim}}==

{{trans|Go}}

const

sum += clusterDensity(n, P)

let sim = sum / T

{{out}}

=={{header|Perl}}==

{{trans|Raku}}

$D{$_} = $i++ for qw<DeadEnd Up Right Down Left>;

$total += perctest($N) for 1..$trials;

printf "𝘱 = 0.5, trials = $trials, 𝘕 = %4d, 𝘒 = %.4f\n", $N, $total / $trials;

{{out}}

<pre> 1 1 1 . . . . 2 2 2 . . . . .

=={{header|Phix}}==

{{trans|C}}

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

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

from random import random

import string

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

print('t=%3i p=%4.2f n=%5i sim=%7.5f'

{{out}}

=={{header|Racket}}==

(require srfi/14) ; character sets

(define grd (build-random-grid 1/2 1000 1000))

(/ (for/sum ((g (in-fxvector grd)) #:when (zero? g)) 1) (fxvector-length grd))

{{out}}

{{works with|Rakudo|2017.02}}

my $fill = 'x';

}

}

{{out}}

<pre>. . 1 . 2 . . 3 . . . 4 . . .

Note that the queue (variables <code>q</code> and <code>k</code>) used to remember where to find cells when flood-filling the cluster is maintained as a list ''segment''; the front of the list is not trimmed for performance reasons. (This would matter with very long queues, in which case the queue could be shortened occasionally; ''frequent'' trimming is still slower though, because Tcl backs its “list” datatype with arrays and not linked lists.)

{{works with|Tcl|8.6}}

proc determineClusters {w h p} {

}

puts "n=$n, K(p)=[expr {$tot/5.0/$n**2}]"

{{out}}

<pre>

{{trans|Kotlin}}

{{libheader|Wren-fmt}}

import "/fmt" for Fmt

Fmt.print("$5d $9.6f", w, t)

w = w << 1

{{out}}

=={{header|zkl}}==

{{trans|C}}

var C,N,NN,P;

fcn createC(n,p){

foreach z in (n){ createC(N,p); k+=countClusters().toFloat()/NN; }

k/n

println("width=%d, p=%.1f, %d clusters:".fmt(N,P,countClusters()));

showCluster();

println("p=0.5, 5 iterations:");

{{out}}

<pre>