Abelian sandpile model/Identity

From Rosetta Code
< Abelian sandpile model
Revision as of 10:07, 17 July 2020 by Simonjsaunders (talk | contribs) (C++ - typo fix)
Abelian sandpile model/Identity is a draft programming task. It is not yet considered ready to be promoted as a complete task, for reasons that should be found in its talk page.

Our sandpiles are based on a 3 by 3 rectangular grid giving nine areas that contain a number from 0 to 3 inclusive. (The numbers are said to represent grains of sand in each area of the sandpile).

E.g. s1 = 

    1 2 0
    2 1 1
    0 1 3

Or s2 = 

    2 1 3
    1 0 1
    0 1 0

Addition on sandpiles is done by adding numbers in corresponding grid areas, so for the above: 

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

If the addition would result in more than 3 "grains of sand" in any area then those areas cause the whole sandpile to become "unstable" and the sandpile areas are "toppled" in an "avalanche" until the "stable" result is obtained.

Any unstable area (with a number >= 4), is "toppled" by loosing one grain of sand to each of its four horizontal or vertical neighbours. Grains are lost at the edge of the grid, but otherwise increase the number in neighbouring cells by one, whilst decreasing the count in the toppled cell by four in each toppling.

A toppling may give an adjacent area more than four grains of sand leading to a chain of topplings called an "avalanche". E.g. 

    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
    0 2 3     0 2 3     0 2 3     0 2 3     1 2 3

The final result is the stable sandpile on the right.

Note: The order in which cells are toppled does not affect the final result.

Task
  • Create a class or datastructure and functions to represent and operate on sandpiles.
  • Confirm the result of the avalanche of topplings shown above
  • 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:
    2 1 2  
    1 0 1  
    2 1 2
* Show that s3 + s3_id == s3
* Show that s3_id + s3_id == s3_id

Show confirming output here, with your example.

References


C++

<lang cpp>#include <algorithm>

  1. include <array>
  2. include <cassert>
  3. include <initializer_list>
  4. include <iostream>

constexpr size_t sp_rows = 3; constexpr size_t sp_columns = 3; constexpr size_t sp_cells = sp_rows * sp_columns; constexpr size_t sp_limit = 4;

class abelian_sandpile { public: 

   abelian_sandpile();
   explicit abelian_sandpile(std::initializer_list<int> init);
   void stabilize();
   bool is_stable() const;
   void topple();
   abelian_sandpile& operator+=(const abelian_sandpile& other);
   void print(std::ostream&) const;

private: 

   int& cell_value(size_t row, size_t column) {
       return cells_[cell_index(row, column)];
   }
   static size_t cell_index(size_t row, size_t column) {
       return row * sp_columns + column;
   }
   static size_t row_index(size_t cell_index) {
       return cell_index/sp_columns;
   }
   static size_t column_index(size_t cell_index) {
       return cell_index % sp_columns;
   }
   friend bool operator==(const abelian_sandpile&, const abelian_sandpile&);
   std::array<int, sp_cells> cells_;

};

abelian_sandpile::abelian_sandpile() { 

   cells_.fill(0);

}

abelian_sandpile::abelian_sandpile(std::initializer_list<int> init) { 

   assert(init.size() == sp_cells);
   std::copy(init.begin(), init.end(), cells_.begin());

}

abelian_sandpile& abelian_sandpile::operator+=(const abelian_sandpile& other) { 

   for (size_t i = 0; i < sp_cells; ++i)
       cells_[i] += other.cells_[i];
   stabilize();
   return *this;

}

bool abelian_sandpile::is_stable() const { 

   return std::none_of(cells_.begin(), cells_.end(),
                       [](int a) { return a >= sp_limit; });

}

void abelian_sandpile::topple() { 

   for (size_t i = 0; i < sp_cells; ++i) {
       if (cells_[i] >= sp_limit) {
           cells_[i] -= sp_limit;
           size_t row = row_index(i);
           size_t column = column_index(i);
           if (row > 0)
               ++cell_value(row - 1, column);
           if (row + 1 < sp_rows)
               ++cell_value(row + 1, column);
           if (column > 0)
               ++cell_value(row, column - 1);
           if (column + 1 < sp_columns)
               ++cell_value(row, column + 1);
           break;
       }
   }

}

void abelian_sandpile::stabilize() { 

   while (!is_stable())
       topple();

}

bool operator==(const abelian_sandpile& a, const abelian_sandpile& b) { 

   return std::equal(a.cells_.begin(), a.cells_.end(), b.cells_.begin());

}

abelian_sandpile operator+(const abelian_sandpile& a, const abelian_sandpile& b) { 

   abelian_sandpile c(a);
   c += b;
   return c;

}

void abelian_sandpile::print(std::ostream& out) const { 

   for (size_t i = 0; i < sp_cells; ++i) {
       if (i > 0)
           out << (column_index(i) == 0 ? '\n' : ' ');
       out << cells_[i];
   }
   out << '\n';

}

int main() { 

   std::cout << std::boolalpha;

   std::cout << "Avalanche:\n";
   abelian_sandpile sp({4,3,3, 3,1,2, 0,2,3});
   while (!sp.is_stable()) {
       sp.print(std::cout);
       std::cout << "stable? " << sp.is_stable() << "\n\n";
       sp.topple();
   }
   sp.print(std::cout);
   std::cout << "stable? " << sp.is_stable() << "\n\n";

   std::cout << "Commutativity:\n";
   abelian_sandpile s1({1,2,0, 2,1,1, 0,1,3});
   abelian_sandpile s2({2,1,3, 1,0,1, 0,1,0});
   abelian_sandpile sum1(s1 + s2);
   abelian_sandpile sum2(s2 + s1);
   std::cout << "s1 + s2 equals s2 + s1? " << (sum1 == sum2) << "\n\n";
   std::cout << "s1 + s2 = \n";
   sum1.print(std::cout);
   std::cout << "\ns2 + s1 = \n";
   sum2.print(std::cout);
   std::cout << '\n';
   
   std::cout << "Identity:\n";
   abelian_sandpile s3({3,3,3, 3,3,3, 3,3,3});
   abelian_sandpile s3_id({2,1,2, 1,0,1, 2,1,2});
   abelian_sandpile sum3(s3 + s3_id);
   abelian_sandpile sum4(s3_id + s3_id);
   std::cout << "s3 + s3_id equals s3? " << (sum3 == s3) << '\n';
   std::cout << "s3_id + s3_id equals s3_id? " << (sum4 == s3_id) << "\n\n";
   std::cout << "s3 + s3_id = \n";
   sum3.print(std::cout);
   std::cout << "\ns3_id + s3_id = \n";
   sum4.print(std::cout);
   
   return 0;

}</lang>

Output:
Avalanche:
4 3 3
3 1 2
0 2 3
stable? false

0 4 3
4 1 2
0 2 3
stable? false

1 0 4
4 2 2
0 2 3
stable? false

1 1 0
4 2 3
0 2 3
stable? false

2 1 0
0 3 3
1 2 3
stable? true

Commutativity:
s1 + s2 equals s2 + s1? true

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

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

Identity:
s3 + s3_id equals s3? true
s3_id + s3_id equals s3_id? true

s3 + s3_id = 
3 3 3
3 3 3
3 3 3

s3_id + s3_id = 
2 1 2
1 0 1
2 1 2

Go

Translation of: Wren

<lang go>package main

import ( 

   "fmt"
   "strconv"
   "strings"

)

type sandpile struct{ a [9]int }

var neighbors = [][]int{ 

   {1, 3}, {0, 2, 4}, {1, 5}, {0, 4, 6}, {1, 3, 5, 7}, {2, 4, 8}, {3, 7}, {4, 6, 8}, {5, 7},

}

// 'a' is in row order func newSandpile(a [9]int) *sandpile { return &sandpile{a} }

func (s *sandpile) plus(other *sandpile) *sandpile { 

   b := [9]int{}
   for i := 0; i < 9; i++ {
       b[i] = s.a[i] + other.a[i]
   }
   return &sandpile{b}

}

func (s *sandpile) isStable() bool { 

   for _, e := range s.a {
       if e > 3 {
           return false
       }
   }
   return true

}

// just topples once so we can observe intermediate results func (s *sandpile) topple() { 

   for i := 0; i < 9; i++ {
       if s.a[i] > 3 {
           s.a[i] -= 4
           for _, j := range neighbors[i] {
               s.a[j]++
           }
           return
       }
   }

}

func (s *sandpile) String() string { 

   var sb strings.Builder
   for i := 0; i < 3; i++ {
       for j := 0; j < 3; j++ {
           sb.WriteString(strconv.Itoa(s.a[3*i+j]) + " ")
       }
       sb.WriteString("\n")
   }
   return sb.String()

}

func main() { 

   fmt.Println("Avalanche of topplings:\n")
   s4 := newSandpile([9]int{4, 3, 3, 3, 1, 2, 0, 2, 3})
   fmt.Println(s4)
   for !s4.isStable() {
       s4.topple()
       fmt.Println(s4)
   }

   fmt.Println("Commutative additions:\n")
   s1 := newSandpile([9]int{1, 2, 0, 2, 1, 1, 0, 1, 3})
   s2 := newSandpile([9]int{2, 1, 3, 1, 0, 1, 0, 1, 0})
   s3_a := s1.plus(s2)
   for !s3_a.isStable() {
       s3_a.topple()
   }
   s3_b := s2.plus(s1)
   for !s3_b.isStable() {
       s3_b.topple()
   }
   fmt.Printf("%s\nplus\n\n%s\nequals\n\n%s\n", s1, s2, s3_a)
   fmt.Printf("and\n\n%s\nplus\n\n%s\nalso equals\n\n%s\n", s2, s1, s3_b)

   fmt.Println("Addition of identity sandpile:\n")
   s3 := newSandpile([9]int{3, 3, 3, 3, 3, 3, 3, 3, 3})
   s3_id := newSandpile([9]int{2, 1, 2, 1, 0, 1, 2, 1, 2})
   s4 = s3.plus(s3_id)
   for !s4.isStable() {
       s4.topple()
   }
   fmt.Printf("%s\nplus\n\n%s\nequals\n\n%s\n", s3, s3_id, s4)

   fmt.Println("Addition of identities:\n")
   s5 := s3_id.plus(s3_id)
   for !s5.isStable() {
       s5.topple()
   }
   fmt.Printf("%s\nplus\n\n%s\nequals\n\n%s", s3_id, s3_id, s5)

}</lang>

Output:
Avalanche of topplings:

4 3 3 
3 1 2 
0 2 3 

0 4 3 
4 1 2 
0 2 3 

1 0 4 
4 2 2 
0 2 3 

1 1 0 
4 2 3 
0 2 3 

2 1 0 
0 3 3 
1 2 3 

Commutative additions:

1 2 0 
2 1 1 
0 1 3 

plus

2 1 3 
1 0 1 
0 1 0 

equals

3 3 3 
3 1 2 
0 2 3 

and

2 1 3 
1 0 1 
0 1 0 

plus

1 2 0 
2 1 1 
0 1 3 

also equals

3 3 3 
3 1 2 
0 2 3 

Addition of identity sandpile:

3 3 3 
3 3 3 
3 3 3 

plus

2 1 2 
1 0 1 
2 1 2 

equals

3 3 3 
3 3 3 
3 3 3 

Addition of identities:

2 1 2 
1 0 1 
2 1 2 

plus

2 1 2 
1 0 1 
2 1 2 

equals

2 1 2 
1 0 1 
2 1 2

Julia

<lang julia>import Base.+, Base.print

struct Sandpile 

   pile::Matrix{UInt8}

end

function Sandpile(s::String) 

   arr = [parse(UInt8, x.match) for x in eachmatch(r"\d+", s)]
   siz = isqrt(length(arr))
   return Sandpile(reshape(UInt8.(arr), siz, siz)')

end

const HMAX = 3

function avalanche!(s::Sandpile, lim=HMAX) 

   nrows, ncols = size(s.pile)
   while any(x -> x > lim, s.pile)
       for j in 1:ncols, i in 1:nrows
           if s.pile[i, j] > lim
               i > 1 && (s.pile[i - 1, j] += 1)
               i < nrows && (s.pile[i + 1, j] += 1)
               j > 1 && (s.pile[i, j - 1] += 1)
               j < ncols && (s.pile[i, j + 1] += 1)
               s.pile[i, j] -= 4
           end
       end
   end
   s

end

+(s1::Sandpile, s2::Sandpile) = avalanche!(Sandpile((s1.pile + s2.pile)))

function print(io::IO, s::Sandpile) 

   for row in 1:size(s.pile)[1]
       for col in 1:size(s.pile)[2]
           print(io, lpad(s.pile[row, col], 4))
       end
       println()
   end

end

const s3 = Sandpile(""" 

   3 3 3
   3 3 3 
   3 3 3""")

const s3_id = Sandpile(""" 

   2 1 2  
   1 0 1  
   2 1 2""")

const s3a = Sandpile(""" 

   4 3 3 
   3 1 2 
   0 2 3""")

println("Avalanche reduction to group:\n", s3a, " =>") println(avalanche!(s3a), "\n")

println("Addition:\n", s3, " +\n", s3_id, " =\n", s3 + s3_id, "\n") println(s3_id, " +\n", s3_id, " =\n", s3_id + s3_id, "\n")

</lang>

Output:
Avalanche reduction to group:
   4   3   3
   3   1   2
   0   2   3
   =>
   2   1   0
   0   3   3
   1   2   3


Addition:
   3   3   3
   3   3   3
   3   3   3
   +
   2   1   2
   1   0   1
   2   1   2
   =
   3   3   3
   3   3   3
   3   3   3


   2   1   2
   1   0   1
   2   1   2
   +
   2   1   2
   1   0   1
   2   1   2
   =
   2   1   2
   1   0   1
   2   1   2

Python

<lang python>from itertools import product from collections import defaultdict


class Sandpile(): 

   def __init__(self, gridtext):
       array = [int(x) for x in gridtext.strip().split()]
       self.grid = defaultdict(int,
                               {(i //3, i % 3): x 
                                for i, x in enumerate(array)})

   _border = set((r, c) 
                 for r, c in product(range(-1, 4), repeat=2) 
                 if not 0 <= r <= 2 or not 0 <= c <= 2
                 )
   _cell_coords = list(product(range(3), repeat=2))
   
   def topple(self):
       g = self.grid
       for r, c in self._cell_coords:
           if g[(r, c)] >= 4:
               g[(r - 1, c)] += 1
               g[(r + 1, c)] += 1
               g[(r, c - 1)] += 1
               g[(r, c + 1)] += 1
               g[(r, c)] -= 4
               return True
       return False
   
   def stabilise(self):
       while self.topple():
           pass
       # Remove extraneous grid border
       g = self.grid
       for row_col in self._border.intersection(g.keys()):
           del g[row_col]
       return self
   
   __pos__ = stabilise     # +s == s.stabilise()
   
   def __eq__(self, other):
       g = self.grid
       return all(g[row_col] == other.grid[row_col]
                  for row_col in self._cell_coords)

   def __add__(self, other):
       g = self.grid
       ans = Sandpile("")
       for row_col in self._cell_coords:
           ans.grid[row_col] = g[row_col] + other.grid[row_col]
       return ans.stabilise()
      
   def __str__(self):
       g, txt = self.grid, []
       for row in range(3):
           txt.append(' '.join(str(g[(row, col)]) 
                               for col in range(3)))
       return '\n'.join(txt)
   
   def __repr__(self):
       return f'{self.__class__.__name__}(""""\n{self.__str__()}""")'

unstable = Sandpile(""" 4 3 3 3 1 2 0 2 3""") s1 = Sandpile(""" 

   1 2 0
   2 1 1
   0 1 3

""") s2 = Sandpile(""" 

   2 1 3
   1 0 1
   0 1 0

""") s3 = Sandpile("3 3 3 3 3 3 3 3 3") s3_id = Sandpile("2 1 2 1 0 1 2 1 2") </lang>

Command line session to complete task.
In [2]: unstable
Out[2]: 
Sandpile(""""
4 3 3
3 1 2
0 2 3""")

In [3]: unstable.stabilise()
Out[3]: 
Sandpile(""""
2 1 0
0 3 3
1 2 3""")

In [4]: s1 + s2
Out[4]: 
Sandpile(""""
3 3 3
3 1 2
0 2 3""")

In [5]: s2 + s1
Out[5]: 
Sandpile(""""
3 3 3
3 1 2
0 2 3""")

In [6]: s1 + s2 == s2 + s1
Out[6]: True

In [7]: s3
Out[7]: 
Sandpile(""""
3 3 3
3 3 3
3 3 3""")

In [8]: s3_id
Out[8]: 
Sandpile(""""
2 1 2
1 0 1
2 1 2""")

In [9]: s3 + s3_id
Out[9]: 
Sandpile(""""
3 3 3
3 3 3
3 3 3""")

In [10]: s3 + s3_id == s3
Out[10]: True

In [11]: s3_id + s3_id
Out[11]: 
Sandpile(""""
2 1 2
1 0 1
2 1 2""")

In [12]: s3_id + s3_id == s3_id
Out[12]: True

In [13]:

Raku

Works with: Rakudo version 2020.05

Most of the logic is lifted straight from the Abelian sandpile model task.

<lang perl6>class ASP { 

   has $.h = 3;
   has $.w = 3;
   has @.pile = 0 xx $!w * $!h;

   method topple {
       my $buf = $!w * $!h;
       my $done;
       repeat {
           $done = True;
           loop (my int $row; $row < $!h; $row = $row + 1) {
               my int $rs = $row * $!w; # row start
               my int $re = $rs  + $!w; # row end
               loop (my int $idx = $rs; $idx < $re; $idx = $idx + 1) {
                   if self.pile[$idx] >= 4 {
                       my $grain = self.pile[$idx] div 4;
                       self.pile[ $idx - $!w ] += $grain if $row > 0;
                       self.pile[ $idx - 1  ]  += $grain if $idx - 1 >= $rs;
                       self.pile[ $idx + $!w ] += $grain if $row < $!h - 1;
                       self.pile[ $idx + 1  ]  += $grain if $idx + 1 < $re;
                       self.pile[ $idx ] %= 4;
                       $done = False;
                   }
               }
           }
       } until $done;
       self.pile;
   }

}

  1. some handy display layout modules

use Terminal::Boxer:ver<0.2+>; use Text::Center;

for 3, (4,3,3,3,1,2,0,2,3), (2,1,2,1,0,1,2,1,2), # 3 square task example 

   3, (2,1,2,1,0,1,2,1,2), (2,1,2,1,0,1,2,1,2), # 3 square identity
   5, (4,1,0,5,1,9,3,6,1,0,8,1,2,5,3,3,0,1,7,5,4,2,2,4,0), (2,3,2,3,2,3,2,1,2,3,2,1,0,1,2,3,2,1,2,3,2,3,2,3,2) # 5 square test
 -> $size, $pile, $identity {

   my $asp = ASP.new(:h($size), :w($size));

   $asp.pile = |$pile;

   my @display;

   my %p = :col($size), :3cw, :indent("\t");

   @display.push: rs-box |%p, |$identity;

   @display.push: rs-box |%p, $asp.pile;

   @display.push: rs-box |%p, $asp.topple;

   $asp.pile Z+= $identity.list;

   @display.push: rs-box |%p, $asp.pile;

   @display.push: rs-box |%p, $asp.topple;

   put %p<indent> ~ qww<identity 'test pile' toppled 'plus identity' toppled>».&center($size * 4 + 1).join: %p<indent>;

   .put for [Z~] @display».lines;

   put ;

}</lang>

Output:
	   identity  	  test pile  	   toppled   	plus identity	   toppled   
	╭───┬───┬───╮	╭───┬───┬───╮	╭───┬───┬───╮	╭───┬───┬───╮	╭───┬───┬───╮
	│ 2 │ 1 │ 2 │	│ 4 │ 3 │ 3 │	│ 2 │ 1 │ 0 │	│ 4 │ 2 │ 2 │	│ 2 │ 1 │ 0 │
	├───┼───┼───┤	├───┼───┼───┤	├───┼───┼───┤	├───┼───┼───┤	├───┼───┼───┤
	│ 1 │ 0 │ 1 │	│ 3 │ 1 │ 2 │	│ 0 │ 3 │ 3 │	│ 1 │ 3 │ 4 │	│ 0 │ 3 │ 3 │
	├───┼───┼───┤	├───┼───┼───┤	├───┼───┼───┤	├───┼───┼───┤	├───┼───┼───┤
	│ 2 │ 1 │ 2 │	│ 0 │ 2 │ 3 │	│ 1 │ 2 │ 3 │	│ 3 │ 3 │ 5 │	│ 1 │ 2 │ 3 │
	╰───┴───┴───╯	╰───┴───┴───╯	╰───┴───┴───╯	╰───┴───┴───╯	╰───┴───┴───╯

	   identity  	  test pile  	   toppled   	plus identity	   toppled   
	╭───┬───┬───╮	╭───┬───┬───╮	╭───┬───┬───╮	╭───┬───┬───╮	╭───┬───┬───╮
	│ 2 │ 1 │ 2 │	│ 2 │ 1 │ 2 │	│ 2 │ 1 │ 2 │	│ 4 │ 2 │ 4 │	│ 2 │ 1 │ 2 │
	├───┼───┼───┤	├───┼───┼───┤	├───┼───┼───┤	├───┼───┼───┤	├───┼───┼───┤
	│ 1 │ 0 │ 1 │	│ 1 │ 0 │ 1 │	│ 1 │ 0 │ 1 │	│ 2 │ 0 │ 2 │	│ 1 │ 0 │ 1 │
	├───┼───┼───┤	├───┼───┼───┤	├───┼───┼───┤	├───┼───┼───┤	├───┼───┼───┤
	│ 2 │ 1 │ 2 │	│ 2 │ 1 │ 2 │	│ 2 │ 1 │ 2 │	│ 4 │ 2 │ 4 │	│ 2 │ 1 │ 2 │
	╰───┴───┴───╯	╰───┴───┴───╯	╰───┴───┴───╯	╰───┴───┴───╯	╰───┴───┴───╯

	       identity      	      test pile      	       toppled       	    plus identity    	       toppled       
	╭───┬───┬───┬───┬───╮	╭───┬───┬───┬───┬───╮	╭───┬───┬───┬───┬───╮	╭───┬───┬───┬───┬───╮	╭───┬───┬───┬───┬───╮
	│ 2 │ 3 │ 2 │ 3 │ 2 │	│ 4 │ 1 │ 0 │ 5 │ 1 │	│ 1 │ 3 │ 2 │ 1 │ 0 │	│ 3 │ 6 │ 4 │ 4 │ 2 │	│ 1 │ 3 │ 2 │ 1 │ 0 │
	├───┼───┼───┼───┼───┤	├───┼───┼───┼───┼───┤	├───┼───┼───┼───┼───┤	├───┼───┼───┼───┼───┤	├───┼───┼───┼───┼───┤
	│ 3 │ 2 │ 1 │ 2 │ 3 │	│ 9 │ 3 │ 6 │ 1 │ 0 │	│ 2 │ 2 │ 3 │ 3 │ 1 │	│ 5 │ 4 │ 4 │ 5 │ 4 │	│ 2 │ 2 │ 3 │ 3 │ 1 │
	├───┼───┼───┼───┼───┤	├───┼───┼───┼───┼───┤	├───┼───┼───┼───┼───┤	├───┼───┼───┼───┼───┤	├───┼───┼───┼───┼───┤
	│ 2 │ 1 │ 0 │ 1 │ 2 │	│ 8 │ 1 │ 2 │ 5 │ 3 │	│ 1 │ 1 │ 2 │ 0 │ 3 │	│ 3 │ 2 │ 2 │ 1 │ 5 │	│ 1 │ 1 │ 2 │ 0 │ 3 │
	├───┼───┼───┼───┼───┤	├───┼───┼───┼───┼───┤	├───┼───┼───┼───┼───┤	├───┼───┼───┼───┼───┤	├───┼───┼───┼───┼───┤
	│ 3 │ 2 │ 1 │ 2 │ 3 │	│ 3 │ 0 │ 1 │ 7 │ 5 │	│ 2 │ 0 │ 3 │ 2 │ 0 │	│ 5 │ 2 │ 4 │ 4 │ 3 │	│ 2 │ 0 │ 3 │ 2 │ 0 │
	├───┼───┼───┼───┼───┤	├───┼───┼───┼───┼───┤	├───┼───┼───┼───┼───┤	├───┼───┼───┼───┼───┤	├───┼───┼───┼───┼───┤
	│ 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 │
	╰───┴───┴───┴───┴───╯	╰───┴───┴───┴───┴───╯	╰───┴───┴───┴───┴───╯	╰───┴───┴───┴───┴───╯	╰───┴───┴───┴───┴───╯

Wren

Library: Wren-fmt

<lang ecmascript>import "/fmt" for Fmt

class Sandpile { 

   static init() {
       __neighbors = [
           [1, 3], [0, 2, 4], [1, 5], [0, 4, 6], [1, 3, 5, 7], [2, 4, 8], [3, 7], [4, 6, 8], [5, 7]
       ]
   }

   // 'a' is a list of 9 integers in row order
   construct new(a) {
       _a = a
   }

   a { _a }

   +(other) {
       var b = List.filled(9, 0)
       for (i in 0..8) b[i] = _a[i] + other.a[i]
       return Sandpile.new(b)
   }

   isStable { _a.all { |i| i <= 3 } }

   // just topples once so we can observe intermediate results
   topple() {
       for (i in 0..8) {
           if (_a[i] > 3) {
               _a[i] = _a[i] - 4
               for (j in __neighbors[i]) _a[j] = _a[j] + 1
               return
           }
       }
   }

   toString {
       var s = ""
       for (i in 0..2) {
           for (j in 0..2) s = s + "%(a[3*i + j]) "
           s = s + "\n"
       }
       return s
   }

}

Sandpile.init() System.print("Avalanche of topplings:\n") var s4 = Sandpile.new([4, 3, 3, 3, 1, 2, 0, 2, 3]) System.print(s4) while (!s4.isStable) { 

   s4.topple()
   System.print(s4)

}

System.print("Commutative additions:\n") var s1 = Sandpile.new([1, 2, 0, 2, 1, 1, 0, 1, 3]) var s2 = Sandpile.new([2, 1, 3, 1, 0, 1, 0, 1, 0]) var s3_a = s1 + s2 while (!s3_a.isStable) s3_a.topple() var s3_b = s2 + s1 while (!s3_b.isStable) s3_b.topple() Fmt.print("$s\nplus\n\n$s\nequals\n\n$s", s1, s2, s3_a) Fmt.print("and\n\n$s\nplus\n\n$s\nalso equals\n\n$s", s2, s1, s3_b)

System.print("Addition of identity sandpile:\n") var s3 = Sandpile.new(List.filled(9, 3)) var s3_id = Sandpile.new([2, 1, 2, 1, 0, 1, 2, 1, 2]) s4 = s3 + s3_id while (!s4.isStable) s4.topple() Fmt.print("$s\nplus\n\n$s\nequals\n\n$s", s3, s3_id, s4)

System.print("Addition of identities:\n") var s5 = s3_id + s3_id while (!s5.isStable) s5.topple() Fmt.write("$s\nplus\n\n$s\nequals\n\n$s", s3_id, s3_id, s5)</lang>

Output:
Avalanche of topplings:

4 3 3 
3 1 2 
0 2 3 

0 4 3 
4 1 2 
0 2 3 

1 0 4 
4 2 2 
0 2 3 

1 1 0 
4 2 3 
0 2 3 

2 1 0 
0 3 3 
1 2 3 

Commutative additions:

1 2 0 
2 1 1 
0 1 3 

plus

2 1 3 
1 0 1 
0 1 0 

equals

3 3 3 
3 1 2 
0 2 3 

and

2 1 3 
1 0 1 
0 1 0 

plus

1 2 0 
2 1 1 
0 1 3 

also equals

3 3 3 
3 1 2 
0 2 3 

Addition of identity sandpile:

3 3 3 
3 3 3 
3 3 3 

plus

2 1 2 
1 0 1 
2 1 2 

equals

3 3 3 
3 3 3 
3 3 3 

Addition of identities:

2 1 2 
1 0 1 
2 1 2 

plus

2 1 2 
1 0 1 
2 1 2 

equals

2 1 2 
1 0 1 
2 1 2
Retrieved from "https://rosettacode.org/wiki/Abelian_sandpile_model/Identity?oldid=301202"