# Copyright 2011, 2012, 2013, 2014 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/>.


# SB,CW N with same X,Y is those N which are palindromes below high 1-bit
# as noted Claudio Bonanno and Stefano Isola, ``Orderings of the Rationals
# and Dynamical Systems'', May 16, 2008.
# cf A006995 binary palindromes, so always odd
#    A178225 characteristic of binary palindromes
#    A048700 binary palindromes odd length
#    A048701 binary palindromes even length
# A044051 binary palindromes (B+1)/2, B odd so B+1 even
# A044051-1 = (B-1)/2 strips low 1-bit to be palindromes below high 1-bit

# Boyko B. Bantchev, "Fraction Space Revisited"
# http://www.math.bas.bg/bantchev/articles/fractions.pdf

# cf Ronald L. Graham, Donald E. Knuth, and Oren Patashnik, Concrete
# Mathematics: A Foundation for Computer Science, Second
# Edition. Addison-Wesley. 1994.
# On Stern-Brocot tree.

# cf A054429 permutation reverse within binary row
#    A065249 - permutation SB X -> X/2
#    A065250 - permutation SB X -> 2X
#    A057114 - permutation SB X -> X+1
#    A057115 - permutation SB X -> X-1
#

#                    high-to-low   low-to-high
# (X+Y)/Y  Y/(X+Y)     HCS            AYT
# X/(X+Y)  (X+Y)/Y      CW            SB    \ alt bit flips
# Y/(X+Y)  (X+Y)/X     Drib          Bird   /
#
#     9  10                    12  10
# 8      11                 8      14
#        12  13                     9  13
#            14                        11
#            15                        15
#
# Stern-Brocot              Calkin-Wilf


#------------------------------------------------------------------------------
# HCS turn left when even number of 1-bits in N+1
#     turn right when odd number of 1-bits in N+1
#
# A010059 start=0: 1,0,0,1,0,1,1,0,0,1,1,0,1,0,0,1,0,1,1,0,1,0,0,1,1,0,0,1,0,1,1,0,0,1,1,0,1,0,0,1,1,0,0,1,0,1,1,0,1,0,0,1,0,1,1,0,0,1,1,0,1,0,0,1,0,1,1,0,1,0,0,1,1,0,0,1,0,1,1,0,1,0,0,1,0,1,1,0,0,1,1,0,1,0,0,1,1,0,0,1,0
#   match 1,0,1,1,0,0,1,1,0,1,0,0,1,0,1,1,0,1,0,0,1,1,0,0,1,0,1,1,0,0,1,1,0,1,0,0,1,1,0,0,1,0
#   PlanePathTurn planepath=RationalsTree,tree_type=HCS,  turn_type=Left
#
# A010060 start=0: 0,1,1,0,1,0,0,1,1,0,0,1,0,1,1,0,1,0,0,1,0,1,1,0,0,1,1,0,1,0,0,1,1,0,0,1,0,1,1,0,0,1,1,0,1,0,0,1,0,1,1,0,1,0,0,1,1,0,0,1,0,1,1,0,1,0,0,1,0,1,1,0,0,1,1,0,1,0,0,1,0,1,1,0,1,0,0,1,1,0,0,1,0,1,1,0,0,1,1,0,1
#   match 0,1,0,0,1,1,0,0,1,0,1,1,0,1,0,0,1,0,1,1,0,0,1,1,0,1,0,0,1,1,0,0,1,0,1,1,0,0,1,1,0,1
#   PlanePathTurn planepath=RationalsTree,tree_type=HCS,  turn_type=Right
#
# 10  |     768        50                  58       896
#  9  |     384   49        52   60        57  448       640
#  8  |     192        27        31       224       320
#  7  |      96   25   26   30   29  112       160   41   42
#  6  |      48                  56        80
#  5  |      24   13   15   28        40   21   23   44
#  4  |      12        14        20        22        36
#  3  |       6    7        10   11        18   19        34
#  2  |       3         5         9        17        33
#  1  |       1    2    4    8   16   32   64  128  256  512
# Y=0 |
#     +-----------------------------------------------------
#       X=0   1    2    3    4    5    6    7    8    9   10
#
#                               1/1
#                  /------------- -------------\
#               2/1                             1/2               2,3 L,R
#          /----   ----\                   /----   ----\
#       3/1             3/2             1/3             2/3    4,5,6,7 L,L,R,R
#      /   \           /   \           /   \           /   \      8        12
#   4/1     5/2     4/3     5/3     1/4     2/5     3/4     3/5   L,L,R,L, R,R,L,R
#  /   \   /   \   /   \   /   \   /   \   /   \   /   \   /   \
# 5/1 7/2 7/3 8/3 5/4 7/5 7/4 8/5 1/5 2/7 3/7 3/8 4/5 5/7 4/7 5/8
#
#         *
#        / \                        U=0 = X+Y, Y           shear
#       /   *                       D=1 = Y,   X+Y         shear+transpose
#      /     \a  = 0.1^k.1
#     N
#      \     /b  = 1.0^k.0
#       \   *
#        \ / \c  = 1.0^k.1         c=even bits, left
#         *
#
# F[-1]=1 F[0]=0 F[1]=1 F[2]=1 F[3]=2 F[4]=3 F[5]=5 ...
# 1^k is F[k-1]*X+F[k]*Y, F[k]*X+F[k+1]*Y
#  X   ,     Y    0
#     Y,  X+ Y    1
#  X+ Y,  X+2Y    2
#  X+2Y, 2X+3Y    3
# 2X+3Y, 3X+5Y    4
#
# then aX = F[k]*X+F[k+1]*Y + F[k+1]*X+F[k+2]*Y
#         = (F[k]+F[k+1])*X + (F[k+1]+F[k+2])*Y
#         = F[k+2]*X + F[k+3]*Y
#      aY = F[k+1]*X + F[k+2]*Y                 near X=phi*Y big
#
# 0^k is X+k*Y, Y
# so bX = Y
#    bY = X+k*Y + Y = X+(k+1)*Y                 near Y axis
#
# c1X = Y
# c1Y = X+Y
# c2X = Y + k*(X+Y) = k*X + (k+1)*Y
# c2Y = X+Y
# cX = X+Y
# cY = k*X + (k+1)*Y + X+Y = (k+1)X + (k+2)Y    near X=Y

#
#         *
#        / \ /a  = 0.1^k.0
#       /   *
#      /     \b  = 0.1^k.1
#     N
#      \     /c  = 1.0^k.1     c=even bits, left
#       \   *
#        \ /
#         *
#------------------------------------------------------------------------------

package Math::PlanePath::RationalsTree;
use 5.004;
use strict;
use Carp 'croak';
#use List::Util 'max';
*max = \&Math::PlanePath::_max;

use vars '$VERSION', '@ISA';
$VERSION = 117;
use Math::PlanePath;
@ISA = ('Math::PlanePath');

use Math::PlanePath::Base::Generic
  'is_infinite',
  'round_nearest';
use Math::PlanePath::Base::Digits
  'round_down_pow',
  'bit_split_lowtohigh',
  'digit_join_lowtohigh';
*_divrem = \&Math::PlanePath::_divrem;

use Math::PlanePath::CoprimeColumns;
*_coprime = \&Math::PlanePath::CoprimeColumns::_coprime;

# uncomment this to run the ### lines
#use Smart::Comments;


use constant parameter_info_array =>
  [ { name            => 'tree_type',
      share_key       => 'tree_type_rationalstree',
      display         => 'Tree Type',
      type            => 'enum',
      default         => 'SB',
      choices         => ['SB','CW','AYT','HCS','Bird','Drib','L',],
      choices_display => ['SB','CW','AYT','HCS','Bird','Drib','L',],
    },
  ];

use constant class_x_negative => 0;
use constant class_y_negative => 0;
sub x_minimum {
  my ($self) = @_;
  return ($self->{'tree_type'} eq 'L' ? 0 : 1);
}
use constant y_minimum => 1;
use constant gcdxy_maximum => 1;  # no common factor
use constant tree_num_children_list => (2); # complete binary tree
use constant tree_n_to_subheight => undef; # complete tree, all infinity

{
  my %absdy_minimum = (# SB   => 0,
                       CW   => 1,
                       # AYT  => 0,
                       # Bird => 0,
                       # Drib => 0,
                       L    => 1);
  sub absdy_minimum {
    my ($self) = @_;
    return $absdy_minimum{$self->{'tree_type'}} || 0;
  }
}

{
  # Drib apparent minimum dX=k dY=2*k+1 approaches dX=1,dY=2
  my %dir_minimum_dxdy = (CW   => [0,1],
                          Drib => [1,2],
                          L    => [1,1], # at N=0 dX=1,dY=1
                         );
  sub dir_minimum_dxdy {
    my ($self) = @_;
    return @{$dir_minimum_dxdy{$self->{'tree_type'}} || [1,0]};
  }
}
{
  my %dir_maximum_dxdy
    = (SB   => [1,-1],
       # CW   => [0,0],

       Bird => [1,-1],
       # Drib => [0,0],

       HCS  => [2,-1],
       # AYT  => [0,0],
       # L    => [0,0], # at 2^k-1 dX=k+1,dY=-1 so approach Dir=4
      );
  sub dir_maximum_dxdy {
    my ($self) = @_;
    return @{$dir_maximum_dxdy{$self->{'tree_type'}} || [0,0]};
  }
}

#------------------------------------------------------------------------------

my %attributes = (CW   => [ n_start => 1, ],
                  SB   => [ n_start => 1, reverse_bits => 1 ],
                  Drib => [ n_start => 1, alternating => 1 ],
                  Bird => [ n_start => 1, alternating => 1, reverse_bits => 1 ],
                  AYT  => [ n_start => 1, sep1s => 1 ],
                  HCS  => [ n_start => 1, sep1s => 1, reverse_bits => 1 ],
                  L    => [ n_start => 0 ],
                 );

sub new {
  my $self = shift->SUPER::new(@_);

  my $tree_type = ($self->{'tree_type'} ||= 'SB');
  my $attributes = $attributes{$tree_type}
    || croak "Unrecognised tree type: ",$tree_type;
  %$self = (%$self, @$attributes);

  return $self;
}

sub n_to_xy {
  my ($self, $n) = @_;
  ### RationalsTree n_to_xy(): "$n"

  if ($n < $self->{'n_start'}) { return; }
  if (is_infinite($n)) { return ($n,$n); }

  # what to do for fractional $n?
  {
    my $int = int($n);
    if ($n != $int) {
      ### frac ...
      my $frac = $n - $int;  # inherit possible BigFloat/BigRat
      my ($x1,$y1) = $self->n_to_xy($int);
      my ($x2,$y2) = $self->n_to_xy($int+1);
      my $dx = $x2-$x1;
      my $dy = $y2-$y1;
      ### x1,y1: "$x1, $y1"
      ### x2,y2: "$x2, $y2"
      ### dx,dy: "$dx, $dy"
      ### result: ($frac*$dx + $x1).', '.($frac*$dy + $y1)
      return ($frac*$dx + $x1, $frac*$dy + $y1);
    }
    $n = $int;
  }

  my $zero = ($n * 0);  # inherit bignum 0
  my $one = $zero + 1;  # inherit bignum 1

  if ($self->{'n_start'} == 0) {
    # L tree adjust;
    $n += 2;
  }

  my @nbits = bit_split_lowtohigh($n);
  pop @nbits;
  ### lowtohigh sans high: @nbits

  if (! $self->{'reverse_bits'}) {
    @nbits = reverse @nbits;
    ### reverse to: @nbits
  }

  my $x = $one;
  my $y = $one;

  if ($self->{'sep1s'}) {
    foreach my $nbit (@nbits) {
      $x += $y;
      if ($nbit) {
        ($x,$y) = ($y,$x);
      }
    }

  } elsif ($self->{'alternating'}) {
    foreach my $nbit (@nbits) {
      ($x,$y) = ($y,$x);
      if ($nbit) {
        $x += $y;     # (x,y) -> (x+y,x), including swap
      } else {
        $y += $x;     # (x,y) -> (y,x+y), including swap
      }
    }

  } elsif ($self->{'tree_type'} eq 'L') {
    my $sub = 2;
    foreach my $nbit (@nbits) {
      if ($nbit) {
        $y += $x;     # (x,y) -> (x,x+y)
        $sub = 0;
      } else {
        $x += $y;     # (x,y) -> (x+y,y)
      }
    }
    $x -= $sub;   # -2 at N=00...000 all zero bits

  } else {
    ### nbits apply CW: @nbits
    foreach my $nbit (@nbits) {   # high to low
      if ($nbit) {
        $x += $y;     # (x,y) -> (x+y,y)
      } else {
        $y += $x;     # (x,y) -> (x,x+y)
      }
    }
  }
  ### result: "$x, $y"
  return ($x,$y);
}

sub xy_is_visited {
  my ($self, $x, $y) = @_;
  $x = round_nearest ($x);
  $y = round_nearest ($y);
  if ($self->{'tree_type'} eq 'L' && $x == 0 && $y == 1) {
    return 1;
  }
  if ($x < 1
      || $y < 1
      || ! _coprime($x,$y)) {
    return 0;
  }
  return 1;
}

sub xy_to_n {
  my ($self, $x, $y) = @_;
  $x = round_nearest ($x);
  $y = round_nearest ($y);
  ### RationalsTree xy_to_n(): "$x,$y   $self->{'tree_type'}"

  if ($x < $self->{'n_start'} || $y < 1) {
    return undef;
  }
  if (is_infinite($x)) {
    return $x;
  }
  if (is_infinite($y)) {
    return $y;
  }

  my @quotients = _xy_to_quotients($x,$y)
    or return undef;  # $x,$y have a common factor
  ### @quotients

  my @nbits;
  if ($self->{'sep1s'}) {
    $quotients[0]++;  # the integer part, making it 1 or more
    foreach my $q (@quotients) {
      push @nbits, (0) x ($q-1), 1;   # runs of "000..0001"
    }
    pop @nbits;  # no high 1-bit separator

  } else {
    if ($quotients[0] < 0) {   # X=0,Y=1 in tree_type="L"
      return $self->{'n_start'};
    }

    my $bit = 1;
    foreach my $q (@quotients) {
      push @nbits, ($bit) x $q;
      $bit ^= 1;     # alternate runs of "00000" or "11111"
    }
    ### nbits in quotient order: @nbits

    if ($self->{'alternating'}) {
      # Flip every second bit, starting from the second lowest.
      for (my $i = 1; $i <= $#nbits; $i += 2) {
        $nbits[$i] ^= 1;
      }
    }

    if ($self->{'tree_type'} eq 'L') {
      # Flip all bits.
      my $anyones = 0;
      foreach my $nbit (@nbits) {
        $nbit ^= 1;   # mutate array
        $anyones ||= $nbit;
      }
      unless ($anyones) {
        push @nbits, 0,0;
      }
    }
  }

  if ($self->{'reverse_bits'}) {
    @nbits = reverse @nbits;
  }
  push @nbits, 1;   # high 1-bit

  ### @nbits
  my $n = digit_join_lowtohigh (\@nbits, 2,
                                $x*0*$y);   # inherit bignum 0
  if ($self->{'tree_type'} eq 'L') {
    return $n-2;
  } else {
    return $n;
  }
}

# Return a list of the quotients from Euclid's greatest common divisor
# algorithm on X,Y.  This is also the terms of the continued fraction
# expansion of rational X/Y.
#
# The last term, the last in the list, is decremented since this is what the
# code above requires.  This term is the top-most quotient in for example
# gcd(7,1) is 7=7*1+0 with q=7 returned as 6.
#
# If $x,$y have a common factor then the return is an empty list.
# If $x,$y have no common factor then the returned list is always one or
# more quotients.
#
sub _xy_to_quotients {
  my ($x,$y) = @_;
  my @ret;
  for (;;) {
    my ($q, $r) = _divrem($x,$y);
    push @ret, $q;
    last unless $r;
    $x = $y;
    $y = $r;
  }

  if ($y > 1) {
    ### found Y>1 common factor, no N at this X,Y ...
    return;
  }
  $ret[-1]--;
  return @ret;
}


# not exact
sub rect_to_n_range {
  my ($self, $x1,$y1, $x2,$y2) = @_;
  ### rect_to_n_range()

  $x1 = round_nearest ($x1);
  $y1 = round_nearest ($y1);
  $x2 = round_nearest ($x2);
  $y2 = round_nearest ($y2);

  ($x1,$x2) = ($x2,$x1) if $x1 > $x2;
  ($y1,$y2) = ($y2,$y1) if $y1 > $y2;
  ### $x2
  ### $y2

  if ($x2 < 1 || $y2 < 1) {
    ### no values, rect below first quadrant
    if ($self->{'n_start'}) {
      return (1,0);
    } else {
      return (0,0);
    }
  }

  my $zero = ($x1 * 0 * $y1 * $x2 * $y2);  # inherit bignum
  ### $zero

  if ($x1 < 1) { $x1 = 1; }
  if ($y1 < 1) { $y1 = 1; }

  # # big x2, small y1
  # # big y2, small x1
  # my $level = _bingcd_max ($y2,$x1);
  # ### $level
  # {
  #   my $l2 = _bingcd_max ($x2,$y1);
  #   ### $l2
  #   if ($l2 > $level) { $level = $l2; }
  # }

  my $level = max($x1,$x2,$y1,$y2);

  return ($self->{'n_start'},
          $self->{'n_start'} + (2+$zero) ** ($level + 3));
}

sub _bingcd_max {
  my ($x,$y) = @_;
  ### _bingcd_max(): "$x,$y"

  if ($x < $y) { ($x,$y) = ($y,$x) }

  ### div: int($x/$y)
  ### bingcd: int($x/$y) + $y

  return int($x/$y) + $y + 1;
}

#   ### fib: _fib_log($y)
# # ENHANCE-ME: log base PHI, or something close for BigInt
# # 2*log2() means log base sqrt(2)=1.4 instead of PHI=1.6
# #
# # use constant 1.02; # for leading underscore
# # use constant _PHI => (1 + sqrt(5)) / 2;
# #
# sub _fib_log {
#   my ($x) = @_;
#   ### _fib_log(): $x
#   my $f0 = ($x * 0);
#   my $f1 = $f0 + 1;
#   my $count = 0;
#   while ($x > $f0) {
#     $count++;
#     ($f0,$f1) = ($f1,$f0+$f1);
#   }
#   return $count;
# }

#------------------------------------------------------------------------------
use constant tree_num_roots => 1;

# N=1 basis children 2N,2N+1
# N=S basis 2(N-(S-1))+(S-1)
#           = 2N - 2(S-1) + (S-1)
#           = 2N - (S-1)
sub tree_n_children {
  my ($self, $n) = @_;
  my $n_start = $self->{'n_start'};
  if ($n >= $n_start) {
    $n = 2*$n - $n_start;
    return ($n+1, $n+2);
  } else {
    return;
  }
}
sub tree_n_num_children {
  my ($self, $n) = @_;
  return ($n >= $self->{'n_start'} ? 2 : undef);
}
sub tree_n_parent {
  my ($self, $n) = @_;
  $n = $n - $self->{'n_start'}; # N=0 basis, and warn if $n==undef
  if ($n > 0) {
    return int(($n-1)/2) + $self->{'n_start'};
  } else {
    return undef;
  }
}
sub tree_n_to_depth {
  my ($self, $n) = @_;
  ### RationalsTree tree_n_to_depth(): $n
  $n = $n - $self->{'n_start'}; # N=0 basis, and warn if $n==undef
  unless ($n >= 0) {
    return undef;
  }
  my ($pow, $exp) = round_down_pow ($n+1, 2);
  return $exp;
}

sub tree_depth_to_n {
  my ($self, $depth) = @_;
  return ($depth >= 0
          ? 2**$depth + $self->{'n_start'}-1
          : undef);
}
# (2^(d+1)+s-1)-1 = 2^(d+1)+s-2
sub tree_depth_to_n_end {
  my ($self, $depth) = @_;
  return ($depth >= 0
          ? 2**($depth+1) + $self->{'n_start'}-2
          : undef);
}
sub tree_depth_to_n_range {
  my ($self, $depth) = @_;
  if ($depth >= 0) {
    my $pow = 2**$depth;
    return ($pow + $self->{'n_start'}-1, 2*$pow + $self->{'n_start'}-2);
  }
  return; # no such $depth
}
sub tree_depth_to_width {
  my ($self, $depth) = @_;
  return ($depth >= 0
          ? 2**$depth
          : undef);
}

1;
__END__


  # xy_to_n() post-processing CW to make AYT
  #
  # if ($self->{'tree_type'} eq 'AYT') {
  #   # AYT shift-xor "N xor (N<<1)" each bit xor with the one below it.  But
  #   # the high 1-bit is left unchanged, hence "$#nbits-1".  At the low end
  #   # for "N<<1" a 1-bit is shifted in, which is arranged by letting $i-1
  #   # become -1 to get the endmost array element which is the high 1-bit.
  #   foreach my $i (reverse 0 .. $#nbits-1) {
  #     $nbits[$i] ^= $nbits[$i-1];
  #   }
  # }


=for stopwords eg Ryde OEIS ie Math-PlanePath coprime encodings Moritz Achille Brocot Stern-Brocot mediant Calkin Wilf Calkin-Wilf 1abcde 1edcba Andreev Yu-Ting Shen AYT Ralf Hinze Haskell subtrees xoring Drib RationalsTree unflipped GCD Luschny Jerzy Czyz Minkowski Nstart Shallit's HCS Ndepth N-Ndepth Nparent subtree LRRL parameterization parameterized Jacobsthal Thue-Morse ceil Matematicheskoe Prosveshchenie Ser DOI

=head1 NAME

Math::PlanePath::RationalsTree -- rationals by tree

=head1 SYNOPSIS

 use Math::PlanePath::RationalsTree;
 my $path = Math::PlanePath::RationalsTree->new (tree_type => 'SB');
 my ($x, $y) = $path->n_to_xy (123);

=head1 DESCRIPTION

This path enumerates reduced rational fractions X/Y E<gt> 0, ie. X and Y
having no common factor.

The rationals are traversed by rows of a binary tree which represents a
coprime pair X,Y by steps of a subtraction-only greatest common divisor
algorithm which proves them coprime.  Or equivalently by bit runs with
lengths which are the quotients in the division-based Euclidean GCD
algorithm and which are also the terms in the continued fraction
representation of X/Y.

The SB, CW, AYT, HCS, Bird and Drib trees all have the same set of X/Y
rationals in a row, but in a different order due to different encodings of
the N value.  See the author's mathematical write-up for a proof that these
are the only trees with a fixed set of matrices.

=over

L<http://user42.tuxfamily.org/rationals/index.html>

=back

The bit runs mean that N values are quite large for relatively modest sized
rationals.  For example in the SB tree 167/3 is N=288230376151711741, a
58-bit number.  The tendency is for the tree to make excursions out to large
rationals while only slowly filling in small ones.  The worst is the integer
X/1 for which N has X many bits, and similarly 1/Y is Y bits.

See F<examples/rationals-tree.pl> in the Math-PlanePath sources for a
printout of all the trees.

=head2 Stern-Brocot Tree

X<Stern, Moritz>X<Brocot, Achille>The default C<tree_type=E<gt>"SB"> is the
tree of Moritz Stern and Achille Brocot.

    depth    N                                                  
    -----  -------                                              
      0      1                         1/1                      
                                 ------   ------
      1    2 to 3             1/2               2/1             
                             /    \            /   \
      2    4 to 7         1/3      2/3      3/2      3/1        
                          | |      | |      | |      | |
      3    8 to 15     1/4  2/5  3/5 3/4  4/3 5/3  5/2 4/1      

Within a row the fractions increase in value.  Each row of the tree is a
repeat of the previous row as first X/(X+Y) and then (X+Y)/Y.  For example

    depth=1    1/2, 2/1

    depth=2    1/3, 2/3    X/(X+Y) of previous row
               3/2, 3/1    (X+Y)/Y of previous row

Plotting the N values by X,Y is as follows.  The unused X,Y positions are
where X and Y have a common factor.  For example X=6,Y=2 has common factor 2
so is never reached.

    tree_type => "SB"

    10  |    512        35                  44       767
     9  |    256   33        39   40        46  383       768
     8  |    128        18        21       191       384
     7  |     64   17   19   20   22   95       192   49   51
     6  |     32                  47        96
     5  |     16    9   10   23        48   25   26   55
     4  |      8        11        24        27        56
     3  |      4    5        12   13        28   29        60
     2  |      2         6        14        30        62
     1  |      1    3    7   15   31   63  127  255  511 1023
    Y=0 |
         ----------------------------------------------------
         X=0   1    2    3    4    5    6    7    8    9   10

The X=1 vertical is the fractions 1/Y which is at the left of each tree row,
at N value

    Nstart = 2^depth

The Y=1 horizontal is the X/1 integers at the end each row which is

    Nend = 2^(depth+1)-1

Numbering nodes of the tree by rows starting from 1 means N without the high
1 bit is the offset into the row.  For example binary N="1011" is "011"=3
into the row.  Those bits after the high 1 are also the directions to follow
down the tree to a node, with 0=left and 1=right.  So N="1011" binary goes
from the root 0=left then twice 1=right to reach X/Y=3/4 at N=11 decimal.

=cut

# O/O O/E E/O   X/(X+Y) -> O/E O/O E/O        A B C -> B A C
#               (X+Y)/Y -> E/O O/E O/O              -> C B A

=pod

=head2 Stern-Brocot Mediant

Writing the parents between the children as an "in-order" tree traversal to
a given depth has all values in increasing order (the same as each row
individually is in increasing order).

                 1/1
         1/2      |      2/1
     1/3  |  2/3  |  3/2  |  3/1
      |   |   |   |   |   |   |

     1/3 1/2 2/3 1/1 3/2 2/1 3/1
                    ^
                    |
                    next level (1+3)/(1+2) = 4/3 mediant

New values at the next level of this flattening are a "mediant"
(x1+x2)/(y1+y2) formed from the left and right parent.  So the next level
4/3 shown is left parent 1/1 and right parent 3/2 giving mediant
(1+3)/(1+2)=4/3.  At the left end a preceding 0/1 is imagined.  At the right
end a following 1/0 is imagined, so as to have 1/(depth+1) and (depth+1)/1
at the ends for a total 2^depth many new values.

The turn sequence left or right along the row depth E<gt>= 2 is by a
repeating LRRL pattern, except the first and last are always R.  (See the
author's mathematical write-up for details.)

    RRRL,LRRL,LRRL,LRRL,LRRL,LRRL,LRRL,LRRR   # row N=32 to N=63

=head2 Calkin-Wilf Tree

X<Calkin, Neil>X<Wilf, Herbert>C<tree_type=E<gt>"CW"> selects the tree of
Calkin and Wilf,

=over

Neil Calkin and Herbert Wilf, "Recounting the Rationals", American
Mathematical Monthly, volume 107, number 4, April 2000, pages 360-363.

L<http://www.math.upenn.edu/~wilf/reprints.html>
L<http://www.math.upenn.edu/~wilf/website/recounting.pdf>
L<http://www.jstor.org/stable/2589182>

=back

As noted above, the values within each row are the same as the Stern-Brocot,
but in a different order.

    N=1                             1/1
                              ------   ------
    N=2 to N=3             1/2               2/1
                          /    \            /    \
    N=4 to N=7         1/3      3/2      2/3      3/1
                       | |      | |      | |      | |
    N=8 to N=15     1/4  4/3  3/5 5/2  2/5 5/3  3/4 4/1

Going by rows the denominator of one value becomes the numerator of the
next.  So at 4/3 the denominator 3 becomes the numerator of 3/5 to the
right.  These values are Stern's diatomic sequence.

Each row is symmetric in reciprocals, ie. reading from right to left is the
reciprocals of reading left to right.  The numerators read left to right are
the denominators read right to left.

A node descends as

          X/Y
        /     \
    X/(X+Y)  (X+Y)/Y

Taking these formulas in reverse up the tree shows how it relates to a
subtraction-only greatest common divisor.  At a given node the smaller of P
or Q is subtracted from the bigger,

       P/(Q-P)         (P-Q)/P
      /          or        \
    P/Q                    P/Q

Plotting the N values by X,Y is as follows.  The X=1 vertical and Y=1
horizontal are the same as the SB above, but the values in between are
re-ordered.

    tree_type => "CW"

    10  |      512        56                  38      1022
     9  |      256   48        60   34        46  510       513
     8  |      128        20        26       254       257
     7  |       64   24   28   18   22  126       129   49   57
     6  |       32                  62        65
     5  |       16   12   10   30        33   25   21   61
     4  |        8        14        17        29        35
     3  |        4    6         9   13        19   27        39
     2  |        2         5        11        23        47
     1  |        1    3    7   15   31   63  127  255  511 1023
    Y=0 |
         -------------------------------------------------------------
           X=0   1    2    3    4    5    6    7    8    9   10

At each node the left leg is S<X/(X+Y) E<lt> 1> and the right leg is
S<(X+Y)/Y E<gt> 1>, which means N is even above the X=Y diagonal and odd
below.  In general each right leg increments the integer part of the
fraction,

    X/Y                       right leg each time
    (X+Y)/Y   = 1 + X/Y
    (X+2Y)/Y  = 2 + X/Y
    (X+3Y)/Y  = 3 + X/Y
    etc

This means the integer part is the trailing 1-bits of N,

    floor(X/Y) = count trailing 1-bits of N
    eg. 7/2 is at N=23 binary "10111"
        which has 3 trailing 1-bits for floor(7/2)=3

N values for the SB and CW trees are converted by reversing bits except the
highest.  So at a given X,Y position

    SB  N = 1abcde         SB <-> CW by reversing bits
    CW  N = 1edcba         except the high 1-bit

For example at X=3,Y=4 the SB tree has N=11 = "1011" binary and the CW has
N=14 binary "1110", a reversal of the bits below the high 1.

N to X/Y in the CW tree can be calculated keeping track of just an X,Y pair
and descending to X/(X+Y) or (X+Y)/Y using the bits of N from high to low.
The relationship between the SB and CW N's means the same can be used to
calculate the SB tree by taking the bits of N from low to high instead.

See also L<Math::PlanePath::ChanTree> for a generalization of CW to ternary
or higher trees, ie. descending to 3 or more children at each node.

=head2 Yu-Ting and Andreev Tree

X<Andreev, D.N.>X<Yu-Ting, Shen>C<tree_type=E<gt>"AYT"> selects the tree
described independently by Yu-Ting and Andreev.

=over

Shen Yu-Ting, "A Natural Enumeration of Non-Negative Rational Numbers
-- An Informal Discussion", American Mathematical Monthly, 87, 1980,
pages 25-29.  L<http://www.jstor.org/stable/2320374>

D. N. Andreev, "On a Wonderful Numbering of Positive Rational Numbers",
Matematicheskoe Prosveshchenie, Ser. 3, 1, 1997, pages 126-134
L<http://mi.mathnet.ru/mp12>

=back

=cut

# Andreev also at
# L<http://files.school-collection.edu.ru/dlrstore/d62f7b96-a780-11dc-945c-d34917fee0be/i2126134.pdf>

=pod

Their constructions are a one-to-one mapping between integer N and rational
X/Y as a way of enumerating the rationals.  This is not designed to be a
tree as such, but the result is the same 2^level rows as the above trees.
The X/Y values within each row are the same, but in a different order.

    N=1                             1/1
                              ------   ------
    N=2 to N=3             2/1               1/2
                          /    \            /    \
    N=4 to N=7         3/1      1/3      3/2      2/3
                       | |      | |      | |      | |
    N=8 to N=15     4/1  1/4  4/3 3/4  5/2 2/5  5/3 3/5

Each fraction descends as follows.  The left is an increment and the right
is reciprocal of the increment.

            X/Y
          /     \
    X/Y + 1     1/(X/Y + 1)

which means

          X/Y
        /     \
    (X+Y)/Y  Y/(X+Y)

The left leg (X+Y)/Y is the same the CW has on its right leg.  But Y/(X+Y)
is not the same as the CW (the other there being X/(X+Y)).

The left leg increments the integer part, so the integer part is given by
(in a fashion similar to CW 1-bits above)

    floor(X/Y) = count trailing 0-bits of N
                 plus one extra if N=2^k

N=2^k is one extra because its trailing 0-bits started from N=1 where
floor(1/1)=1 whereas any other odd N starts from some floor(X/Y)=0.

X<Fibonacci numbers>The Y/(X+Y) right leg forms the Fibonacci numbers
F(k)/F(k+1) at the end of each row, ie. at Nend=2^(level+1)-1.  And as noted
by Andreev, successive right leg fractions N=4k+1 and N=4k+3 add up to 1,

    X/Y at N=4k+1  +  X/Y at N=4k+3  =  1
    Eg. 2/5 at N=13 and 3/5 at N=15 add up to 1

Plotting the N values by X,Y gives

=cut

# math-image --path=RationalsTree,tree_type=AYT --all --output=numbers_xy --size=70x11

=pod

    tree_type => "AYT"

    10  |     513        41                  43       515
     9  |     257   49        37   39        51  259       514
     8  |     129        29        31       131       258
     7  |      65   25   21   23   27   67       130   50   42
     6  |      33                  35        66
     5  |      17   13   15   19        34   26   30   38
     4  |       9        11        18        22        36
     3  |       5    7        10   14        20   28        40
     2  |       3         6        12        24        48
     1  |       1    2    4    8   16   32   64  128  256  512
    Y=0 |
         ----------------------------------------------------
          X=0   1    2    3    4    5    6    7    8    9   10

N=1,2,4,8,etc on the Y=1 horizontal is the X/1 integers at
Nstart=2^level=2^X.  N=1,3,5,9,etc in the X=1 vertical is the 1/Y
fractions.  Those fractions always immediately follow the
corresponding integer, so N=Nstart+1=2^(Y-1)+1 in that column.

In each node the left leg (X+Y)/Y E<gt> 1 and the right leg Y/(X+Y) E<lt> 1,
which means odd N is above the X=Y diagonal and even N is below.

X<Kepler, Johannes>The tree structure corresponds to Johannes Kepler's tree
of fractions (see L<Math::PlanePath::FractionsTree>).  That tree starts from
1/2 and makes fractions A/B with AE<lt>B by descending to A/(A+B) and
B/(A+B).  Those descents are the same as the AYT tree and the two are
related simply by

    A = Y        AYT denominator is Kepler numerator
    B = X+Y      AYT sum num+den is the Kepler denominator

    X = B-A      inverse
    Y = A

=head2 HCS Continued Fraction

X<Hanna, Paul D.>X<Czyz, Jerzy>X<Self, Will>C<tree_type=E<gt>"HCS"> selects
continued fraction terms coded as bit runs 1000...00 from high to low, as
per Paul D. Hanna and independently Czyz and Self.

=over

L<http://oeis.org/A071766>

Jerzy Czyz and William Self, "The Rationals Are Countable: Euclid's
Proof", The College Mathematics Journal, volume 34, number 5,
November 2003, page 367.
L<http://www.jstor.org/stable/3595818>

L<http://www.cut-the-knot.org/do_you_know/countRatsCF.shtml>
L<http://www.dm.unito.it/~cerruti/doc-html/tremattine/tre_mattine.pdf>

=back

This arises also in a radix=1 variation of Jeffrey Shallit's digit-based
continued fraction encoding.  See L<Math::PlanePath::CfracDigits/Radix 1>.

If the continued fraction of X/Y is

                 1
    X/Y = a + ------------             a >= 0
                     1
              b + -----------         b,c,etc >= 1
                        1
                  c + -------
                    ... +  1
                          ---          z >= 2
                           z

then the N value is bit runs of lengths a,b,c etc.

    N = 1000 1000 1000 ... 1000
        \--/ \--/ \--/     \--/
         a+1   b    c       z-1

Each group is 1 or more bits.  The +1 in "a+1" makes the first group 1 or
more bits, since a=0 occurs for any X/YE<lt>=1.  The -1 in "z-1" makes the
last group 1 or more since zE<gt>=2.

    N=1                             1/1
                              ------   ------
    N=2 to N=3             2/1               1/2
                          /    \            /    \
    N=4 to N=7         3/1      3/2      1/3      2/3
                       | |      | |      | |      | |
    N=8 to N=15      4/1 5/2  4/3 5/3  1/4 2/5  3/4 3/5

The result is a bit reversal of the N values in the AYT tree.

    AYT  N = binary "1abcde"      AYT <-> HCS bit reversal
    HCS  N = binary "1edcba"

For example at X=4,Y=7 the AYT tree is N=11 binary "10111" whereas HCS there
has N=30 binary "11110", a reversal of the bits below the high 1.

Plotting by X,Y gives

=cut

# math-image --path=RationalsTree,tree_type=HCS --all --output=numbers_xy --size=70x11

=pod

    tree_type => "HCS"

    10  |     768        50                  58       896
     9  |     384   49        52   60        57  448       640
     8  |     192        27        31       224       320
     7  |      96   25   26   30   29  112       160   41   42
     6  |      48                  56        80
     5  |      24   13   15   28        40   21   23   44
     4  |      12        14        20        22        36
     3  |       6    7        10   11        18   19        34
     2  |       3         5         9        17        33
     1  |       1    2    4    8   16   32   64  128  256  512
    Y=0 |
        +-----------------------------------------------------
          X=0   1    2    3    4    5    6    7    8    9   10

N=1,2,4,etc in the row Y=1 are powers-of-2, being integers X/1 having just a
single group of bits N=1000..000.

N=1,3,6,12,etc in the column X=1 are 3*2^(Y-1) corresponding to continued
fraction S<0 + 1/Y> so terms 0,Y making runs 1,Y-1 and so bits N=11000...00.

X<Thue-Morse>The turn sequence left or right following successive X,Y points
is the Thue-Morse sequence.  A proof of this can be found in the author's
mathematical write-up (above).

    count 1-bits in N+1      turn at N
    -------------------      ---------
           odd                 right
           even                left

=head2 Bird Tree

X<Hinze, Ralf>C<tree_type=E<gt>"Bird"> selects the Bird tree,

=over

Ralf Hinze, "Functional Pearls: The Bird tree", Journal of Functional
Programming, volume 19, issue 5, September 2009, pages 491-508.  DOI
10.1017/S0956796809990116
L<http://www.cs.ox.ac.uk/ralf.hinze/publications/Bird.pdf>

=back

It's expressed recursively, illustrating Haskell programming features.  The
left subtree is the tree plus one and take the reciprocal.  The right
subtree is conversely the reciprocal first then add one,

       1             1
    --------  and  ---- + 1
    tree + 1       tree

which means Y/(X+Y) and (X+Y)/X taking N bits low to high.

    N=1                             1/1
                              ------   ------
    N=2 to N=3             1/2               2/1
                          /    \            /    \
    N=4 to N=7         2/3      1/3      3/1      3/2
                       | |      | |      | |      | |
    N=8 to N=15     3/5  3/4  1/4 2/5  5/2 4/1  4/3 5/3

Plotting by X,Y gives

    tree_type => "Bird"

    10  |     682        41                  38       597
     9  |     341   43        45   34        36  298       938
     8  |     170        23        16       149       469
     7  |      85   20   22   17   19   74       234   59   57
     6  |      42                  37       117
     5  |      21   11    8   18        58   28   31   61
     4  |      10         9        29        30        50
     3  |       5    4        14   15        25   24        54
     2  |       2         7        12        27        52
     1  |       1    3    6   13   26   53  106  213  426  853
    Y=0 |
         ----------------------------------------------------
          X=0   1    2    3    4    5    6    7    8    9   10

Notice that unlike the other trees N=1,2,5,10,etc in the X=1 vertical for
fractions 1/Y is not the row start or end, but instead are on a zigzag
through the middle of the tree binary N=1010...etc alternate 1 and 0 bits.
The integers X/1 in the Y=1 vertical are similar, but N=11010...etc starting
the alternation from a 1 in the second highest bit, since those integers are
in the right hand half of the tree.

The Bird tree N values are related to the SB tree by inverting every second
bit starting from the second after the high 1-bit,

    Bird N=1abcdefg..    binary
             101010..    xor, so b,d,f etc flip 0<->1
    SB   N=1aBcDeFg..         to make B,D,F

For example 3/4 in the SB tree is at N=11 = binary 1011.  Xor with 0010 for
binary 1001 N=9 which is 3/4 in the Bird tree.  The same xor goes back the
other way Bird tree to SB tree.

This xoring is a mirroring in the tree, swapping left and right at each
level.  Only every second bit is inverted because mirroring twice puts it
back to the ordinary way on even rows.

=head2 Drib Tree

X<Hinze, Ralf>C<tree_type=E<gt>"Drib"> selects the Drib tree by Ralf Hinze.

=over

L<http://oeis.org/A162911>

=back

It reverses the bits of N in the Bird tree (in a similar way that the SB and
CW are bit reversals of each other).

    N=1                             1/1
                              ------   ------
    N=2 to N=3             1/2               2/1
                          /    \            /    \
    N=4 to N=7         2/3      3/1      1/3      3/2
                       | |      | |      | |      | |
    N=8 to N=15     3/5  5/2  1/4 4/3  3/4 4/1  2/5 5/3

The descendants of each node are

          X/Y
        /     \
    Y/(X+Y)  (X+Y)/X

X<Fibonacci numbers>The endmost fractions of each row are Fibonacci numbers,
F(k)/F(k+1) on the left and F(k+1)/F(k) on the right.

=cut

# math-image --path=RationalsTree,tree_type=Drib --all --output=numbers_xy

=pod

    tree_type => "Drib"

    10  |     682        50                  44       852
     9  |     426   58        54   40        36  340       683
     8  |     170        30        16       212       427
     7  |     106   18   22   24   28   84       171   59   51
     6  |      42                  52       107
     5  |      26   14    8   20        43   19   31   55
     4  |      10        12        27        23        41
     3  |       6    4        11   15        25   17        45
     2  |       2         7         9        29        37
     1  |       1    3    5   13   21   53   85  213  341  853
    Y=0 |
         -------------------------------------------------------
         X=0    1    2    3    4    5    6    7    8    9   10

In each node descent the left Y/(X+Y) E<lt> 1 and the right (X+Y)/X E<gt> 1,
which means even N is above the X=Y diagonal and odd N is below.

Because Drib/Bird are bit reversals like CW/SB are bit reversals, the xor
procedure described above which relates BirdE<lt>-E<gt>SB applies to
DribE<lt>-E<gt>CW, but working from the second lowest bit upwards, ie. xor
binary "0..01010".  For example 4/1 is at N=15 binary 1111 in the CW tree.
Xor with 0010 for 1101 N=13 which is 4/1 in the Drib tree.

=head2 L Tree

X<Luschny, Peter>C<tree_type=E<gt>"L"> selects the L-tree by Peter Luschny.

=over

L<http://www.oeis.org/wiki/User:Peter_Luschny/SternsDiatomic>

=back

It's a row-reversal of the CW tree with a shift to include zero as 0/1.

    N=0                             0/1
                              ------   ------
    N=1 to N=2             1/2               1/1
                          /    \            /    \
    N=3 to N=8         2/3      3/2      1/3      2/1
                       | |      | |      | |      | |
    N=9 to N=16     3/4  5/3  2/5 5/2  3/5 4/3  1/4 3/1

Notice in the N=9 to N=16 row rationals 3/4 to 1/4 are the same as in the CW
tree but read right-to-left.

=cut

# math-image --path=RationalsTree,tree_type=L --all --output=numbers_xy --size=70x11

=pod

    tree_type => "L"

    10  |    1021        37                  55       511
     9  |     509   45        33   59        47  255      1020
     8  |     253        25        19       127       508
     7  |     125   21   17   27   23   63       252   44   36
     6  |      61                  31       124
     5  |      29    9   11   15        60   20   24   32
     4  |      13         7        28        16        58
     3  |       5    3        12    8        26   18        54
     2  |       1         4        10        22        46
     1  |  0    2    6   14   30   62  126  254  510 1022 2046
    Y=0 |
         -------------------------------------------------------
         X=0    1    2    3    4    5    6    7    8    9   10

N=0,2,6,14,30,etc along the row at Y=1 are powers 2^(X+1)-2.
N=1,5,13,29,etc in the column at X=1 are similar powers 2^Y-3.

=head2 Common Characteristics

The SB, CW, Bird, Drib, AYT and HCS trees have the same set of rationals in
each row, just in different orders.  The properties of Stern's diatomic
sequence mean that within a row the totals are

    row N=2^depth to N=2^(depth+1)-1 inclusive

      sum X/Y     = (3 * 2^depth - 1) / 2
      sum X       = 3^depth
      sum 1/(X*Y) = 1

For example the SB tree depth=2, N=4 to N=7,

    sum X/Y     = 1/3 + 2/3 + 3/2 + 3/1 = 11/2 = (3*2^2-1)/2
    sum X       = 1+2+3+3 = 9 = 3^2
    sum 1/(X*Y) = 1/(1*3) + 1/(2*3) + 1/(3*2) + 1/(3*1) = 1

Many permutations are conceivable within a row, but the ones here have some
relationship to X/Y descendants, tree sub-forms or continued fractions.  As
an encoding of continued fraction terms by bit runs the combinations are

     bit encoding           high to low    low to high
    ----------------        -----------    -----------
    0000 1111 runs              SB             CW
    0101 1010 alternating       Bird           Drib
    1000 1000 runs              HCS            AYT

A run of alternating 101010 ends where the next bit is the oppose of the
expected alternating 0,1.  This is a doubled bit 00 or 11.  An electrical
engineer would think of it as a phase shift.

=head2 Minkowski Question Mark

The Minkowski question mark function is a sum of the terms in the continued
fraction representation of a real number.  If q0,q1,q2,etc are those terms
then the question mark function "?(r)" is

                     1           1           1
    ?(r) = 2 * (1 - ---- * (1 - ---- * (1 - ---- * (1 - ...
                    2^q0        2^q1        2^q2

                     1         1            1
         = 2 * (1 - ---- + --------- - ------------ + ... )
                    2^q0   2^(q0+q1)   2^(q0+q1+q2)

For rational r the continued fraction q0,q1,q2,etc is finite and so the ?(r)
sum is finite and rational.  The pattern of + and - in the terms gives runs
of bits the same as the N values in the Stern-Brocot tree.  The
RationalsTree code can calculate the ?(r) function by

    rational r=X/Y
    N = xy_to_n(X,Y) tree_type=>"SB"
    depth = floor(log2(N))       # row containing N (depth=0 at top)
    Ndepth = 2^depth             # start of row containing N

           2*(N-Ndepth) + 1
    ?(r) = ----------------
                Ndepth

The effect of N-Ndepth is to remove the high 1-bit, leaving an offset into
the row.  2*(..)+1 appends an extra 1-bit at the end.  The division by
Ndepth scales down from integer N to a fraction.

    N    = 1abcdef      integer, in binary
    ?(r) = a.bcdef1     binary fraction

For example ?(2/3) is X=2,Y=3 which is N=5 in the SB tree.  It is at
depth=2, Ndepth=2^2=4, and so ?(2/3)=(2*(5-4)+1)/4=3/4.  Or written in
binary N=101 gives Ndepth=100 and N-Ndepth=01 so 2*(N-Ndepth)+1=011 and
divide by Ndepth=100 for ?=0.11.

In practice this is not a very efficient way to handle the question
function, since the bit runs in the N values may become quite large for
relatively modest fractions.  (L<Math::ContinuedFraction> may be better, and
also allows repeating terms from quadratic irrationals to be represented
exactly.)

=head2 Pythagorean Triples

Pythagorean triples A^2+B^2=C^2 can be generated by A=P^2-Q^2, B=2*P*Q.  If
PE<gt>QE<gt>1 with P,Q no common factor and one odd the other even then this
gives all primitive triples, being primitive in the sense of A,B,C no common
factor (L<Math::PlanePath::PythagoreanTree/PQ Coordinates>).

In the Calkin-Wilf tree the parity of X,Y pairs are as follows.  Pairs X,Y
with one odd the other even are N=0 or 2 mod 3.

    CW tree           X/Y
                   --------
    N=0 mod 3      even/odd
    N=1 mod 3      odd/odd
    N=2 mod 3      odd/even

This occurs because the numerators are the Stern diatomic sequence and the
denominators likewise but offset by 1.  The Stern diatomic sequence is a
repeating pattern even,odd,odd (eg. per L<Math::NumSeq::SternDiatomic/Odd
and Even>).

The XE<gt>Y pairs in the CW tree are the right leg of each node, which is N
odd.  so

    CW tree N=3 or 5 mod 6   gives X>Y one odd the other even

    index t=1,2,3,etc to enumerate such pairs
    N = 3*t   if t odd
        3*t-1 if t even

X<Jacobsthal numbers>2 of each 6 points are used.  In a given row it's
width/3 but rounded up or down according to where the 3,5mod6 falls on the
N=2^depth start, which is either floor or ceil according to depth odd or
even,

    NumPQ(depth) = floor(2^depth / 3) for depth=even
                   ceil (2^depth / 3) for depth=odd
      = 0, 1, 1, 3, 5, 11, 21, 43, 85, 171, 341, ...

These are the Jacobsthal numbers, which in binary are 101010...101 and
1010...1011.

For the other tree types the various bit transformations which map N
positions between the trees can be applied to the above N=3or5 mod 6.  The
simplest is the L tree where the N offset and row reversal gives N=0or4
mod 6.

The SB tree is a bit reversal of the CW, as described above, and for the
Pythagorean N this gives

    SB tree N=0 or 2 mod 2 and N="11...." in binary
     gives X>Y one odd the other even

N="11..." binary is the bit reversal of the CW N=odd "1...1" condition.
This bit pattern is those N in the second half of each row, which is where
the X/Y E<gt> 1 rationals occur.  The N=0or2 mod 3 condition is unchanged by
the bit reversal.  N=0or2 mod 3 precisely when bitreverse(N)=0or2 mod 3.

For SB whether it's odd/even or even/odd at N=0or2 mod 3 alternates between
rows.  The two are both wanted, they just happen to switch in each row.

    SB tree X/Y    depth=even     depth=odd
                   ----------     ---------
    N=0 mod 3      odd/even       even/odd
    N=1 mod 3      odd/odd        odd/odd    <- exclude for Pythagorean
    N=2 mod 3      even/odd       odd/even

=head1 FUNCTIONS

See L<Math::PlanePath/FUNCTIONS> for behaviour common to all path classes.

=over

=item C<$path = Math::PlanePath::RationalsTree-E<gt>new ()>

=item C<$path = Math::PlanePath::RationalsTree-E<gt>new (tree_type =E<gt> $str)>

Create and return a new path object.  C<tree_type> (a string) can be

    "SB"      Stern-Brocot
    "CW"      Calkin-Wilf
    "AYT"     Yu-Ting, Andreev
    "HCS"
    "Bird"
    "Drib"
    "L"

=item C<$n = $path-E<gt>n_start()>

Return the first N in the path.  This is 1 for SB, CW, AYT, HCS, Bird and
Drib, but 0 for L.

=item C<($n_lo, $n_hi) = $path-E<gt>rect_to_n_range ($x1,$y1, $x2,$y2)>

Return a range of N values which occur in a rectangle with corners at
C<$x1>,C<$y1> and C<$x2>,C<$y2>.  The range is inclusive.

For reference, C<$n_hi> can be quite large because within each row there's
only one new X/1 integer and 1/Y fraction.  So if X=1 or Y=1 is included
then roughly C<$n_hi = 2**max(x,y)>.  If min(x,y) is bigger than 1 then it
reduces a little to roughly 2**(max/min + min).

=back

=head2 Tree Methods

X<Complete binary tree>Each point has 2 children, so the path is a complete
binary tree.

=over

=item C<@n_children = $path-E<gt>tree_n_children($n)>

Return the two children of C<$n>, or an empty list if C<$n E<lt> 1>
(ie. before the start of the path).

This is simply C<2*$n, 2*$n+1>.  Written in binary the children are C<$n>
with an extra bit appended, a 0-bit or a 1-bit.

=item C<$num = $path-E<gt>tree_n_num_children($n)>

Return 2, since every node has two children.  If C<$nE<lt>1>, ie. before the
start of the path, then return C<undef>.

=item C<$n_parent = $path-E<gt>tree_n_parent($n)>

Return the parent node of C<$n>.  Or return C<undef> if C<$n E<lt>= 1> (the
top of the tree).

This is simply Nparent = floor(N/2), ie. strip the least significant bit
from C<$n>.  (Undo what C<tree_n_children()> appends.)

=item C<$depth = $path-E<gt>tree_n_to_depth($n)>

Return the depth of node C<$n>, or C<undef> if there's no point C<$n>.  The
top of the tree at N=1 is depth=0, then its children depth=1, etc.

This is simply floor(log2(N)) since the tree has 2 nodes per point.  For
example N=4 through N=7 are all depth=2.

The L tree starts at N=0 and the calculation becomes floor(log2(N+1)) there.

=item C<$n = $path-E<gt>tree_depth_to_n($depth)>

=item C<$n = $path-E<gt>tree_depth_to_n_end($depth)>

Return the first or last N at tree level C<$depth> in the path, or C<undef>
if nothing at that depth or not a tree.  The top of the tree is depth=0.

The structure of the tree means the first N is at C<2**$depth>, or for the L
tree S<C<2**$depth - 1>>.  The last N is C<2**($depth+1)-1>, or for the L
tree C<2**($depth+1)>.

=back

=head2 Tree Descriptive Methods

=over

=item C<$num = $path-E<gt>tree_num_children_minimum()>

=item C<$num = $path-E<gt>tree_num_children_maximum()>

Return 2 since every node has 2 children so that's both the minimum and
maximum.

=item C<$bool = $path-E<gt>tree_any_leaf()>

Return false, since there are no leaf nodes in the tree.

=back

=cut

# =head1 FORMULAS

=pod

=head1 OEIS

The trees are in Sloane's Online Encyclopedia of Integer Sequences in
various forms,

=over

L<http://oeis.org/A007305> (etc)

=back

    tree_type=SB
      A007305   X, extra initial 0,1
      A047679   Y
      A057431   X,Y pairs (initial extra 0/1,1/0)
      A007306   X+Y sum, Farey 0 to 1 part (extra 1,1)
      A153036   int(X/Y), integer part
      A088696   length of continued fraction SB left half (X/Y<1)

    tree_type=CW
      A002487   X and Y, Stern diatomic sequence (extra 0)
      A070990   Y-X diff, Stern diatomic first diffs (less 0)
      A070871   X*Y product
      A007814   int(X/Y), integer part, count trailing 1-bits
                  which is count trailing 0-bits of N+1
      A086893   N position of Fibonacci F[n+1]/F[n], N = binary 1010..101
      A061547   N position of Fibonacci F[n]/F[n+1], N = binary 11010..10
      A047270   3or5 mod 6, being N positions of X>Y not both odd
                  which can generate primitive Pythagorean triples

    tree_type=AYT
      A020650   X
      A020651   Y (Kepler numerator)
      A086592   X+Y sum (Kepler denominator)
      A135523   int(X/Y), integer part,
                   count trailing 0-bits plus 1 extra if N=2^k

    tree_type=HCS
      A229742   X, extra initial 0/1
      A071766   Y
      A071585   X+Y sum

    tree_type=Bird
      A162909   X
      A162910   Y
      A081254   N of row Y=1,    N = binary 1101010...10
      A000975   N of column X=1, N = binary  101010...10

    tree_type=Drib
      A162911   X
      A162912   Y
      A086893   N of row Y=1,    N = binary 110101..0101 (ending 1)
      A061547   N of column X=1, N = binary  110101..010 (ending 0)

    tree_type=L
      A174981   X
      A002487   Y, same as CW X,Y, Stern diatomic
      A047233   0or4 mod 6, being N positions of X>Y not both odd
                  which can generate primitive Pythagorean triples

    tree_type=SB,CW,AYT,HCS,Bird,Drib,L
      A008776   total X+Y in row, being 2*3^depth

    A000523  tree_n_to_depth(), being floor(log2(N))

    A059893  permutation SB<->CW, AYT<->HCS, Bird<->Drib
               reverse bits below highest
    A153153  permutation CW->AYT, reverse and un-Gray
    A153154  permutation AYT->CW, reverse and Gray code
    A154437  permutation AYT->Drib, Lamplighter low to high
    A154438  permutation Drib->AYT, un-Lamplighter low to high
    A003188  permutation SB->HCS, Gray code shift+xor
    A006068  permutation HCS->SB, Gray code inverse
    A154435  permutation HCS->Bird, Lamplighter bit flips
    A154436  permutation Bird->HCS, Lamplighter variant

    A054429  permutation SB,CW,Bird,Drib N at transpose Y/X,
               (mirror binary tree, runs 0b11..11 down to 0b10..00)
    A004442  permutation AYT N at transpose Y/X, from N=2 onwards
               (xor 1, ie. flip least significant bit)
    A063946  permutation HCS N at transpose Y/X, extra initial 0
               (xor 2, ie. flip second least significant bit)

    A054424  permutation DiagonalRationals -> SB
    A054426  permutation SB -> DiagonalRationals
    A054425  DiagonalRationals -> SB with 0s at non-coprimes
    A054427  permutation coprimes -> SB right hand X/Y>1

    A044051  N+1 of those N where SB and CW have same X,Y
               same Bird<->Drib and HCS<->AYT
               begin N+1 of N binary palindrome below high 1-bit

The sequences marked "extra ..." have one or two extra initial values over
what the RationalsTree here gives, but are the same after that.  And the
Stern first differences "less ..." means it has one less term than what the
code here gives.

=head1 SEE ALSO

L<Math::PlanePath>,
L<Math::PlanePath::FractionsTree>,
L<Math::PlanePath::CfracDigits>,
L<Math::PlanePath::ChanTree> 

L<Math::PlanePath::CoprimeColumns>,
L<Math::PlanePath::DiagonalRationals>,
L<Math::PlanePath::FactorRationals>,
L<Math::PlanePath::GcdRationals>,
L<Math::PlanePath::PythagoreanTree>

L<Math::NumSeq::SternDiatomic>,
L<Math::ContinuedFraction>

=head1 HOME PAGE

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

=head1 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/>.

=cut

#
# =head2 Calkin-Wilf Tree -- X,Y to Next X,Y
#
# Successive values of the CW tree can be calculated using a method be Moshe
# Newman.
# 
#           X                     Y
#     N is ---      N+1 is ---------------
#           Y              X+Y - 2*(X % Y)      0 <= X%Y < Y
#
# This means that the tree X,Y values can be iterated by keeping just a
# current X,Y pair.
# 
#     dX = Y - X
#     dY = X+Y - 2*(X%Y) - Y
#        = X - 2*(X%Y)
#
# floor(X/Y) = count trailing 1-bits of N
#    10111
#    11000  increment
# floor(X/Y) = integer part = first term of continued fraction