Abelian sandpile model/Identity: Difference between revisions

* https://en.wikipedia.org/wiki/Abelian_sandpile_model

<br><br>

 

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits <br> or android 64 bits with application Termux }}

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

/* program abelianSum64.s */

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

.include "../includeARM64.inc"

{{Output}}

<pre>

2 1 2

</pre>

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

{{works with|as|Raspberry Pi <br> or android 32 bits with application Termux}}

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

/* program abelianSum.s */

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

.include "../affichage.inc"

{{Output}}

<pre>

 

The package specification for Abelian_Sandpile is:

 

package Abelian_Sandpile is

 

end Abelian_Sandpile;

The package body for Abelian_Sandpile is

 

package body Abelian_Sandpile is

end Print;

end Abelian_Sandpile;

The main procedure performing the same tests as the C++ example is

with Ada.Text_IO; use Ada.Text_IO;

with Abelian_Sandpile; use Abelian_Sandpile;

 

end Main;

{{out}}

<pre>

 

s3_id + s3_id =

2 1 2

1 0 1

 

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

#include <array>

#include <cassert>

 

return 0;

 

{{out}}

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

This task uses [http://www.rosettacode.org/wiki/Abelian_sandpile_model#F.23 Abelian Sandpile Model (F#)]

let s1=Sandpile(3,3,[|1;2;0;2;1;1;0;1;3|])

let s2=Sandpile(3,3,[|2;1;3;1;0;1;0;1;0|])

let e2=Array.zeroCreate<int> 25 in e2.[12]<-16

printfn "%s\n" ((Sandpile(5,5,e1)+Sandpile(5,5,e2)).toS)

{{out}}

<pre>

I wouldn't call it a translation, but the idea of storing sandpiles as flat arrays came from the Wren entry.

{{works with|Factor|0.99 2020-07-03}}

qw sequences ;

 

 

"s3_id + s3_id = s3_id" print nl

{{out}}

<pre>

1 0 1 + 1 0 1 = 1 0 1

2 1 2 2 1 2 2 1 2

</pre>

 

=={{header|Go}}==

{{trans|Wren}}

 

import (

}

fmt.Printf("%s\nplus\n\n%s\nequals\n\n%s", s3_id, s3_id, s5)

 

{{out}}

 

=={{header|Haskell}}==

 

import Data.List (findIndex, transpose)

lng = length s

pad = replicate lng ' '

<pre>Cascade:

4 3 3 0 4 3 1 0 4 1 1 0 2 1 0

 

=={{header|J}}==

While=:2 :'u^:(0-.@:-:v)^:_'

index_of_maximum=: $ #: (i. >./)@:,

avalanche=: (AVALANCHE + {)`[`]}~ ([: <"1 NEIGHBORS +"1 index_of_maximum)

erode=: avalanche&.:frame While(3 < [: >./ ,)

<pre>

NB. common ways to construct a matrix in j from directly entered vectors

└─────────┴─────────┘

</pre>

 

=={{header|Julia}}==

 

struct Sandpile

println(s3_id, " +\n", s3_id, " =\n", s3_id + s3_id, "\n")

 

<pre>

Avalanche reduction to group:

2 1 2

</pre>

=={{header|Lua}}==

Uses Abelian sandpile model [[Abelian_sandpile_model#Lua|here]], then extends..

sandpile.new = function(self, vals)

local inst = setmetatable({},sandpile)

print("\ns3 + s3_id =") s3ps3_id:draw()

local s3_idps3_id = s3_id:add(s3_id)

{{out}}

<pre>s1 =

1 0 1

2 1 2</pre>

 

=={{header|Nim}}==

import sequtils

import strutils

echo "s3_id + s3_id = s3_id\n"

printSum(s3_id, s3_id, s3_id + s3_id)

 

{{out}}

</pre>

 

 

 

 

 

 

 

 

 

 

 

 

{{out}}

<pre>

=={{header|Python}}==

===Object Oriented===

from collections import defaultdict

 

s3 = Sandpile("3 3 3 3 3 3 3 3 3")

s3_id = Sandpile("2 1 2 1 0 1 2 1 2")

 

;Command line session to complete task.

 

===Functional===

 

from operator import add, eq

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>Cascade:

Most of the logic is lifted straight from the [[Abelian_sandpile_model#Raku|Abelian sandpile model]] task.

 

has $.h = 3;

has $.w = 3;

 

put '';

{{out}}

<pre> identity test pile toppled plus identity toppled

│ 2 │ 3 │ 2 │ 3 │ 2 │ │ 4 │ 2 │ 2 │ 4 │ 0 │ │ 3 │ 2 │ 3 │ 2 │ 1 │ │ 5 │ 5 │ 5 │ 5 │ 3 │ │ 3 │ 2 │ 3 │ 2 │ 1 │

╰───┴───┴───┴───┴───╯ ╰───┴───┴───┴───┴───╯ ╰───┴───┴───┴───┴───╯ ╰───┴───┴───┴───┴───╯ ╰───┴───┴───┴───┴───╯

</pre>

 

=={{header|REXX}}==

@.= 0; size= 3 /*assign 0 to all grid cells; grid size*/

call init 2, 2 1 3 1 0 1 0 1 0 /* " " " " " " 2 */

call init 3, 3 3 3 3 3 3 3 3 3 /* " " " " " " 3 */

end /*r*/; say arg(4); call norm t; return

/*──────────────────────────────────────────────────────────────────────────────────────*/

end /*r*/

return

/*──────────────────────────────────────────────────────────────────────────────────────*/

end /*r*/; shows= 0; return

/*──────────────────────────────────────────────────────────────────────────────────────*/

/*──────────────────────────────────────────────────────────────────────────────────────*/

show: parse arg x; xx= tran(x); say ind center("sandpile" xx,25,'─') /*show the title*/

say ind pad $ /*display a row.*/

{{out|output|text=&nbsp; when using the default inputs:}}

 

2 1 2

comparison of sum4 and s3_id: same.

</pre>

 

=={{header|Wren}}==

{{libheader|Wren-fmt}}

 

class Sandpile {

var s5 = s3_id + s3_id

while (!s5.isStable) s5.topple()

 

{{out}}

1 0 1

2 1 2

</pre>