Abelian sandpile model/Identity: Difference between revisions

 

E.g. <code>s1</code> =

2 1 1

 

1 0 1

 

Addition on sandpiles is done by adding numbers in corresponding grid areas,

so for the above:

s1 + s2 = 2 1 1 + 1 0 1 = 3 1 2

 

If the addition would result in more than 3 "grains of sand" in any area then

a chain of topplings called an "avalanche".

E.g.

3 1 2 ==> 4 1 2 ==> 4 2 2 ==> 4 2 3 ==> 0 3 3

 

The final result is the stable sandpile on the right.

* Confirm that s1 + s2 == s2 + s1 # Show the stable results

* If s3 is the sandpile with number 3 in every grid area, and s3_id is the following sandpile:

1 0 1

 

 

;References:

* https://www.youtube.com/watch?v=1MtEUErz7Gg

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

 

 

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

#include <array>

#include <cassert>

constexpr size_t sp_columns = 3;

constexpr size_t sp_cells = sp_rows * sp_columns;

 

class abelian_sandpile {

public:

abelian_sandpile();

bool is_stable() const;

void topple();

private:

int& cell_value(size_t row, size_t column) {

return cell_index % sp_columns;

}

std::array<int, sp_cells> cells_;

};

stabilize();

return *this;

}

 

while (!is_stable())

topple();

}

 

}

 

for (size_t i = 0; i < sp_cells; ++i) {

if (i > 0)

}

}

 

abelian_sandpile sp{4,3,3, 3,1,2, 0,2,3};

while (!sp.is_stable()) {

sp.topple();

}

 

std::cout << "Commutativity:\n";

abelian_sandpile sum2(s2 + s1);

std::cout << "s1 + s2 equals s2 + s1? " << (sum1 == sum2) << "\n\n";

std::cout << '\n';

std::cout << "Identity:\n";

abelian_sandpile s3{3,3,3, 3,3,3, 3,3,3};

std::cout << "s3 + s3_id equals s3? " << (sum3 == s3) << '\n';

std::cout << "s3_id + s3_id equals s3_id? " << (sum4 == s3_id) << "\n\n";

return 0;

 

{{out}}

 

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

printfn "%s\n" ((s1+s2).toS)

printfn "%s\n" ((s2+s1).toS);;

printfn "%s\n" ((s1+s1).toS)

printfn "%s\n" ((s2+s2).toS);;

printfn "%s\n" (s3+s3_id).toS

printfn "%s\n" (s3_id+s3_id).toS

{{out}}

<pre>

[1; 0; 1]

[2; 1; 2]]

</pre>

=={{header|Factor}}==

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:

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

'''Tests of cascades and additions'''

s0 = [[4, 3, 3], [3, 1, 2], [0, 2, 3]]

s1 = [[1, 2, 0], [2, 1, 1], [0, 1, 3]]

s2 = [[2, 1, 3], [1, 0, 1], [0, 1, 0]]

s3_id = [[2, 1, 2], [1, 0, 1], [2, 1, 2]]

 

for expr in [

showSandPiles(

[(' ', series[0])] + [

 

 

def convergence(p):

'''All items of xs to the point where the binary

'''

def go(xs):

return [

]

return go

 

def go(xs):

return next(

None

)

yield v

v = f(v)

return go

 

# MAIN ---

if __name__ == '__main__':

{{Out}}

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

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

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

{{libheader|Wren-fmt}}

 

class Sandpile {

var s5 = s3_id + s3_id

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

 

{{out}}