Abelian sandpile model: Difference between revisions

</pre>

=={{header|11l}}==

grid[5][5] = 64

 

L(row) grid

L(c) row

 

{{out}}

{{works with|as|Raspberry Pi 3B version Buster 64 bits

or android 64 bits with application Termux }}

/* ARM assembly AARCH64 Raspberry PI 3B or android 64 bits */

/* program abelian64.s */

/* for this file see task include a file in language AArch64 assembly */

.include "../includeARM64.inc"

{{Output}}

<pre>

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI or android 32 bits */

/* program abelian.s */

/***************************************************/

.include "../affichage.inc"

{{output}}

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

Compile with following <tt>CMakeList.txt</tt>:

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>

 

=={{header|FreeBASIC}}==

WindowTitle "Abelian sandpile model"

 

Loop Until partic < 4

Bsave "abelian_sandpile.bmp",0

{{out}}

<pre>[https://www.dropbox.com/s/lky2ji9n15gn5u6/abelian_sandpile.bmp?dl=0 Abelian sandpile model FreeBasic image]

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

 

ab=: - [: +/@(-"2 ((,-)=/~i.2)|.!.0]) 3&< NB. abelian sand pile for grid graph

require 'viewmat' NB. viewmat utility

 

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

init = function(self, dim, val)

self.cell, self.dim = {}, dim

sandpile:init(15, 256)

sandpile:iter()

{{out}}

<pre>0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

 

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

sp[s_List] + sp[n_Integer] ^:= sp[s] + sp[ConstantArray[n, Dimensions[s]]]

sp[s_List] + sp[t_List] ^:= Module[{dim, r, tmp, neighbours}, dim = Dimensions[s];

u = sp[CenterArray[250, {15, 15}]];

u += sp[0];

{{out}}

<pre>000000000000000

Our program uses Rust algorithm (and also its colors 🙂) and the formula to compute grid size from number of particles comes from Pascal algorithm.

Number of particles is an input from user. The program displays the values on the terminal if there are not too many and produce a PNG image. Code to produce a PPM image is also provided but not used.

# Abelian sandpile.

 

#grid.writePpmFile(fmt"grid_{initVal}.ppm")

grid.writePngFile(fmt"grid_{initVal}.png")

 

{{out}}

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>

{{works with|OCaml|4.11}}

In Sandpile module (sandpile.ml)

module Make =

functor (M : sig val m : int val n : int end)

; S.avalanche ()

; S.print ()

 

=={{header|Perl}}==

 

use strict; # http://www.rosettacode.org/wiki/Abelian_sandpile_model

}

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.

<span style="color: #000080;font-style:italic;">-- demo\rosetta\Abelian_sandpile_model.exw</span>

<span style="color: #008080;">include</span> <span style="color: #000000;">pGUI</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span>

<span style="color: #000000;">main</span><span style="color: #0000FF;">()</span>

 

=={{header|Python}}==

===Python: Original, with output===

import matplotlib.pyplot as plt

 

plt.figure()

plt.gray()

{{Out}}

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:')

{{Out}}

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

 

===Python: using tkinter===

''' Python 3.6.5 code using Tkinter graphical user

interface (Canvas widget) to display final results.'''

## 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:'''

=={{header|Scheme}}==

{{works with|Chez Scheme}}

 

; Create an empty (all cells 0) grid of the specified size.

(asm-stabilize asm)

(printf "After:~%")

{{out}}

<pre>

 

=={{header|VBA}}==

Application.ScreenUpdating = False

For i = 1 To a

Debug.Print "End:" & Now()

 

'''Output:'''

<pre>

{{trans|Go}}

 

import strings

 

// after the recursive algorithm has ended.

// write_pile(pile)

 

{{out}}

=={{header|Wren}}==

{{libheader|Wren-fmt}}

 

class Sandpile {

var str2 = s.toString

printAcross.call(str1, str2)

 

{{out}}

 

=={{header|XPL0}}==

char Pile1(Size*Size), Pile2(Size*Size);

int Spigot, I, X, Y;

I:= Pile1; Pile1:= Pile2; Pile2:= I;

until Spigot < 4;

 

{{out}}