Abelian sandpile model: Difference between revisions

<br>

Implement the '''Abelian sandpile model''' also known as '''Bak–Tang–Wiesenfeld model'''. Its history, mathematical definition and properties can be found under its [https://en.wikipedia.org/wiki/Abelian_sandpile_model wikipedia article].

0 0 0 0 0 0 0 1 0 0

</pre>

 

=={{header|C}}==

Writes out the initial and final sand piles to the console and the final sand pile to a PPM file.

#include<stdlib.h>

#include<string.h>

return 0;

}

 

Console output :

<!-- c++ bindings -->

<br>

#include "xtensor/xarray.hpp"

#include "xtensor/xio.hpp"

 

return 0;

project(abelian_sandpile)

 

 

target_compile_options(abelian_sandpile PRIVATE -march=native -std=c++14)

 

=={{header|Delphi}}==

{{Trans|Python}}

program Abelian_sandpile_model;

 

Readln;

end.

 

 

{{works with|gforth|0.7.3}}

<br>

\ Abelian Sandpile Model

 

: simulate prepare begin stack-full? while 2dup 2>r reduce 2r> inc-all repeat drop to-pgm ." written to " filename type cr ;

 

 

{{out}}

{{works with|gfortran|9.2.0}}

The Abelian sandpile operations are defined here.

 

implicit none

end subroutine

 

 

The <code>main</code> program calls the <code>abelian_sandpile_m</code> and creates an ppm bitmap file by loading <code>rgbimage_m</code> module, which is defined [[Basic bitmap storage#Fortran|here]].

 

use rgbimage_m

call im%write('fig.ppm')

 

 

=={{header|Fōrmulæ}}==

 

 

=={{header|F_Sharp|F#}}==

// Abelian sandpile model. Nigel Galloway: July 20th., 2020

type Sandpile(x,y,N:int[])=

let e1=Array.zeroCreate<int> 25 in e1.[12]<-6; printfn "%s\n" (Sandpile(5,5,e1)).toS

let e1=Array.zeroCreate<int> 25 in e1.[12]<-16; printfn "%s\n" (Sandpile(5,5,e1)).toS

{{out}}

<pre>

[0; 0; 1; 0; 0]]

</pre>

=={{header|Go}}==

{{trans|Rust}}

<br>

Stack management in Go is automatic, starting very small (2KB) for each goroutine and expanding as necessary until the maximum allowed size is reached.

 

import (

// after the recursive algorithm has ended.

// writePile(pile)

 

{{out}}

<br>

Using a custom monad to make the code cleaner.

{-# LANGUAGE GeneralizedNewtypeDeriving #-}

{-# LANGUAGE ScopedTypeVariables #-}

fp = printf "sandpile_%d_%d.pgm" size height

toPGM b fp

 

{{out}}

=={{header|J}}==

 

 

=={{header|Java}}==

This is based on the JavaScript implementation linked to in the task description.

import java.awt.event.*;

import javax.swing.*;

};

private static final int GRID_LENGTH = 300;

 

{{out}}

 

=={{header|Julia}}==

Modified from code by Hayk Aleksanyan, viewable at github.com/hayk314/Sandpiles, license viewable there.

 

# supports output functionality for the results of the sandpile simulations

 

Z_lat, Odometer = AbelSand.move(100000)

[http://alahonua.com/temp/Abel_Z_color_100000.png Link to PNG output file for N=100000 ie. AbelSand.move(100000)] <br />

[http://alahonua.com/temp/Abel_Z_color_1000000.png Link to PNG output file (run time >90 min) for N=1000000 (move(1000000))]

 

=={{header|Pascal}}==

Memorizing the used colums of the rows has little effect when choosing the right size of the grid.Only 11 secs for abelian(1e6) -> 1min 9sec<BR>

[http://rosettacode.org/wiki/Abelian_sandpile_model#Python Python] shows 64 too.

program Abelian2;

{$IFDEF FPC}

OneTurn(100000);

END.

{{out}}

<pre>

</pre>

 

 

use warnings;

 

my ($high, $wide) = split ' ', qx(stty size);

my $pile = $mask =~ s/\177/ rand() < 0.02 ? chr 64 + rand 20 : "\0" /ger;

 

{

print "\e[H", $pile =~ tr/\0-\177/ 1-~/r, "\n$_";

for ("\0$add", "\0" x $wide . $add, substr($add, 1), substr $add, $wide)

{

$pile =~ tr/\200-\377/\1-\176/; # add one to each neighbor of >=4

}

select undef, undef, undef, 0.1; # comment out for full speed

 

=={{header|Phix}}==

Generates moving images similar to the julia output.

The distributed version also has variable speed, additional display modes, and a random dropping toggle.

 

 

 

=={{header|Python}}==

import matplotlib.pyplot as plt

 

plt.figure()

plt.gray()

Before:

[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]

[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]

[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]

[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]

After:

[0. 0. 0. 1. 2. 1. 0. 0. 0. 0.]

[0. 0. 2. 2. 2. 2. 2. 0. 0. 0.]

[0. 0. 0. 1. 2. 1. 0. 0. 0. 0.]

[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]

 

An interactive variant to the above solution:

from time import sleep

 

run(area)

print('\nAfter:')

Before:

0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0 0 0

 

=={{header|Raku}}==

Defaults to a stack of 1000 and showing progress. Pass in a custom stack size if desired and -hide-progress to run without displaying progress (much faster.)

 

 

signal(SIGINT).tap: { cleanup(); exit(0) }

print "\e[1;1H", @buffer.map( { @color[$_ min 4] }).join;

 

 

Passing in 2048 as a stack size results in: [https://github.com/thundergnat/rc/blob/master/img/Abelian-sandpile-model-perl6.png Abelian-sandpile-model-perl6.png] (offsite .png image)

 

===SDL2 Animation===

use SDL2::Raw;

 

}

$fps

 

Passing in a stack size of 20000 results in: [https://github.com/thundergnat/rc/blob/master/img/Abelian-sandpile-sdl2.png Abelian-sandpile-sdl2.png] (offsite .png image)

 

=={{header|Rust}}==

//

// It loops over the current state of the sandpile and updates it on-the-fly.

display(&playfield);

//write_pile(&playfield);

 

'''Output:'''

</pre>

 

=={{header|VBA}}==

Application.ScreenUpdating = False

For i = 1 To a

Debug.Print "End:" & Now()

 

'''Output:'''

<pre>

On Excel Page

</pre>

 

=={{header|Wren}}==

{{libheader|Wren-fmt}}

 

class Sandpile {

var str2 = s.toString

printAcross.call(str1, str2)

 

{{out}}

0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 2 1 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

</pre>