1Math::PlanePath::HypotOUcstearntC(o3n)tributed Perl DocuMmaetnht:a:tPiloannePath::HypotOctant(3)
2
3
4

NAME

6       Math::PlanePath::HypotOctant -- octant of points in order of hypotenuse
7       distance
8

SYNOPSIS

10        use Math::PlanePath::HypotOctant;
11        my $path = Math::PlanePath::HypotOctant->new;
12        my ($x, $y) = $path->n_to_xy (123);
13

DESCRIPTION

15       This path visits an octant of integer points X,Y in order of their
16       distance from the origin 0,0.  The points are a rising triangle
17       0<=Y<=X,
18
19            8  |                                61
20            7  |                            47  54
21            6  |                        36  43  49
22            5  |                    27  31  38  44
23            4  |                18  23  28  34  39
24            3  |            12  15  19  24  30  37
25            2  |         6   9  13  17  22  29  35
26            1  |     3   5   8  11  16  21  26  33
27           Y=0 | 1   2   4   7  10  14  20  25  32  ...
28               +---------------------------------------
29                X=0  1   2   3   4   5   6   7   8
30
31       For example N=11 at X=4,Y=1 is sqrt(4*4+1*1) = sqrt(17) from the
32       origin.  The next furthest from the origin is X=3,Y=3 at sqrt(18).
33
34       This octant is "primitive" elements X^2+Y^2 in the sense that it
35       excludes negative X or Y or swapped Y,X.
36
37   Equal Distances
38       Points with the same distance from the origin are taken in anti-
39       clockwise order from the X axis, which means by increasing Y.  Points
40       with the same distance occur when there's more than one way to express
41       a given distance as the sum of two squares.
42
43       Pythagorean triples give a point on the X axis and also above.  For
44       example 5^2 == 4^2 + 3^2 has N=14 at X=5,Y=0 simply as 5^2 = 5^2 + 0
45       and then N=15 at X=4,Y=3 for the triple.  Both are 5 away from the
46       origin.
47
48       Combinations like 20^2 + 15^2 == 24^2 + 7^2 occur too, and also with
49       three or more different ways to have the same sum distance.
50
51   Even Points
52       Option "points => "even"" visits just the even points, meaning the sum
53       X+Y even, so X,Y both even or both odd.
54
55           12  |                                    66
56           11  |     points => "even"            57
57           10  |                              49    58
58            9  |                           40    50
59            8  |                        32    41    51
60            7  |                     25    34    43
61            6  |                  20    27    35    45
62            5  |               15    21    29    37
63            4  |            10    16    22    30    39
64            3  |          7    11    17    24    33
65            2  |       4     8    13    19    28    38
66            1  |    2     5     9    14    23    31
67           Y=0 | 1     3     6    12    18    26    36
68               +---------------------------------------
69               X=0  1  2  3  4  5  6  7  8  9 10 11 12
70
71       Even points can be mapped to all points by a 45 degree rotate and flip.
72       N=1,3,6,12,etc on the X axis here is on the X=Y diagonal of all-points.
73       And conversely N=1,2,4,7,10,etc on the X=Y diagonal here is on the X
74       axis of all-points.
75
76           all_X = (even_X + even_Y) / 2
77           all_Y = (even_X - even_Y) / 2
78
79           even_X = (all_X + all_Y)
80           even_Y = (all_X - all_Y)
81
82       The sets of points with equal hypotenuse are the same in the even and
83       all, but the flip takes them in reverse order.  The first such reversal
84       occurs at N=14 and N=15.  In even-points they're at 7,1 and 5,5.  In
85       all-points they're at 5,0 and 4,3 and those two map 5,5 and 7,1, ie.
86       the opposite way around.
87
88   Odd Points
89       Option "points => "odd"" visits just the odd points, meaning sum X+Y
90       odd, so X,Y one odd the other even.
91
92           12  |                                       66
93           11  |        points => "odd"             57
94           10  |                                 47    58
95            9  |                              39    49
96            8  |                           32    41    51
97            7  |                        25    33    42
98            6  |                     20    26    35    45
99            5  |                  14    21    29    37
100            4  |               10    16    22    30    40
101            3  |             7    11    17    24    34
102            2  |          4     8    13    19    28    38
103            1  |       2     5     9    15    23    31
104           Y=0 |    1     3     6    12    18    27    36
105               +------------------------------------------
106               X=0  1  2  3  4  5  6  7  8  9 10 11 12 13
107
108       The X=Y diagonal is excluded because it has X+Y even.
109

FUNCTIONS

111       See "FUNCTIONS" in Math::PlanePath for behaviour common to all path
112       classes.
113
114       "$path = Math::PlanePath::HypotOctant->new ()"
115       "$path = Math::PlanePath::HypotOctant->new (points => $str)"
116           Create and return a new hypot octant path object.  The "points"
117           option can be
118
119               "all"         all integer X,Y (the default)
120               "even"        only points with X+Y even
121               "odd"         only points with X+Y odd
122
123       "($x,$y) = $path->n_to_xy ($n)"
124           Return the X,Y coordinates of point number $n on the path.
125
126           For "$n < 1" the return is an empty list, it being considered the
127           first point at X=0,Y=0 is N=1.
128
129           Currently it's unspecified what happens if $n is not an integer.
130           Successive points are a fair way apart, so it may not make much
131           sense to give an X,Y position in between the integer $n.
132
133       "$n = $path->xy_to_n ($x,$y)"
134           Return an integer point number for coordinates "$x,$y".  Each
135           integer N is considered the centre of a unit square and an "$x,$y"
136           within that square returns N.
137

FORMULAS

139       The calculations are not very efficient currently.  For each Y row a
140       current X and the corresponding hypotenuse X^2+Y^2 are maintained.  To
141       find the next furthest a search through those hypotenuses is made
142       seeking the smallest, including equal smallest, which then become the
143       next N points.
144
145       For "n_to_xy()" an array is built in the object used for repeat
146       calculations.  For "xy_to_n()" an array of hypot to N gives a the first
147       N of given X^2+Y^2 distance.  A search is then made through the next
148       few N for the case there's more than one X,Y of that hypot.
149

OEIS

151       Entries in Sloane's Online Encyclopedia of Integer Sequences related to
152       this path include
153
154           <http://oeis.org/A024507> (etc)
155
156           points="all"
157             A024507   X^2+Y^2 of all points not on X axis or X=Y diagonal
158             A024509   X^2+Y^2 of all points not on X axis
159                         being integers occurring as sum of two non-zero squares,
160                         with repetitions for multiple ways
161
162           points="even"
163             A036702   N on X=Y leading Diagonal
164                         being count of points norm<=k
165
166           points="odd"
167             A057653   X^2+Y^2 values occurring
168                         ie. odd numbers which are sum of two squares,
169                         without repetitions
170

SEE ALSO

172       Math::PlanePath, Math::PlanePath::Hypot,
173       Math::PlanePath::TriangularHypot, Math::PlanePath::PixelRings,
174       Math::PlanePath::PythagoreanTree
175

HOME PAGE

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

LICENSE

180       Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 Kevin Ryde
181
182       This file is part of Math-PlanePath.
183
184       Math-PlanePath is free software; you can redistribute it and/or modify
185       it under the terms of the GNU General Public License as published by
186       the Free Software Foundation; either version 3, or (at your option) any
187       later version.
188
189       Math-PlanePath is distributed in the hope that it will be useful, but
190       WITHOUT ANY WARRANTY; without even the implied warranty of
191       MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
192       General Public License for more details.
193
194       You should have received a copy of the GNU General Public License along
195       with Math-PlanePath.  If not, see <http://www.gnu.org/licenses/>.
196
197
198
199perl v5.28.0                      2017-12-03   Math::PlanePath::HypotOctant(3)
Impressum