Provided by: libmath-planepath-perl_113-1_all bug

NAME

       Math::PlanePath::CellularRule190 -- cellular automaton 190 and 246 points

SYNOPSIS

        use Math::PlanePath::CellularRule190;
        my $path = Math::PlanePath::CellularRule190->new;
        my ($x, $y) = $path->n_to_xy (123);

DESCRIPTION

       This is the pattern of Stephen Wolfram's "rule 190" cellular automaton

           <http://mathworld.wolfram.com/Rule190.html>

       arranged as rows,

           66 67 68    69 70 71    72 73 74    75 76 77    78 79 80      9
              53 54 55    56 57 58    59 60 61    62 63 64    65         8
                 41 42 43    44 45 46    47 48 49    50 51 52            7
                    31 32 33    34 35 36    37 38 39    40               6
                       22 23 24    25 26 27    28 29 30                  5
                          15 16 17    18 19 20    21                     4
                              9 10 11    12 13 14                        3
                                 5  6  7     8                           2
                                    2  3  4                              1
                                       1                             <- Y=0

           -9 -8 -7 -6 -5 -4 -3 -2 -1 X=0 1  2  3  4  5  6  7  8  9

       Each row is 3 out of 4 cells.  Even numbered rows have one point on its own at the end.
       Each two-row group has a step of 6 more points than the previous two-row.

       The of rightmost N=1,4,8,14,21,etc are triangular plus quarter square, ie.

           Nright = triangular(Y+1) + quartersquare(Y+1)
             triangular(t)    = t*(t+1)/2
             quartersquare(t) = floor(t^2/4)

       The rightmost N=1,8,21,40,65,etc on even rows Y=0,2,4,6,etc are the octagonal numbers
       k*(3k-2).  The octagonal numbers of the "second kind" N=5,16,33,56,85, etc, k*(3k+2) are a
       straight-ish line upwards to the left.

   Mirror
       The "mirror => 1" option gives the mirror image pattern which is "rule 246".  It differs
       only in the placement of the gaps on the even rows.  The point on its own is at the left
       instead of the right.  The numbering is still left to right.

           66 67 68    69 70 71    72 73 74    75 76 77    78 79 80      9
              53    54 55 56    57 58 59    60 61 62    63 64 65         8
                 41 42 43    44 45 46    47 48 49    50 51 52            7
                    31    32 33 34    35 36 37    38 39 40               6
                       22 23 24    25 26 27    28 29 30                  5
                          15    16 17 18    19 20 21                     4
                              9 10 11    12 13 14                        3
                                 5     6  7  8                           2
                                    2  3  4                              1
                                       1                             <- Y=0

           -9 -8 -7 -6 -5 -4 -3 -2 -1 X=0 1  2  3  4  5  6  7  8  9

       Sometimes this small change to the pattern helps things line up better.  For example
       plotting the Klaner-Rado sequence gives some unplotted lines up towards the right in the
       mirror 246 which are not visible in the plain 190.

   Row Ranges
       The left end of each row, both ordinary and mirrored, is

           Nleft = ((3Y+2)*Y + 4)/4     if Y even
                   ((3Y+2)*Y + 3)/4     if Y odd

       The right end is

           Nright = ((3Y+8)*Y + 4)/4    if Y even
                    ((3Y+8)*Y + 5)/4    if Y odd

                  = Nleft(Y+1) - 1   ie. 1 before next Nleft

       The row width Xmax-Xmin = 2*Y but with the gaps the number of visited points in a row is
       less than that,

           rowpoints = 3*Y/2 + 1        if Y even
                       3*(Y+1)/2        if Y odd

       For any Y of course the Nleft to Nright difference is the number of points in the row too

           rowpoints = Nright - Nleft + 1

   N Start
       The default is to number points starting N=1 as shown above.  An optional "n_start" can
       give a different start, in the same pattern.  For example to start at 0,

           n_start => 0

           21 22 23    24 25 26    27 28 29          5
              14 15 16    17 18 19    20             4
                  8  9 10    11 12 13                3
                     4  5  6     7                   2
                        1  2  3                      1
                           0                     <- Y=0

           -5 -4 -3 -2 -1 X=0 1  2  3  4  5

       The effect is to push each N rightwards by 1, and wrapping around.  So the
       N=0,1,4,8,14,etc on the left were on the right of the default n_start=1.  This also has
       the effect of removing the +1 in the Nright formula given above, so

           Nleft = triangular(Y) + quartersquare(Y)

FUNCTIONS

       See "FUNCTIONS" in Math::PlanePath for behaviour common to all path classes.

       "$path = Math::PlanePath::CellularRule190->new ()"
       "$path = Math::PlanePath::CellularRule190->new (mirror => 1, n_start => $n)"
           Create and return a new path object.

       "($x,$y) = $path->n_to_xy ($n)"
           Return the X,Y coordinates of point number $n on the path.

       "$n = $path->xy_to_n ($x,$y)"
           Return the point number for coordinates "$x,$y".  $x and $y are each rounded to the
           nearest integer, which has the effect of treating each cell as a square of side 1.  If
           "$x,$y" is outside the pyramid or on a skipped cell the return is "undef".

       "($n_lo, $n_hi) = $path->rect_to_n_range ($x1,$y1, $x2,$y2)"
           The returned range is exact, meaning $n_lo and $n_hi are the smallest and biggest in
           the rectangle.

OEIS

       This pattern is in Sloane's Online Encyclopedia of Integer Sequences in a couple of forms,

           <http://oeis.org/A037576> (etc)

           A037576     whole-row used cells as bits of a bignum
           A071039     \ 1/0 used and unused cells across rows
           A118111     /
           A071041     1/0 used and unused of mirrored rule 246

           n_start=0
             A006578   N at left of each row (X=-Y),
                         and at right of each row when mirrored,
                         being triangular+quartersquare

SEE ALSO

       Math::PlanePath, Math::PlanePath::CellularRule, Math::PlanePath::CellularRule54,
       Math::PlanePath::CellularRule57, Math::PlanePath::PyramidRows

       Cellular::Automata::Wolfram

       <http://mathworld.wolfram.com/Rule190.html>

HOME PAGE

       <http://user42.tuxfamily.org/math-planepath/index.html>

LICENSE

       Copyright 2011, 2012, 2013 Kevin Ryde

       This file is part of Math-PlanePath.

       Math-PlanePath is free software; you can redistribute it and/or modify it under the terms
       of the GNU General Public License as published by the Free Software Foundation; either
       version 3, or (at your option) any later version.

       Math-PlanePath is distributed in the hope that it will be useful, but WITHOUT ANY
       WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
       PURPOSE.  See the GNU General Public License for more details.

       You should have received a copy of the GNU General Public License along with Math-
       PlanePath.  If not, see <http://www.gnu.org/licenses/>.