Math::PlanePath::GrayCode -- Gray code coordinates
use Math::PlanePath::GrayCode; my $path = Math::PlanePath::GrayCode->new; my ($x, $y) = $path->n_to_xy (123);
This is a mapping of N to X,Y using Gray codes. The default is the form by Christos Faloutsos which is an X,Y split in binary reflected Gray code.
7 | 63-62 57-56 39-38 33-32 | | | | | 6 | 60-61 58-59 36-37 34-35 | 5 | 51-50 53-52 43-42 45-44 | | | | | 4 | 48-49 54-55 40-41 46-47 | 3 | 15-14 9--8 23-22 17-16 | | | | | 2 | 12-13 10-11 20-21 18-19 | 1 | 3--2 5--4 27-26 29-28 | | | | | Y=0 | 0--1 6--7 24-25 30-31 | +------------------------- X=0 1 2 3 4 5 6 7
N is converted to a Gray code, then split by bits to X,Y, and those X,Y converted back from Gray to integer indices. Stepping from N to N+1 changes just one bit of the Gray code and therefore changes just one of X or Y each time.
On the Y axis the values use only digits 0,3 in base 4. On the X axis the values are 2k and 2k+1 where k uses only digits 0,3 in base 4. It happens too that a turn N-1,N,N+1 is always either left +90 or reverse 180, never straight ahead or to the right.
The default is binary, or the radix => $r option can select another radix. This is used for both the Gray code and the digit splitting. For example radix => 4,
radix => $r
radix => 4
radix => 4 | 127-126-125-124 99--98--97--96--95--94--93--92 67--66--65--64 | | | | 120-121-122-123 100-101-102-103 88--89--90--91 68--69--70--71 | | | | 119-118-117-116 107-106-105-104 87--86--85--84 75--74--73--72 | | | | 112-113-114-115 108-109-110-111 80--81--82--83 76--77--78--79 15--14--13--12 19--18--17--16 47--46--45--44 51--50--49--48 | | | | 8-- 9--10--11 20--21--22--23 40--41--42--43 52--53--54--55 | | | | 7-- 6-- 5-- 4 27--26--25--24 39--38--37--36 59--58--57--56 | | | | 0-- 1-- 2-- 3 28--29--30--31--32--33--34--35 60--61--62--63
The apply_type => $str option controls how Gray codes are applied to N and X,Y. It can be one of
apply_type => $str
"TsF" to Gray, split, from Gray (default) "Ts" to Gray, split "Fs" from Gray, split "FsT" from Gray, split, to Gray "sT" split, to Gray "sF" split, from Gray
"T" means integer-to-Gray, "F" means integer-from-Gray, and omitted means no transformation. For example the following is "Ts" which means N to Gray then split, leaving Gray coded values for X,Y.
apply_type => "Ts" 7 | 51--50 52--53 44--45 43--42 | | | | | 6 | 48--49 55--54 47--46 40--41 | 5 | 60--61 59--58 35--34 36--37 ...-66 | | | | | | 4 | 63--62 56--57 32--33 39--38 64--65 | 3 | 12--13 11--10 19--18 20--21 | | | | | 2 | 15--14 8-- 9 16--17 23--22 | 1 | 3-- 2 4-- 5 28--29 27--26 | | | | | Y=0 | 0-- 1 7-- 6 31--30 24--25 | +--------------------------------- X=0 1 2 3 4 5 6 7
This "Ts" is quite attractive because a step from N to N+1 changes just one bit in X or Y alternately, giving 2-D single-digit changes. For example N=19 at X=4 then N=20 at X=6 is a single bit change in X.
N=0,2,8,10,etc on the leading diagonal X=Y is numbers using only digits 0,2 in base 4. The Y axis N=0,3,15,12,etc is numbers using only digits 0,3 in base 4, but in a Gray code order.
The "Fs", "FsT" and "sF" forms effectively treat the input N as a Gray code and convert from it to integers, either before or after split. For "Fs" the effect is little Z parts in various orientations.
apply_type => "sF" 7 | 32--33 37--36 52--53 49--48 | / \ / \ 6 | 34--35 39--38 54--55 51--50 | 5 | 42--43 47--46 62--63 59--58 | \ / \ / 4 | 40--41 45--44 60--61 57--56 | 3 | 8-- 9 13--12 28--29 25--24 | / \ / \ 2 | 10--11 15--14 30--31 27--26 | 1 | 2-- 3 7-- 6 22--23 19--18 | \ / \ / Y=0 | 0-- 1 5-- 4 20--21 17--16 | +--------------------------------- X=0 1 2 3 4 5 6 7
The gray_type option selects what type of Gray code is used. The choices are
gray_type
"reflected" increment to radix-1 then decrement (default) "modular" cycle from radix-1 back to 0
For example in decimal,
integer Gray Gray "reflected" "modular" ------- ----------- --------- 0 0 0 1 1 1 2 2 2 ... ... ... 8 8 8 9 9 9 10 19 19 11 18 10 12 17 11 13 16 12 14 15 13 ... ... ... 17 12 16 18 11 17 19 10 18
Notice on reaching "19" the reflected type runs the low digit down again, a reverse or reflection of the preceding 0 up to 9. The modular form instead continues to increment the low digit, wrapping around from 9 to 0.
In binary modular and reflected are the same (see "Equivalent Combinations" below). There's various other systematic ways to change a single digit successively but many of them are implicitly based on a pre-determined fixed number of bits or digits.
Some option combinations are equivalent,
condition equivalent --------- ---------- radix=2 modular==reflected and TsF==Fs, Ts==FsT radix>2 odd reflected TsF==FsT, Ts==Fs, sT==sF because T==F radix>2 even reflected TsF==Fs, Ts==FsT
In binary radix=2 the "modular" and "reflected" Gray codes are the same because there's only digits 0 and 1 so going forward or backward is the same.
For odd radix and reflected Gray code, the "to Gray" and "from Gray" operations are the same. For example the following table is ternary radix=3. Notice how integer value 012 maps to Gray code 010, and in turn integer 010 maps to Gray code 012. All values are either 2-cycle pairs like that or unchanged like 021.
integer Gray "reflected" (written in ternary) 000 000 001 001 002 002 010 012 011 011 012 010 020 020 021 021 022 022
For even radix and reflected Gray code, "TsF" is equivalent to "Fs", and also "Ts" equivalent to "FsT". This arises from the way the reversing behaves when split across digits of two X,Y values. (In higher dimensions such as a split to 3-D X,Y,Z it's not the same.)
The net effect for distinct paths is
condition distinct combinations --------- --------------------- radix=2 four TsF==Fs, Ts==FsT, sT, sF radix>2 odd / three reflected TsF==FsT, Ts==Fs, sT==sF \ six modular TsF, Ts, Fs, FsT, sT, sF radix>2 even / four reflected TsF==Fs, Ts==FsT, sT, sF \ six modular TsF, Ts, Fs, FsT, sT, sF
In radix => 3 and other odd radices the "reflected" Gray type gives the Peano curve (see Math::PlanePath::PeanoCurve). The "reflected" encoding is equivalent to Peano's "xk" and "yk" complementing.
radix => 3
| 53--52--51 38--37--36--35--34--33 | | | 48--49--50 39--40--41 30--31--32 | | | 47--46--45--44--43--42 29--28--27 | 6-- 7-- 8-- 9--10--11 24--25--26 | | | 5-- 4-- 3 14--13--12 23--22--21 | | | 0-- 1-- 2 15--16--17--18--19--20
See "FUNCTIONS" in Math::PlanePath for the behaviour common to all path classes.
$path = Math::PlanePath::GrayCode->new ()
$path = Math::PlanePath::GrayCode->new (radix => $r, apply_type => $str, gray_type => $str)
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. Points begin at 0 and if $n < 0 then the return is an empty list.
$n
$n < 0
$n = $path->n_start ()
Return the first N on the path, which is 0.
This path is in Sloane's Online Encyclopedia of Integer Sequences in a few forms,
http://oeis.org/A163233 (etc) A163233 "sF" N values by diagonals, same axis start A163234 inverse permutation A163235 "sF" N values by diagonals, opp axis start A163236 inverse permutation A163237 "sF" N values by diagonals, same axis, flip digits 2,3 A163238 inverse permutation A163239 "sF" N values by diagonals, opp axis, flip digits 2,3 A163240 inverse permutation A163242 "sF" N sums along diagonals A163478 sums divided by 3
The Gray code conversions themselves (not directly offered by the PlanePath code here) are variously for instance binary A003188, ternary reflected A128173 and modular A105530, decimal reflected A003100 and modular A098488.
Math::PlanePath, Math::PlanePath::ZOrderCurve, Math::PlanePath::PeanoCurve, Math::PlanePath::CornerReplicate
http://user42.tuxfamily.org/math-planepath/index.html
Copyright 2011, 2012 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/>.
To install Math::PlanePath, copy and paste the appropriate command in to your terminal.
cpanm
cpanm Math::PlanePath
CPAN shell
perl -MCPAN -e shell install Math::PlanePath
For more information on module installation, please visit the detailed CPAN module installation guide.