libmath-planepath-perl 122-1 / usr / share / perl5 / Math / NumSeq / PlanePathTurn.pm

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


# math-image --values=PlanePathTurn
#
# maybe:
# Turn4    0,1,2,3  and fractional
# Turn4n   0,1,2,-1  negatives    Turn4mid Turn4n Turn4s
# TTurn6n   0,1,2,3, -1,-2,  eg. flowsnake  TTurn6s
# TTurn6   0,1,2,3,4,5



package Math::NumSeq::PlanePathTurn;
use 5.004;
use strict;
use Carp 'croak';

use vars '$VERSION','@ISA';
$VERSION = 122;
use Math::NumSeq;
@ISA = ('Math::NumSeq');

use Math::NumSeq::PlanePathCoord;
use Math::PlanePath;
use Math::PlanePath::Base::Generic
  'is_infinite';
use Math::NumSeq::PlanePathDelta;

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


use constant characteristic_smaller => 1;

sub description {
  my ($self) = @_;
  if (ref $self) {
    return "Turn values $self->{'turn_type'} from path $self->{'planepath'}";
  } else {
    # class method
    return 'Turns from a PlanePath';
  }
}

use constant::defer parameter_info_array =>
  sub {
    return [
            Math::NumSeq::PlanePathCoord::_parameter_info_planepath(),
            {
             name    => 'turn_type',
             display => 'Turn Type',
             type    => 'enum',
             default => 'Left',
             choices => ['Left','Right','Straight',
                         'LSR','SLR','SRL',
                          
                         # 'NotStraight',
                         # 'Straight',
                         # 'RSL',
                         # 'Turn4',  # Turn4 is 0<=value<4.
                         # 'Turn4n',
                         # 'TTurn6',
                        ],
             description => 'Left is 1=left, 0=right or straight.
Right is 1=right, 0=left or straight.
LSR is 1=left,0=straight,-1=right.
SLR is 0=straight,1=left,2=right.
SRL is 0=straight,1=right,2=left.',
            },
           ];
  };

sub characteristic_integer {
  my ($self) = @_;
  my $planepath_object = $self->{'planepath_object'};
  if (my $func = $planepath_object->can("_NumSeq_Turn_$self->{'turn_type'}_integer")) {
    return $planepath_object->$func();
  }
  return undef;
}

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

sub oeis_anum {
  my ($self) = @_;
  ### PlanePathTurn oeis_anum() ...

  my $planepath = $self->{'planepath_object'};
  my $key = Math::NumSeq::PlanePathCoord::_planepath_oeis_anum_key($self->{'planepath_object'});

  ### planepath: ref $planepath
  ### $key
  ### whole table: $planepath->_NumSeq_Turn_oeis_anum
  ### key href: $planepath->_NumSeq_Turn_oeis_anum->{$key}

  return $planepath->_NumSeq_Turn_oeis_anum->{$key}->{$self->{'turn_type'}};
}

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

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

  $self->{'planepath_object'}
    ||= Math::NumSeq::PlanePathCoord::_planepath_name_to_object($self->{'planepath'});

  ### turn_func: "_turn_func_$self->{'turn_type'}", $self->{'turn_func'}
  $self->{'turn_func'} = $self->can('_turn_func_'.$self->{'turn_type'})
    || croak "Unrecognised turn_type: ",$self->{'turn_type'};

  $self->rewind;
  ### $self
  return $self;
}

sub i_start {
  my ($self) = @_;
  my $planepath_object = $self->{'planepath_object'} || return 0;
  return $planepath_object->n_start + $planepath_object->arms_count;
}
sub rewind {
  my ($self) = @_;
  my $planepath_object = $self->{'planepath_object'} || return;

  $self->{'i'} = $self->i_start;
  $self->{'arms'} = $planepath_object->arms_count;
  undef $self->{'prev_dx'};
}

sub next {
  my ($self) = @_;
  ### NumSeq-PlanePathTurn next(): "i=$self->{'i'}"

  my $planepath_object = $self->{'planepath_object'};

  my $i = $self->{'i'}++;
  my $arms = $self->{'arms'};

  my $prev_dx = $self->{'prev_dx'};
  my $prev_dy;
  if (defined $prev_dx) {
    $prev_dy = $self->{'prev_dy'};
    ### use prev dxdy: "$prev_dx,$prev_dy"
  } else {
    ($prev_dx, $prev_dy) = $planepath_object->n_to_dxdy($i-$arms)
      or do {
        ### nothing in path at n: $i
        return;
      };
    ### calc prev dxdy: "at i=".($i-$arms)."   $prev_dx,$prev_dy"
  }

  my ($dx, $dy) = $planepath_object->n_to_dxdy($i)
    or do {
      ### nothing in path at previous n: $i-$arms
      return;
    };
  ### calc dxdy: "at i=$i   $dx,$dy"

  if ($arms == 1) {
    $self->{'prev_dx'} = $dx;
    $self->{'prev_dy'} = $dy;
  }
  return ($i, $self->{'turn_func'}->($prev_dx,$prev_dy, $dx,$dy));
}

sub ith {
  my ($self, $i) = @_;
  ### PlanePathTurn ith(): $i

  if (is_infinite($i)) {
    return undef;
  }
  my $planepath_object = $self->{'planepath_object'};
  my $arms = $self->{'arms'};
  my ($prev_dx, $prev_dy) = $planepath_object->n_to_dxdy($i - $arms)
    or return undef;
  my ($dx, $dy) = $planepath_object->n_to_dxdy($i)
    or return undef;
  return $self->{'turn_func'}->($prev_dx,$prev_dy, $dx,$dy);
}

#            dx1,dy1
#  dx2,dy2  /
#       *  /
#         /
#        /
#       /
#      /
#     O
#
# cmpy = dx2 * dy1/dx1
# left if dy2 > cmpy
#         dy2 > dx2 * dy1/dx1
#         dy2 * dx1 > dx2 * dy1
#
# if dx1=0, dy1 > 0 then left if dx2 < 0
#    dy2 * 0 > dx2 * dy1
#          0 > dx2*dy1     good
#
sub _turn_func_Left {
  my ($dx,$dy, $next_dx,$next_dy) = @_;
  ### _turn_func_Left() ...
  return ($next_dy * $dx > $next_dx * $dy ? 1 : 0);
}
sub _turn_func_Right {
  my ($dx,$dy, $next_dx,$next_dy) = @_;
  ### _turn_func_Right() ...
  return ($next_dy * $dx < $next_dx * $dy ? 1 : 0);
}
sub _turn_func_LSR {
  my ($dx,$dy, $next_dx,$next_dy) = @_;
  ### _turn_func_LSR() ...
  return (($next_dy * $dx <=> $next_dx * $dy) || 0);  # 1,0,-1
}
sub _turn_func_RSL {
  return - _turn_func_LSR(@_);
}
{
  my @LSR_to_SLR = (0,  # LSR=0  straight -> SLR=0
                    1,  # LSR=1  left     -> SLR=1
                    2); # LSR=-1 right    -> SLR=2
  sub _turn_func_SLR {
    return $LSR_to_SLR[_turn_func_LSR(@_)];
  }
}
{
  my @LSR_to_SRL = (0,  # LSR=0  straight -> SRL=0
                    2,  # LSR=1  left     -> SRL=2
                    1); # LSR=-1 right    -> SRL=1
  sub _turn_func_SRL {
    return $LSR_to_SRL[_turn_func_LSR(@_)];
  }
}
sub _turn_func_Straight {
  my ($dx,$dy, $next_dx,$next_dy) = @_;
  ### _turn_func_Left() ...
  return ($next_dy * $dx == $next_dx * $dy ? 1 : 0);
}
sub _turn_func_NotStraight {
  my ($dx,$dy, $next_dx,$next_dy) = @_;
  ### _turn_func_Left() ...
  return ($next_dy * $dx == $next_dx * $dy ? 0 : 1);
}
# sub _turn_func_LR_01 {
#   my ($dx,$dy, $next_dx,$next_dy) = @_;
#   ### _turn_func_LR_01() ...
#   return ($next_dy * $dx >= $next_dx * $dy || 0);
# }
sub _turn_func_Turn4 {
  my ($dx,$dy, $next_dx,$next_dy) = @_;
  ### _turn_func_Turn4(): "$dx,$dy  $next_dx,$next_dy"
  return
    (((Math::NumSeq::PlanePathDelta::_delta_func_Dir360($next_dx,$next_dy)
       - Math::NumSeq::PlanePathDelta::_delta_func_Dir360($dx,$dy)) % 360)
     / 90);
}
sub _turn_func_Turn4n {
  my ($dx,$dy, $next_dx,$next_dy) = @_;
  require Math::NumSeq::PlanePathDelta;
  my $ret
    = (((Math::NumSeq::PlanePathDelta::_delta_func_Dir360($next_dx,$next_dy)
         - Math::NumSeq::PlanePathDelta::_delta_func_Dir360($dx,$dy)) % 360)
       / 90);
  if ($ret > 2) { $ret -= 4; }
  return $ret;
}
sub _turn_func_TTurn6 {
  my ($dx,$dy, $next_dx,$next_dy) = @_;
  require Math::NumSeq::PlanePathDelta;
  return
    (((Math::NumSeq::PlanePathDelta::_delta_func_TDir360($next_dx,$next_dy)
       - Math::NumSeq::PlanePathDelta::_delta_func_TDir360($dx,$dy)) % 360)
     / 60);
}

sub pred {
  my ($self, $value) = @_;
  ### PlanePathTurn pred(): $value
  my $planepath_object = $self->{'planepath_object'};

  if (defined (my $values_min = $self->values_min)) {
    if ($value < $values_min) {
      return 0;
    }
  }
  if (defined (my $values_max = $self->values_max)) {
    if ($value > $values_max) {
      return 0;
    }
  }

  my $turn_type = $self->{'turn_type'};
  if ($turn_type eq 'Left' || $turn_type eq 'Right' || $turn_type eq 'Straight') {
    unless ($value == 0 || $value == 1) {
      return 0;
    }
  } elsif ($turn_type eq 'LSR' || $turn_type eq 'RSL') {
    unless ($value == 1 || $value == 0 || $value == -1) {
      return 0;
    }
  } else { # ($turn_type eq 'SLR' || $turn_type eq 'SRL') {
    unless ($value == 0 || $value == 1 || $value == 2) {
      return 0;
    }
  }

  if (my $func = $planepath_object->can('_NumSeq_Turn_'.$self->{'turn_type'}.'_pred_hash')) {
    my $href = $self->$func();
    unless ($href->{$value}) {
      return 0;
    }
  }

  return 1;
}



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

sub values_min {
  my ($self) = @_;

  my $method = '_NumSeq_Turn_' . $self->{'turn_type'} . '_min';
  return $self->{'planepath_object'}->can($method)
    ? $self->{'planepath_object'}->$method()
      : undef;
}

sub values_max {
  my ($self) = @_;

  my $method = '_NumSeq_Turn_' . $self->{'turn_type'} . '_max';
  return $self->{'planepath_object'}->can($method)
    ? $self->{'planepath_object'}->$method()
      : undef;
}

sub characteristic_increasing {
  my ($self) = @_;
  my $planepath_object = $self->{'planepath_object'};
  if (my $func = $planepath_object->can("_NumSeq_Turn_$self->{'turn_type'}_increasing")) {
    return $planepath_object->$func();
  }
  return undef; # unknown
}

sub characteristic_non_decreasing {
  my ($self) = @_;
  my $planepath_object = $self->{'planepath_object'};
  if (my $func = $planepath_object->can("_NumSeq_Turn_$self->{'turn_type'}_non_decreasing")) {
    return $planepath_object->$func();
  }
  if (defined (my $values_min = $self->values_min)) {
    if (defined (my $values_max = $self->values_max)) {
      if ($values_min == $values_max) {
        # constant seq is non-decreasing
        return 1;
      }
    }
  }
  # increasing means non_decreasing too
  return $self->characteristic_increasing;
}

# my $all_Left_predhash = { 0=>1, 1=>1 };
# my $all_LSR_predhash = { 0=>1, 1=>1, -1=>1 };
# my $straight_Left_predhash = { 0=>1 };
# my $straight_LSR_predhash = { 0=>1 };

{ package Math::PlanePath;
  use constant 1.02; # for leading underscore

  sub _NumSeq_Turn_Left_min {
    my ($self) = @_;
    return ($self->turn_any_right
            || $self->turn_any_straight ? 0 : 1);
  }
  sub _NumSeq_Turn_Left_max {
    my ($self) = @_;
    return ($self->turn_any_left ? 1 : 0);
  }
  use constant _NumSeq_Turn_Left_integer => 1;

  sub _NumSeq_Turn_Right_min {
    my ($self) = @_;
    return ($self->turn_any_left
            || $self->turn_any_straight ? 0 : 1);
  }
  sub _NumSeq_Turn_Right_max {
    my ($self) = @_;
    return ($self->turn_any_right ? 1 : 0);
  }
  use constant _NumSeq_Turn_Right_integer => 1;

  sub _NumSeq_Turn_Straight_min {
    my ($self) = @_;
    return ($self->turn_any_left
            || $self->turn_any_right ? 0 : 1);
  }
  sub _NumSeq_Turn_Straight_max {
    my ($self) = @_;
    return ($self->turn_any_straight ? 1 : 0);
  }
  use constant _NumSeq_Turn_Straight_integer => 1;

  sub _NumSeq_Turn_LSR_min {
    my ($self) = @_;
    return ($self->turn_any_right      ? -1
            : $self->turn_any_straight ? 0
            : 1);  # only ever Left
  }
  sub _NumSeq_Turn_LSR_max {
    my ($self) = @_;
    return ($self->turn_any_left       ? 1
            : $self->turn_any_straight ? 0
            : -1);  # only ever Right
  }
  use constant _NumSeq_Turn_LSR_integer => 1;

  sub _NumSeq_Turn_SLR_min {
    my ($self) = @_;
    return ($self->turn_any_straight ? 0
            : $self->turn_any_left   ? 1
            : 2);  # only ever Right
  }
  sub _NumSeq_Turn_SLR_max {
    my ($self) = @_;
    return ($self->turn_any_right ? 2
            : $self->_NumSeq_Turn_Left_max); # 1 if any Left 
  }
  use constant _NumSeq_Turn_SLR_integer => 1;

  sub _NumSeq_Turn_SRL_min {
    my ($self) = @_;
    return ($self->turn_any_straight ? 0
            : $self->turn_any_right  ? 1
            : 2);  # only ever Left
  }
  sub _NumSeq_Turn_SRL_max {
    my ($self) = @_;
    return ($self->turn_any_left ? 2
            : $self->_NumSeq_Turn_Right_max);  # 1 if any Right
  }
  use constant _NumSeq_Turn_SRL_integer => 1;

  use constant _NumSeq_Turn_Turn4_min => 0;
  sub _NumSeq_Turn_Turn4_integer {
    my ($self) = @_;
    return $self->_NumSeq_Delta_Dir4_integer;
  }
  sub _NumSeq_Turn_Turn4_max {
    my ($self) = @_;
    return ($self->_NumSeq_Turn_Turn4_integer ? 3 : 4);
  }

  use constant _NumSeq_Turn_oeis_anum => {};
}

# { package Math::PlanePath::SquareSpiral;
#   # SquareSpiral
#   # abs(A167752)==Left=LSR=Turn4 if that really is the quarter-squares
#   # abs(A167753)==Left=LSR=Turn4 of wider=1 if that really is the ceil(n+1)^2
# }
{ package Math::PlanePath::GreekKeySpiral;
  sub _NumSeq_Turn_Turn4_max {
    my ($self) = @_;
    return ($self->{'turns'} == 0
            ? 1    # SquareSpiral, left or straight only
            : 3);  # otherwise turn right too
  }
}
{ package Math::PlanePath::PyramidSpiral;
  use constant _NumSeq_Turn_Turn4_max => 1.5;
}
{ package Math::PlanePath::TriangleSpiral;
  use constant _NumSeq_Turn_Turn4_max => 1.5;

  use constant _NumSeq_Turn_oeis_anum =>
    { 'n_start=-1' =>
      { Left     => 'A023531',  # 1 at k*(k+3)/2
        LSR      => 'A023531',
        Straight => 'A023532',  # 0 at k*(k+3)/2, 1 otherwise
        # OEIS-Other: A023531 planepath=TriangleSpiral,n_start=-1
        # OEIS-Other: A023531 planepath=TriangleSpiral,n_start=-1 turn_type=LSR
        # OEIS-Other: A023532 planepath=TriangleSpiral,n_start=-1 turn_type=Straight
      },

      # PlanePathTurn planepath=TriangleSpiral,n_start=1,  turn_type=TTurn6
      # A089799 Expansion of Jacobi theta function theta_2(q^(1/2))/q^(1/8)
      # is this 2s with runs of 0s ?
    };
}
{ package Math::PlanePath::TriangleSpiralSkewed;
  use constant _NumSeq_Turn_Turn4_max => 1.5;

  use constant _NumSeq_Turn_oeis_anum =>
    {
     do {
       my $href = { Left     => 'A023531',  # 1 at k*(k+3)/2
                    LSR      => 'A023531',
                    Straight => 'A023532',  # 0 at k*(k+3)/2, 1 otherwise
                  };
       ('skew=left,n_start=-1' => $href,
        'skew=right,n_start=-1' => $href,
        'skew=up,n_start=-1' => $href,
        'skew=down,n_start=-1' => $href)
         # OEIS-Other: A023531 planepath=TriangleSpiralSkewed,n_start=-1
         # OEIS-Other: A023531 planepath=TriangleSpiralSkewed,n_start=-1 turn_type=LSR
         # OEIS-Other: A023532 planepath=TriangleSpiralSkewed,n_start=-1 turn_type=Straight
         # OEIS-Other: A023531 planepath=TriangleSpiralSkewed,n_start=-1,skew=right
         # OEIS-Other: A023531 planepath=TriangleSpiralSkewed,n_start=-1,skew=up
         # OEIS-Other: A023531 planepath=TriangleSpiralSkewed,n_start=-1,skew=down
     },
    };
}
{ package Math::PlanePath::DiamondSpiral;
  use constant _NumSeq_Turn_Turn4_max => 1.5;
}
{ package Math::PlanePath::AztecDiamondRings;
  use constant _NumSeq_Turn_Turn4_max => 1; # left or straight
}
{ package Math::PlanePath::PentSpiral;
  use constant _NumSeq_Turn_Turn4_max =>
    Math::NumSeq::PlanePathTurn::_turn_func_Turn4(2,0, -2,1);
}
{ package Math::PlanePath::PentSpiralSkewed;
  use constant _NumSeq_Turn_Turn4_max => 1.5;
}
{ package Math::PlanePath::HexSpiral;
  use constant _NumSeq_Turn_Turn4_max => 1.5;
}
{ package Math::PlanePath::HexSpiralSkewed;
  use constant _NumSeq_Turn_Turn4_max => 1.5;
}
{ package Math::PlanePath::HeptSpiralSkewed;
  use constant _NumSeq_Turn_Turn4_max => 1.5; # at N=2 turn +135
}
{ package Math::PlanePath::AnvilSpiral;
  use constant _NumSeq_Turn_Turn4_max => 3;
}
{ package Math::PlanePath::OctagramSpiral;
  use constant _NumSeq_Turn_Turn4_max => 3; # +90 right
}
{ package Math::PlanePath::KnightSpiral;
  # use constant _NumSeq_Turn_Turn4_min => ...; # 2,1
}
# { package Math::PlanePath::CretanLabyrinth;
# }
{ package Math::PlanePath::SquareArms;
  use constant _NumSeq_Turn_Turn4_max => 1;  # left or straight
}
{ package Math::PlanePath::DiamondArms;
  use constant _NumSeq_Turn_Turn4_max => 1; # left or straight
  use constant _NumSeq_Turn_Turn4_integer => 1;
}
{ package Math::PlanePath::HexArms;
  use constant _NumSeq_Turn_Turn4_max => 1; # at N=8
}
{ package Math::PlanePath::SacksSpiral;

  sub _NumSeq_Turn_Turn4_max {
    my ($self) = @_;
    # at N=1 is maximum turn
    return Math::NumSeq::PlanePathTurn::_turn_func_Turn4(1,0,
                                                         $self->n_to_dxdy(1));
  }
  use constant _NumSeq_Turn4_min_is_infimum => 1;

  use constant _NumSeq_Turn_oeis_anum =>
    { '' =>
      { 'Left' => 'A000012',  # left always, all ones
        'LSR'  => 'A000012',
        # OEIS-Other: A000012 planepath=SacksSpiral
        # OEIS-Other: A000012 planepath=SacksSpiral turn_type=LSR
      },
    };
}
# { package Math::PlanePath::VogelFloret;
# }
{ package Math::PlanePath::TheodorusSpiral;
  use constant _NumSeq_Turn4_min_is_infimum => 1; # approaches straight
  use constant _NumSeq_Turn_Turn4_max => 1; # initial 90deg

  use constant _NumSeq_Turn_oeis_anum =>
    { '' =>
      { 'Left' => 'A000012',  # left always, all ones
        'LSR'  => 'A000012',
        # OEIS-Other: A000012 planepath=TheodorusSpiral
        # OEIS-Other: A000012 planepath=TheodorusSpiral turn_type=LSR
      },
    };
}
{ package Math::PlanePath::ArchimedeanChords;
  sub _NumSeq_Turn_Turn4_max {
    my ($self) = @_;
    # at N=1 is maximum turn
    return Math::NumSeq::PlanePathTurn::_turn_func_Turn4(1,0,
                                                         $self->n_to_dxdy(1));
  }
  use constant _NumSeq_Turn4_min_is_infimum => 1; # approaches straight ahead

  use constant _NumSeq_Turn_oeis_anum =>
    { '' =>
      { 'Left' => 'A000012',  # left always, all ones
        'LSR'  => 'A000012',
        # OEIS-Other: A000012 planepath=ArchimedeanChords
        # OEIS-Other: A000012 planepath=ArchimedeanChords turn_type=LSR
      },
    };
}
{ package Math::PlanePath::MultipleRings;

  # step=1 and step=2 are mostly 1 for left, but after a while each ring
  # endpoint is to the right

  sub _NumSeq_Turn_Left_non_decreasing {
    my ($self) = @_;
    # step=0 always straight
    # step=1 straight,straight, then always left
    return ($self->{'step'} <= 1);
  }
  *_NumSeq_Turn_Right_non_decreasing = \&_NumSeq_Turn_Left_non_decreasing;
  *_NumSeq_Turn_LSR_non_decreasing = \&_NumSeq_Turn_Left_non_decreasing;
  *_NumSeq_Turn_SLR_non_decreasing = \&_NumSeq_Turn_Left_non_decreasing;
  *_NumSeq_Turn_SRL_non_decreasing = \&_NumSeq_Turn_Left_non_decreasing;

  sub _NumSeq_Turn_Turn4_max {
    my ($self) = @_;
    my $step = $self->{'step'};
    return ($step == 0
            ? 0  # step == 0 is always straight ahead
            : 4/$step);
  }

  use constant _NumSeq_Turn_oeis_anum =>
    {
     # MultipleRings step=0 is trivial X=N,Y=0
     'step=0,ring_shape=circle' =>
     { Left => 'A000004',  # all-zeros
       LSR  => 'A000004',  # all zeros, straight
       # OEIS-Other: A000004 planepath=MultipleRings,step=0
       # OEIS-Other: A000004 planepath=MultipleRings,step=0 turn_type=LSR
     },
     'step=0,ring_shape=polygon' =>
     { Left => 'A000004',  # all-zeros
       LSR  => 'A000004',  # all zeros, straight
       # OEIS-Other: A000004 planepath=MultipleRings,step=0,ring_shape=polygon
       # OEIS-Other: A000004 planepath=MultipleRings,step=0,ring_shape=polygon turn_type=LSR
     },
    };
}
{ package Math::PlanePath::PixelRings;
  # has right turns between rings
  use constant _NumSeq_Turn_Turn4_max => 3.5;
}
{ package Math::PlanePath::FilledRings;
  use constant _NumSeq_Turn_Turn4_max => 3.5;
}
{ package Math::PlanePath::Hypot;
  sub _NumSeq_Turn4_min_is_infimum {
    my ($self) = @_;
    return ($self->{'points'} eq 'all');
  }
  {
    my %_NumSeq_Turn_Turn4_max
      = (all  => 1.5, # at N=2, apparent maximum
         even => 1.5, # at N=2, apparent maximum
         odd  => Math::NumSeq::PlanePathTurn::_turn_func_Turn4(3,-3, 3,5),
        );
    sub _NumSeq_Turn_Turn4_max {
      my ($self) = @_;
      return ($_NumSeq_Turn_Turn4_max{$self->{'points'}} || 0);
    }
  }
}
{ package Math::PlanePath::HypotOctant;
  # apparently approaches +360 degrees
  use constant _NumSeq_Turn4_max_is_supremum => 1;
}
{ package Math::PlanePath::TriangularHypot;
  # points=even Turn4=0 at N=31
  #
  # points=all   apparently approaches 0
  # min i=473890[1303230202] 0.00000  px=-11,py=1 dx=-13,dy=1   -13.000
  #
  # points=odd    apparently approaches 0
  # min i=95618[113112002] 0.01111  px=-14,py=4 dx=-16,dy=4   -4.000
  #
  # points=hex   apparently approaches 0
  # min i=44243[22303103] 0.01111  px=-15,py=3 dx=-12,dy=2   -6.000
  #
  # points=hex_rotated Turn4=0 at N=58
  # points=hex_centred Turn4=0 at N=24
  {
    my %_NumSeq_Turn4_min_is_infimum = (all => 1,
                                        odd => 1,
                                        hex => 1,
                                       );
    sub _NumSeq_Turn4_min_is_infimum {
      my ($self) = @_;
      return ($_NumSeq_Turn4_min_is_infimum{$self->{'points'}} || 0);
    }
  }
  {
    my %_NumSeq_Turn_Turn4_max
      = (even => 1.5, # at N=2
         odd  => Math::NumSeq::PlanePathTurn::_turn_func_Turn4(5,3, 0,-6),
         all  => Math::NumSeq::PlanePathTurn::_turn_func_Turn4(5,3, 0,-6),
         hex  => Math::NumSeq::PlanePathTurn::_turn_func_Turn4(2,0, -3,1),
         hex_rotated => Math::NumSeq::PlanePathTurn::_turn_func_Turn4(1,1, -3,-1),
         hex_centred => Math::NumSeq::PlanePathTurn::_turn_func_Turn4(3,1, -2,2),
        );
    sub _NumSeq_Turn_Turn4_max {
      my ($self) = @_;
      return ($_NumSeq_Turn_Turn4_max{$self->{'points'}} || 0);
    }
  }
}
# { package Math::PlanePath::PythagoreanTree;
#   # A000004 all-zeros and A000012 all-ones are OFFSET=0 which doesn't match
#   # start N=1 here for always turn left or right in UAD.
# }
# { package Math::PlanePath::RationalsTree;
#   #   SB turn cf A021913 0,0,1,1
#   #              A133872 1,1,0,0
#   #              A057077 1,1,-1,-1
#   #              A087960 1,-1,-1,1
#   #   HCS turn left close to A010059 thue-morse or A092436
#   #            right A010060
#   #            LSR => 'A106400',  # thue-morse +/-1
#   #   CfracDigits radix=1 likewise
# }
# { package Math::PlanePath::FractionsTree;
# }
# { package Math::PlanePath::ChanTree;
#   # FIXME: k=4,5,6 are Right-only, maybe
#   # sub _NumSeq_Turn_Left_max {
#   #   my ($self) = @_;
#   #   return ($self->{'k'} >= 4
#   #           ? 0 # never Left
#   #           : 1);
#   # }
#   # sub _NumSeq_Turn_Right_min {
#   #   my ($self) = @_;
#   #   return ($self->{'k'} >= 4
#   #           ? 1 # always Right
#   #           : 0);
#   # }
#   # sub _NumSeq_Turn_LSR_max {
#   #   my ($self) = @_;
#   #   return ($self->{'k'} >= 4
#   #           ? -1 # always Right
#   #           : 1);
#   # }
# }
{ package Math::PlanePath::DiagonalRationals;
  sub _NumSeq_Turn_Turn4_max {
    my ($self) = @_;
    return ($self->{'direction'} eq 'down'
            ? 2.5   # N=2
            : Math::NumSeq::PlanePathTurn::_turn_func_Turn4(-1,1, 2,-1)); # N=3
  }
}
# { package Math::PlanePath::FactorRationals;
#   # revbinary
#   # max i=296[10220] 3.98889  px=-258,py=1 dx=-26,dy=1[-122,1]   -26.000
#   N=295=5*59   X=5*59 Y=1             N=297
#   N=296=2^3*37 X=37   Y=2     -26,+1     \ N=296 <-------- N=295
#   N=297=3^3*11 X=11   Y=3                         -258,+1
# }
{ package Math::PlanePath::GcdRationals;
  # Turn4 minimum
  # pairs_order=rows
  #   min=0 at N=12
  #   max i=216[3120] 3.98889  px=11,py=-14 dx=3,dy=-4[3,-10]   -0.750
  #
  # pairs_order=rows_reverse
  #   min i=13[31] 0.00000  px=-1,py=0 dx=-1,dy=0   0.000
  #   max i=611[21203] 3.98889  px=-1,py=2 dx=-13,dy=28[-31,130]   -0.464
  #
  # pairs_order=diagonals_down
  #   min i=2[2] 0.00000  px=0,py=1 dx=0,dy=1   0.000
  #   max i=561[20301] 3.98889  px=-7,py=8 dx=-5,dy=6[-11,12]   -0.833
  #
  # pairs_order=diagonals_up
  #   min i=11[23] 0.00000  px=-1,py=1 dx=-1,dy=1   -1.000
  #   max i=4886[1030112] 3.98889  px=6,py=-6 dx=15,dy=-16[33,-100]   -0.938
  #
  # Are these exact maximums or more when bigger N?
}
# { package Math::PlanePath::CfracDigits;
# }
{ package Math::PlanePath::AR2W2Curve;     # NSEW+diag
  use constant _NumSeq_Turn_Turn4_max => 3.5;
}
{ package Math::PlanePath::PeanoCurve;
  use constant _NumSeq_Turn_oeis_anum =>
    { 'radix=3' =>
      {
       # 2---0---0---0---0---2
       # |                   |
       # 2---0---1   1---0---2
       #         |   |
       # .---0---1   1---0---0-...
       SLR => 'A163536', # turn 0=ahead,1=left,2=right, OFFSET=1
       SRL => 'A163537',
       # OEIS-Catalogue: A163536 planepath=PeanoCurve turn_type=SLR
       # OEIS-Catalogue: A163537 planepath=PeanoCurve turn_type=SRL

       # Not quite, A039963 is OFFSET=0 vs first turn N=1 here
       # Straight => 'A039963',
      },
    };
}
# { package Math::PlanePath::WunderlichSerpentine;
# }
{ package Math::PlanePath::HilbertCurve;
  use constant _NumSeq_Turn_oeis_anum =>
    { '' =>
      { SLR => 'A163542', # relative direction ahead=0,left=1,right=2 OFFSET=1
        SRL => 'A163543', # relative direction transpose
        # OEIS-Catalogue: A163542 planepath=HilbertCurve turn_type=SLR
        # OEIS-Catalogue: A163543 planepath=HilbertCurve turn_type=SRL
      },
    };
}
{ package Math::PlanePath::HilbertSides;
  use constant _NumSeq_Turn_oeis_anum =>
    { '' =>
      { NotStraight => 'A035263',  # morphism
        # OEIS-Other: A035263 planepath=HilbertSides turn_type=NotStraight

        # Not quite, OFFSET=0 but first turn here N=1.
        # # OEIS-Other: A096268 planepath=HilbertSides turn_type=Straight
        # Straight => 'A096268',  # odd/even trailing 0 bits
      },
    };
}
{ package Math::PlanePath::ZOrderCurve;
  sub _NumSeq_Turn_Turn4_min {
    my ($self) = @_;
    return ($self->{'radix'} == 2
            ? 0.5
            : 0);  # includes straight
  }
  # radix   max at
  # -----   ------
  #   2       3             *---*      Y=radix-1
  #   3       8                  \
  #   4      15                   \
  #   5      24                    *   Y=0
  sub _NumSeq_Turn_Turn4_max {
    my ($self) = @_;
    return (Math::NumSeq::PlanePathTurn::_turn_func_Turn4
            (1,0, 1,1-$self->{'radix'}));
  }
}
{ package Math::PlanePath::GrayCode;
  # ENHANCE-ME: check this is true
  # PlanePathTurn planepath=GrayCode,apply_type=TsF,gray_type=reflected,radix=2,  turn_type=SLR
  # PlanePathTurn planepath=GrayCode,apply_type=Fs,gray_type=reflected,radix=2,  turn_type=SLR
  # match 1,1,0,0,1,1,1,1,1,1,0,0,1,1,0,0,1,1,0,0,1,1,1,1,1,1
  # A039963 The period-doubling sequence A035263 repeated.
  # A039963 ,1,1,0,0,1,1,1,1,1,1,0,0,1,1,0,0,1,1,0,0,1,1,1,1,1,1

  # Not quite, A039963 is OFFSET=0 vs first turn at N=1 here
  # 'Math::PlanePath::GrayCode' =>
  # {
  #  Left => 'A039963',  # duplicated KochCurve
  #  LSR  => 'A039963',
  # },
  # Koch characteristic of A003159 ending even zeros
  # 'Math::PlanePath::GrayCode' =>

  use constant _NumSeq_Turn_oeis_anum =>
    {
     do {
       my $peano = Math::PlanePath::PeanoCurve
         -> _NumSeq_Turn_oeis_anum -> {'radix=3'};
       ('apply_type=TsF,gray_type=reflected,radix=3' => $peano,
        'apply_type=FsT,gray_type=reflected,radix=3' => $peano,
       ),
         # OEIS-Other: A163536 planepath=GrayCode,apply_type=TsF,radix=3 turn_type=SLR
         # OEIS-Other: A163536 planepath=GrayCode,apply_type=FsT,radix=3 turn_type=SLR
         # OEIS-Other: A163537 planepath=GrayCode,apply_type=TsF,radix=3 turn_type=SRL
         # OEIS-Other: A163537 planepath=GrayCode,apply_type=FsT,radix=3 turn_type=SRL
     },
    };
}
# { package Math::PlanePath::ImaginaryBase;
# }
# { package Math::PlanePath::ImaginaryHalf;
# }
# { package Math::PlanePath::CubicBase;
# }
# { package Math::PlanePath::Flowsnake;
#   # inherit from FlowsnakeCentres
# }
{ package Math::PlanePath::FlowsnakeCentres;
  use constant _NumSeq_Turn_Turn4_max => 3.5;
}
# { package Math::PlanePath::GosperIslands;
# }
{ package Math::PlanePath::KochCurve;
  use constant _NumSeq_Turn_oeis_anum =>
    { '' =>
      { Left => 'A035263', # OFFSET=1 matches N=1
        # OEIS-Catalogue: A035263 planepath=KochCurve

        SLR => 'A056832',
        # OEIS-Catalogue: A056832 planepath=KochCurve turn_type=SLR
        # A056832 All a(n) = 1 or 2; a(1) = 1; get next 2^k terms by repeating first 2^k terms and changing last element so sum of first 2^(k+1) terms is odd.
        # A056832 ,1,2,1,1,1,2,1,2,1,2,1,1,1,2,1

        # Not quite, A096268 OFFSET=0 values 0,1,0,0,0,1
        # whereas here N=1 first turn values 0,1,0,0,0,1
        # Right => 'A096268',  # morphism
      },
    };
}
# { package Math::PlanePath::KochPeaks;
# }
# { package Math::PlanePath::KochSnowflakes;
# }
# { package Math::PlanePath::KochSquareflakes;
# }
# { package Math::PlanePath::QuadricCurve;
# }
# { package Math::PlanePath::QuadricIslands;
# }
{ package Math::PlanePath::SierpinskiTriangle;
  {
    my %_NumSeq_Turn_Turn4_max = (triangular => 2.5,
                                  left       => 2.5,
                                  right      => 3,
                                  diagonal   => 2.5,
                                 );
    sub _NumSeq_Turn_Turn4_max {
      my ($self) = @_;
      return $_NumSeq_Turn_Turn4_max{$self->{'align'}};
    }
  }
}
{ package Math::PlanePath::SierpinskiArrowhead;
  use constant _NumSeq_Turn_Turn4_min => 0.5; # North-East diagonal
  use constant _NumSeq_Turn_Turn4_max => 3.5; # South-East diagonal
}
{ package Math::PlanePath::SierpinskiArrowheadCentres;
  use constant _NumSeq_Turn_Turn4_max => 3.5; # South-East diagonal
}
# { package Math::PlanePath::SierpinskiCurve;
# #   use constant _NumSeq_Turn_oeis_anum =>
# #   { 'arms=1' =>
# #     {
# #      # Not quite, A039963 numbered OFFSET=0 whereas first turn at N=1 here
# #      Right => 'A039963',  # duplicated KochCurve turns
# #     },
# #   },
# # }
# }
{ package Math::PlanePath::SierpinskiCurveStair;
  use constant _NumSeq_Turn_Turn4_min => 1; # never straight
}
{ package Math::PlanePath::DragonCurve;
  use constant _NumSeq_Turn_Turn4_min => 1; # left or right only
  use constant _NumSeq_Turn_oeis_anum =>
    { 'arms=1' =>
      {
       'LSR' => 'A034947', # Jacobi symbol (-1/n)
       # OEIS-Catalogue: A034947 planepath=DragonCurve turn_type=LSR

       Turn4 => 'A099545',  # (odd part of n) mod 4
       # OEIS-Catalogue: A099545 planepath=DragonCurve turn_type=Turn4

       # 'L1R0' => 'A014577', # left=1,right=0  OFFSET=0
       # 'L0R1' => 'A014707', # left=0,right=1  OFFSET=0
       # 'L1R2' => 'A014709', # left=1,right=2  OFFSET=0
       # 'L1R3' => 'A099545', # left=1,right=3  OFFSET=1

       #  # Not quite, A014707 has OFFSET=0 cf first elem for N=1
       #  Left => 'A014707', # turn, 1=left,0=right
       #  # OEIS-Catalogue: A014707 planepath=DragonCurve

       #  # Not quite, A014577 has OFFSET=0 cf first elem for N=1
       #  Right => 'A014577', # turn, 0=left,1=right
       #  # OEIS-Catalogue: A014577 planepath=DragonCurve turn_type=Right

       # Not quite A014709 OFFSET=0 vs first turn at N=1 here
       # SLR => 'A014709'
       # SRL => 'A014710',
      },
    };
}
{ package Math::PlanePath::DragonRounded;
  use constant _NumSeq_Turn_Turn4_min => 0.5;
  use constant _NumSeq_Turn_Turn4_max => 3.5;
}
# { package Math::PlanePath::DragonMidpoint;
# }
{ package Math::PlanePath::AlternatePaper;
  use constant _NumSeq_Turn_Turn4_min => 1; # left or right only

  # A209615 is (-1)^e for each p^e prime=4k+3 or prime=2
  # 3*3 mod 4 = 1 mod 4
  # so picks out bit above lowest 1-bit, and factor -1 if an odd power-of-2
  # which is the AlternatePaper turn formula
  #
  use constant _NumSeq_Turn_oeis_anum =>
    { 'arms=1' =>
      { LSR => 'A209615',
        # OEIS-Catalogue: A209615 planepath=AlternatePaper turn_type=LSR

        # # Not quite, A106665 has OFFSET=0 cf first here i=1
        # 'Left' => 'A106665', # turn, 1=left,0=right
        # # OEIS-Catalogue: A106665 planepath=AlternatePaper i_offset=1
      },
    };
}
{ package Math::PlanePath::GosperSide;

  # Suspect not in OEIS:
  # Left or Right according to lowest non-zero ternary digit 1 or 2
  #
  use constant _NumSeq_Turn_oeis_anum =>
    { '' =>
      { Left => 'A137893', # turn, 1=left,0=right, OFFSET=1
        SLR  => 'A060236', # base-3 lowest non-zero digit 1=left,2=right
        # OEIS-Catalogue: A137893 planepath=GosperSide
        # OEIS-Other:     A137893 planepath=TerdragonCurve
        # OEIS-Catalogue: A060236 planepath=GosperSide turn_type=SLR
        # OEIS-Other:     A060236 planepath=TerdragonCurve turn_type=SLR
        # A060236 would also be a "TTurn3"

        # cf A136442 - a(3n)=1, a(3n-1)=0, a(3n+1)=a(n)
        # ternary lowest non-1  0->1 2->0

        # Not quite, A080846 OFFSET=0 values 0,1,0,0,1 which are N=1 here
        # Right => 'A080846',
        # # OEIS-Catalogue: A080846 planepath=GosperSide turn_type=Right
        # # OEIS-Other:     A080846 planepath=TerdragonCurve turn_type=Right
        # Or A189640 has extra initial 0.
      },
    };
}
{ package Math::PlanePath::TerdragonCurve;
  # GosperSide and TerdragonCurve same turn sequence, by diff angles
  use constant _NumSeq_Turn_Turn4_min => 1;
  use constant _NumSeq_Turn_Turn4_max => 3;
  use constant _NumSeq_Turn_oeis_anum =>
    { 'arms=1' => Math::PlanePath::GosperSide->_NumSeq_Turn_oeis_anum->{''} };
}
{ package Math::PlanePath::TerdragonRounded;
  use constant _NumSeq_Turn_Turn4_min => 0.5;
  use constant _NumSeq_Turn_Turn4_max => 3.5;
}
{ package Math::PlanePath::TerdragonMidpoint;
  use constant _NumSeq_Turn_Turn4_max => 3;
}
{ package Math::PlanePath::R5DragonCurve;
  use constant _NumSeq_Turn_Turn4_min => 1;  # right or left turn always
# # Not quite,    OFFSET=0 values 0,0,1,1,0
# # cf first turn here N=1 values 0,0,1,1,0
# # 'Math::PlanePath::R5DragonCurve' =>
# # { Right => 'A175337',
# #   # OEIS-Catalogue: A175337 planepath=R5DragonCurve turn_type=Right
# # },
}
# { package Math::PlanePath::R5DragonMidpoint;
# }
{ package Math::PlanePath::CCurve;
  # Not quite, A096268 OFFSET=1 vs first turn N=1 here
  # Straight => 'A096268'
}
# { package Math::PlanePath::ComplexPlus;
# }
# { package Math::PlanePath::ComplexMinus;
# }
# { package Math::PlanePath::ComplexRevolving;
# }
{ package Math::PlanePath::Rows;
  #  3---4  width=2
  #    \     N=2 turn4=1.5
  #  1---2   N=3 turn4=2.5
  sub _NumSeq_Turn_Turn4_min {
    my ($self) = @_;
    return ($self->{'width'} == 2
            ? 1.5  # at N=2
            : 0);  # otherwise has straight points
  }
  #   *--------
  #      \---\
  #   *---------*
  sub _NumSeq_Turn_Turn4_max {
    my ($self) = @_;
    return ($self->{'width'} <= 1
            ? 0  # width=1 always straight
            : (Math::NumSeq::PlanePathTurn::_turn_func_Turn4
               (1-$self->{'width'},1, 1,0)));  # at row start
  }

  use constant _NumSeq_Turn_oeis_anum =>
    {
     'n_start=1,width=0' => # Rows width=0 is trivial X=N,Y=0
     { Left => 'A000004',  # all-zeros
       LSR  => 'A000004',  # all zeros, straight
       # OEIS-Other: A000004 planepath=Rows,width=0
       # OEIS-Other: A000004 planepath=Rows,width=0 turn_type=LSR
     },

     # 4      N=1  turn=2
     #   \    N=2  turn=4
     # 2---3
     #   \
     # 0---1
     'n_start=-1,width=2' =>
     { TTurn6 => 'A010694', # repeat 2,4 with OFFSET=0
       # OEIS-Other: A010694 planepath=Rows,width=2,n_start=-1 turn_type=TTurn6
     },
    };
}
{ package Math::PlanePath::Columns;
  #  2   4  height=2
  #  | \ |   N=2 turn4=2.5
  #  1   3   N=3 turn4=1.5
  sub _NumSeq_Turn_Turn4_min {
    my ($self) = @_;
    return ($self->{'height'} == 2
            ? 1.5  # at N=3
            : 0);  # otherwise has straight points
  }
  #   *
  #   | \
  #   |  |
  #   *  *
  sub _NumSeq_Turn_Turn4_max {
    my ($self) = @_;
    return ($self->{'height'} <= 1
            ? 0   # height=1 always straight
            : (Math::NumSeq::PlanePathTurn::_turn_func_Turn4
               (0,1, 1,1-$self->{'height'})));  # at column top
  }

  use constant _NumSeq_Turn_oeis_anum =>
    {
     'n_start=1,height=0' => # Columns height=0 is trivial X=N,Y=0
     { Left => 'A000004',  # all-zeros
       LSR  => 'A000004',  # all zeros, straight
       # OEIS-Other: A000004 planepath=Columns,height=0
       # OEIS-Other: A000004 planepath=Columns,height=0 turn_type=LSR
     },

     # 'n_start=-1,height=4' =>
     # { Straight    => 'A133872', # repeat 1,1,0,0 OFFSET=0
     #   NotStraight => 'A021913', # repeat 0,0,1,1 OFFSET=0
     #   # OEIS-Other: A133872 planepath=Columns,n_start=-1,height=4 turn_type=Straight
     #   # OEIS-Other: A021913 planepath=Columns,n_start=-1,height=4 turn_type=NotStraight
     # },
    };
}
{ package Math::PlanePath::Diagonals;
  {
    my %_NumSeq_Turn_Turn4_max
      = (down => 2.5,
         # at N=3 dx=-1,dy=+1 then dx=2,dy=-1
         up   => Math::NumSeq::PlanePathTurn::_turn_func_Turn4(-1,1, 2,-1));
    sub _NumSeq_Turn_Turn4_max {
      my ($self) = @_;
      return $_NumSeq_Turn_Turn4_max{$self->{'direction'}};
    }
  }

  use constant _NumSeq_Turn_oeis_anum =>
    { 'direction=down,n_start=0,x_start=0,y_start=0' =>
      { Left => 'A129184', # shift of triangle
        SRL  => 'A156319', # triangle 1, 2, 0, 0, 0, ... in each row OFFSET=1
        # OEIS-Catalogue: A129184 planepath=Diagonals,n_start=0
        # OEIS-Catalogue: A156319 planepath=Diagonals,n_start=0 turn_type=SRL
      },
      'direction=down,n_start=-1,x_start=0,y_start=0' =>
      { Right => 'A023531', # 1 at m(m+3)/2
        # OEIS-Other: A023531 planepath=Diagonals,n_start=-1 turn_type=Right
      },

      'direction=up,n_start=0,x_start=0,y_start=0' =>
      { Right => 'A129184', # shift of triangle
        SLR   => 'A156319', # triangle 1, 2, 0, 0, 0, ... in each row OFFSET=1
        # OEIS-Other: A129184 planepath=Diagonals,direction=up,n_start=0 turn_type=Right
        # OEIS-Other: A156319 planepath=Diagonals,direction=up,n_start=0 turn_type=SLR
      },
      'direction=up,n_start=-1,x_start=0,y_start=0' =>
      { Left => 'A023531', # 1 at m(m+3)/2
        # OEIS-Other: A023531 planepath=Diagonals,direction=up,n_start=-1
      },
    };
}
{ package Math::PlanePath::DiagonalsAlternating;
  use constant _NumSeq_Turn_Turn4_max => 3.5;
}
{ package Math::PlanePath::DiagonalsOctant;
  sub _NumSeq_Turn_Turn4_max {
    my ($self) = @_;
    return ($self->{'direction'} eq 'down'
            ? 2.5  # N=3
            : 3);  # N=2
  }
#   # down is left or straight, but also right at N=2,3,4
#   # up is straight or right, but also left at N=2,3,4
#   'Math::PlanePath::DiagonalsOctant,direction=down' =>
#   { Left => square or pronic starting from 1
#   },
#   'Math::PlanePath::DiagonalsOctant,direction=up' =>
#   { Left => square or pronic starting from 1
#   },
}
{ package Math::PlanePath::Staircase;
  use constant _NumSeq_Turn_Turn4_min => 1;
  use constant _NumSeq_Turn_Turn4_max => 3;
}
# { package Math::PlanePath::StaircaseAlternating;
# }
{ package Math::PlanePath::MPeaks;
  use constant _NumSeq_Turn_Turn4_max => 3;
}
{ package Math::PlanePath::Corner;
  use constant _NumSeq_Turn_Turn4_max => 3;

  use constant _NumSeq_Turn_oeis_anum =>
    { 'wider=1,n_start=-1' =>
      { Left => 'A000007', # turn Left=1 at N=0 only
        # catalogued only unless/until a better implementation
        # OEIS-Catalogue: A000007 planepath=Corner,wider=1,n_start=-1
      },
      'wider=2,n_start=-1' =>
      { Left => 'A063524', # turn Left=1 at N=1 only
        # catalogued only unless/until a better implementation
        # OEIS-Catalogue: A063524 planepath=Corner,wider=2,n_start=-1
      },
      'wider=3,n_start=-1' =>
      { Left => 'A185012', # turn Left=1 at N=2 only
        # catalogued only unless/until a better implementation
        # OEIS-Catalogue: A185012 planepath=Corner,wider=3,n_start=-1
      },
      # A185013 Characteristic function of three.
      # A185014 Characteristic function of four.
      # A185015 Characteristic function of 5.
      # A185016 Characteristic function of 6.
      # A185017 Characteristic function of 7.
    };
}
{ package Math::PlanePath::PyramidRows;
  # if step==0 then always straight ahead

  # *--*         *---*
  # | step=1       \   step=3
  # *                *
  sub _NumSeq_Turn_Turn4_max {
    my ($self) = @_;
    return ($self->{'step'} == 0
            ? 0   # straight vertical only
            # at N=2
            : (Math::NumSeq::PlanePathTurn::_turn_func_Turn4
               (- $self->{'left_slope'},1, 1,0)));
  }

  use constant _NumSeq_Turn_oeis_anum =>
    {
     # PyramidRows step=0 is trivial X=N,Y=0
     do {
       my $href= { Left => 'A000004',  # all-zeros, OFFSET=0
                   LSR  => 'A000004',  # all zeros straight
                 };
       ('step=0,align=centre,n_start=1' => $href,
        'step=0,align=right,n_start=1'  => $href,
        'step=0,align=left,n_start=1'   => $href,
       );
       # OEIS-Other: A000004 planepath=PyramidRows,step=0
       # OEIS-Other: A000004 planepath=PyramidRows,step=0 turn_type=LSR
       # OEIS-Other: A000004 planepath=PyramidRows,step=0,align=right
       # OEIS-Other: A000004 planepath=PyramidRows,step=0,align=left turn_type=LSR
     },

     # PyramidRows step=1
     do {
       my $href= { Left => 'A129184', # triangle 1s shift right
                 };
       ('step=1,align=centre,n_start=0' => $href,
        'step=1,align=right,n_start=0'  => $href,
        'step=1,align=left,n_start=0'   => $href,
       );
       # OEIS-Other: A129184 planepath=PyramidRows,step=1,n_start=0
       # OEIS-Other: A129184 planepath=PyramidRows,step=1,align=right,n_start=0
       # OEIS-Other: A129184 planepath=PyramidRows,step=1,align=left,n_start=0
     },
     do {
       my $href= { Right => 'A023531',  # 1 at n==m*(m+3)/2
                 };
       ('step=1,align=centre,n_start=-1' => $href,
        'step=1,align=right,n_start=-1'  => $href,
       );
       # OEIS-Other: A023531 planepath=PyramidRows,step=1,n_start=-1 turn_type=Right
       # OEIS-Other: A023531 planepath=PyramidRows,step=1,align=right,n_start=-1 turn_type=Right
     },
    };
}
{ package Math::PlanePath::PyramidSides;
  use constant _NumSeq_Turn_Turn4_max => 3; # at N=3
}
{ package Math::PlanePath::CellularRule;
  sub _NumSeq_Turn_Left_increasing {
    my ($self) = @_;
    return (defined $self->{'rule'}
            && ($self->{'rule'} & 0x17) == 0    # single cell only
            ? 1
            : 0);
  }
  *_NumSeq_Turn_Right_increasing = \&_NumSeq_Turn_Left_increasing;

  sub _NumSeq_Turn_LSR_increasing {
    my ($self) = @_;
    return (defined $self->{'rule'}
            && ($self->{'rule'} & 0x17) == 0    # single cell only
            ? 1
            : 0);
  }
}
{ package Math::PlanePath::CellularRule::Line;
  use constant _NumSeq_Turn_Turn4_max => 0;
  use constant _NumSeq_Turn_Turn4_integer => 1;
}
{ package Math::PlanePath::CellularRule::OneTwo;

  # 5-6                                      5--6
  #  \                                       |
  #   4          left rule=6                 4   right rule=20
  #    ^----.    N=2 turn4=2.5              /    N=2 turn4=0.5
  #      2--3    N=3 turn4=3.5          2--3     N=3 turn4=3
  #       \      N=4 turn4=             |
  #         1                           1
  sub _NumSeq_Turn_Turn4_min {
    my ($self) = @_;
    return ($self->{'align'} eq 'left'
            ? Math::NumSeq::PlanePathTurn::_turn_func_Turn4(1,0, -2,1) # N=3
            : 0.5);
  }
  sub _NumSeq_Turn_Turn4_max {
    my ($self) = @_;
    return ($self->{'align'} eq 'left'
            ? Math::NumSeq::PlanePathTurn::_turn_func_Turn4(-2,1, -1,1) # N=4
            : 3);
  }

  use constant _NumSeq_Turn_oeis_anum =>
    { 'align=left,n_start=-1' =>
      { SRL => 'A131534', # repeat 1,2,1, 1,2,1, ... OFFSET=0
        # OEIS-Catalogue: A131534 planepath=CellularRule,rule=6,n_start=-1 turn_type=SRL
        # OEIS-Other:     A131534 planepath=CellularRule,rule=38,n_start=-1 turn_type=SRL
        # OEIS-Other:     A131534 planepath=CellularRule,rule=134,n_start=-1 turn_type=SRL
        # OEIS-Other:     A131534 planepath=CellularRule,rule=166,n_start=-1 turn_type=SRL
      },

      'align=right,n_start=-1' =>
      { SRL => 'A130196', # repeat 1,2,2, 1,2,2, ... OFFSET=0
        # OEIS-Catalogue: A130196 planepath=CellularRule,rule=20,n_start=-1 turn_type=SRL
        # OEIS-Other:     A130196 planepath=CellularRule,rule=52,n_start=-1 turn_type=SRL
        # OEIS-Other:     A130196 planepath=CellularRule,rule=148,n_start=-1 turn_type=SRL
        # OEIS-Other:     A130196 planepath=CellularRule,rule=180,n_start=-1 turn_type=SRL
      },
    };
}
{ package Math::PlanePath::CellularRule::Two;

  # 5--6                                      6--7
  #  ^---.                                    |
  #   4--5       left rule=6               4--5   right rule=84
  #    ^----.    N=2 turn4=2.5             |      N=2 turn4=1
  #      2--3    N=3 turn4=             2--3      N=3 turn4=3
  #       \                             |
  #         1                           1
  sub _NumSeq_Turn_Turn4_min {
    my ($self) = @_;
    return ($self->{'align'} eq 'left'
            ? Math::NumSeq::PlanePathTurn::_turn_func_Turn4(1,0, -2,1) # N=3
            : 1);
  }
  sub _NumSeq_Turn_Turn4_max {
    my ($self) = @_;
    return ($self->{'align'} eq 'left'
            ? 2.5
            : 3);
  }
  use constant _NumSeq_Turn_oeis_anum =>
    { 'align=right,n_start=-1' =>
      {
       # right line 2, stair step
       #       |
       #    3--1
       #    |
       # 3--1   Turn4 amounts
       # |
       # *
       Turn4 => 'A176040', # 3,1 repeating OFFSET=0
      },
      # OEIS-Catalogue: A176040 planepath=CellularRule,rule=84,n_start=-1 turn_type=Turn4
      # OEIS-Other:     A176040 planepath=CellularRule,rule=116,n_start=-1 turn_type=Turn4
      # OEIS-Other:     A176040 planepath=CellularRule,rule=212,n_start=-1 turn_type=Turn4
      # OEIS-Other:     A176040 planepath=CellularRule,rule=244,n_start=-1 turn_type=Turn4
    };
}
{ package Math::PlanePath::CellularRule::OddSolid;
  use constant _NumSeq_Turn_Turn4_max => 2.5; # at N=2

  # R 0 0 L  1 0 0 2
  #  R 0 L    1 0 2
  #   R L      1 2
  #    .        .

  use constant _NumSeq_Turn_oeis_anum =>
    { 'n_start=0' =>
      { SRL => 'A156319', # triangle rows 1,2,0,0,0,0,...
        # OEIS-Other: A156319 planepath=CellularRule,rule=50,n_start=0 turn_type=SRL
        # OEIS-Other: A156319 planepath=CellularRule,rule=58,n_start=0 turn_type=SRL
        # OEIS-Other: A156319 planepath=CellularRule,rule=250,n_start=0 turn_type=SRL
        # OEIS-Other: A156319 planepath=CellularRule,rule=179,n_start=0 turn_type=SRL
      },
    };
}
{ package Math::PlanePath::CellularRule54;
  use constant _NumSeq_Turn_Turn4_max => 2.5;
}
{ package Math::PlanePath::CellularRule57;
  sub _NumSeq_Turn_Turn4_max {
    my ($self) = @_;
    return ($self->{'mirror'}
            ? 3.5
            : Math::NumSeq::PlanePathTurn::_turn_func_Turn4(-2,1, 2,0)); # N=2
  }
}
{ package Math::PlanePath::CellularRule190;
  use constant _NumSeq_Turn_Turn4_max => 2.5;
}
# { package Math::PlanePath::CoprimeColumns;
# }
# { package Math::PlanePath::DivisibleColumns;
# }
# { package Math::PlanePath::File;
#   # File                   points from a disk file
#   # FIXME: analyze points for min/max etc
# }
{ package Math::PlanePath::QuintetCurve;
  use constant _NumSeq_Turn_Turn4_max => 3;
}
{ package Math::PlanePath::QuintetCentres;
  use constant _NumSeq_Turn_Turn4_max => 3.5;
}
# { package Math::PlanePath::QuintetSide;
  # PlanePathTurn planepath=QuintetSide,  turn_type=SLR
  # match 1,2,1,1,2,2,1,2,1,1,2,1,1,2,2,1,2,2,1,2,1,1,2,2,1,2
  # A060236 If n mod 3 = 0 then a(n)=a(n/3), otherwise a(n)=n mod 3.
  # A060236 ,1,2,1,1,2,2,1,2,1,1,2,1,1,2,2,1,2,2,1,2,1,1,2,2,1,2,1,1,2,1,1,2,2,1,2,1,1,2,1,1,2,2,1,2,2,1,2,1,1,2,2,1,2,2,1,2,1,1,2,2,1,2,1,1,2,1,1,2,2,1,2,2,1,2,1,1,2,2,1,2,1,1,2,1,1,2,2,1,2,1,1,2,1,1,2,2,1,2,2,1,2,1,1,2,2,
# }
# { package Math::PlanePath::DekkingCurve;
# }
# { package Math::PlanePath::DekkingCentres;
# }
# { package Math::PlanePath::CincoCurve;
# }
{ package Math::PlanePath::CornerReplicate;
  use constant _NumSeq_Turn_Turn4_min =>  # apparent minimum
    Math::NumSeq::PlanePathTurn::_turn_func_Turn4(-1,0, -2,-1);  # at N=11
  use constant _NumSeq_Turn_Turn4_max => 3; # apparent maximum
}
{ package Math::PlanePath::SquareReplicate;
  use constant _NumSeq_Turn_Turn4_max =>
    Math::NumSeq::PlanePathTurn::_turn_func_Turn4(2,1, 0,1);  # at N=9
}
{ package Math::PlanePath::DigitGroups;
  # radix=3 "11110222222"  len many 1s, 2*len-2 many 2s gives ever-increasing
  # radix=4 "1303333...3333" ever-increasing
}
{ package Math::PlanePath::FibonacciWordFractal;

  use constant _NumSeq_Turn_oeis_anum =>
    { '' =>
      { SRL => 'A156596', # turns 0=straight,1=right,2=left
        # OEIS-Catalogue: A156596 planepath=FibonacciWordFractal turn_type=SRL

        # Not quite, A003849 OFFSET=0 vs first turn N=1 here
        # Straight => 'A003849'
      },
    };
}
# { package Math::PlanePath::LTiling;
# }
{ package Math::PlanePath::WythoffArray;
  use constant _NumSeq_Turn_Turn4_max =>   # apparent maximum
    Math::NumSeq::PlanePathTurn::_turn_func_Turn4(-2,3, 5,-4);  # at N=12
}
{ package Math::PlanePath::WythoffPreliminaryTriangle;
  # apparent maximum, searched through to N=10_000_000
  # turn4 = 3.17777777777778
  use constant _NumSeq_Turn_Turn4_max =>
    Math::NumSeq::PlanePathTurn::_turn_func_Turn4(-54,-16, -8,13);  # at N=1344
}
{ package Math::PlanePath::PowerArray;

  # Turn4 ...
  #
  # radix=2
  #  min i=2[10] 1.50000  px=1,py=0 dx=-1,dy=1   -1.000
  # max i=3[11] 2.20000  px=-1,py=1 dx=2,dy=-1[10,-1]   -2.000
  #
  # radix=3
  #  min i=130[11211] 0.00000  px=-1,py=58 dx=0,dy=1   0.000
  # max i=67[2111] 3.98889  px=-1,py=30 dx=0,dy=1[0,1]   0.000
  #
  # radix=4
  #  min i=2[2] 0.00000  px=0,py=1 dx=0,dy=1   0.000
  # max i=53[311] 3.98889  px=-1,py=30 dx=0,dy=1[0,1]   0.000
  #
  # radix=5
  #  min i=2[2] 0.00000  px=0,py=1 dx=0,dy=1   0.000
  # max i=46[141] 3.98889  px=-1,py=29 dx=0,dy=1[0,1]   0.000
  #
  # radix=6
  #  min i=2[2] 0.00000  px=0,py=1 dx=0,dy=1   0.000
  # max i=43[111] 3.98889  px=-1,py=30 dx=0,dy=1[0,1]   0.000
  #
  # radix=7
  #  min i=2[2] 0.00000  px=0,py=1 dx=0,dy=1   0.000
  # max i=43[61] 3.98889  px=-1,py=31 dx=0,dy=1[0,1]   0.000
  #
  # radix=8
  #  min i=2[2] 0.00000  px=0,py=1 dx=0,dy=1   0.000
  # max i=41[51] 3.98889  px=-1,py=31 dx=0,dy=1[0,1]   0.000
  #
  # radix=9
  #  min i=2[2] 0.00000  px=0,py=1 dx=0,dy=1   0.000
  # max i=37[41] 3.98889  px=-1,py=29 dx=0,dy=1[0,1]   0.000
  #
  # radix=10
  #  min i=2[2] 0.00000  px=0,py=1 dx=0,dy=1   0.000
  # max i=41[41] 3.98889  px=-1,py=33 dx=0,dy=1[0,1]   0.000
  #
  # radix=16
  #  min i=2[2] 0.00000  px=0,py=1 dx=0,dy=1   0.000
  # max i=33[21] 3.98889  px=-1,py=29 dx=0,dy=1[0,1]   0.000
  #
  # radix=29
  #  min i=2[2] 0.00000  px=0,py=1 dx=0,dy=1   0.000
  # max i=59[21] 3.98889  px=-1,py=55 dx=0,dy=1[0,1]   0.000

  # use constant _NumSeq_oeis_anum =>
  #   # Not quite, A011765 0,0,0,1 repeating has OFFSET=1
  #   # cf n_start=1 is first turn at N=2
  #   # Left  => 'A011765',
  #   # Right => 'A011765',
  #
  #     # Not quite, A131534 has OFFSET=1 vs first turn at N=2 here
  #     # 'radix=3' =>
  #     # { SRL => 'A131534', # repeat 1,2,1, OFFSET=0
  #     # }
  #
  #     # Not quite, A007877 has OFFSET=1 vs first turn at N=2 here
  #     # 'radix=4' =>
  #     # { SRL => 'A007877', # repeat 0,1,2,1
  #     # }
  #
  #     # Not quite, 0,0,2,1,2 here vs A053796 0,2,1,2,0
  #     # 'radix=5' =>
  #     # { SRL => 'A053796', # repeat 0,2,1,2,0
  #     # }
  #   };
}
{ package Math::PlanePath::ToothpickTree;
  {
    my %_NumSeq_Turn_Turn4_max
      = (wedge => 3,  # at N=1 turn right
        );
    sub _NumSeq_Turn_Turn4_max {
      my ($self) = @_;
      return $_NumSeq_Turn_Turn4_max{$self->{'parts'}} || 4;
    }
  }
  {
    my %_NumSeq_Turn4_max_is_supremum
      = (wedge => 0,
        );
    sub _NumSeq_Turn4_max_is_supremum {
      my ($self) = @_;
      my $ret = $_NumSeq_Turn4_max_is_supremum{$self->{'parts'}};
      return (defined $ret ? $ret : 1);
    }
  }
}
{ package Math::PlanePath::ToothpickReplicate;
  {
    my %_NumSeq_Turn_Turn4_max
      = ( # at N=16
         '3' => Math::NumSeq::PlanePathTurn::_turn_func_Turn4(-1,3, 0,1),
        );
    sub _NumSeq_Turn_Turn4_max {
      my ($self) = @_;
      return $_NumSeq_Turn_Turn4_max{$self->{'parts'}} || 3.5;
    }
  }
}
{ package Math::PlanePath::ToothpickUpist;
  use constant _NumSeq_Turn_Turn4_max =>
    Math::NumSeq::PlanePathTurn::_turn_func_Turn4(-2,1, 2,0);  # at N=4
}
{ package Math::PlanePath::ToothpickSpiral;
  use constant _NumSeq_Turn_Turn4_min => 1; # left or right always
}
{ package Math::PlanePath::LCornerReplicate;
  # min i=63[333] 0.25556  px=1,py=0 dx=7,dy=3   2.333
  use constant _NumSeq_Turn_Turn4_min =>
    Math::NumSeq::PlanePathTurn::_turn_func_Turn4(1,0, 7,3);  # at N=63

  # higher N=1333..3333[base4] loop 3.8, 2.8, 1.7888, 0.7888
  # max i=8191[1333333] 3.80000  px=-1,py=0 dx=-38,dy=13[-212,31]   -2.923
  use constant _NumSeq_Turn_Turn4_max =>
    Math::NumSeq::PlanePathTurn::_turn_func_Turn4(-1,0, -38,13);  # at N=8191
}
{ package Math::PlanePath::LCornerTree;
  # parts=3 maybe maximum
  # max i=3107[300203] 3.98889  px=1,py=0 dx=66,dy=-1[1002,-1]   -66.000

  # LCornerTree,parts=diagonal-1 Turn4 values_max=4 vs saw_values_max=3 at i=27 (to i_end=801)

  {
    my %_NumSeq_Turn_Turn4_max
      = (wedge        => 3,  # at N=14
         'wedge+1'    => 3,  # at N=19
         diagonal     => 3,  # at N=21
         'diagonal-1' => 3,  # at N=27
        );
    sub _NumSeq_Turn_Turn4_max {
      my ($self) = @_;
      return $_NumSeq_Turn_Turn4_max{$self->{'parts'}} || 4;
    }
  }
  {
    my %_NumSeq_Turn4_max_is_supremum
      = (4 => 0,  # apparently
        );
    sub _NumSeq_Turn4_max_is_supremum {
      my ($self) = @_;
      return $_NumSeq_Turn4_max_is_supremum{$self->{'parts'}};
    }
  }
}

1;
__END__


=for stopwords Ryde Math-PlanePath NumSeq PlanePath SquareSpiral ie LSR dX,dY dx1,dy1 dx2,dy2 dx1 dx2 SRL dX

=head1 NAME

Math::NumSeq::PlanePathTurn -- turn sequence from PlanePath module

=head1 SYNOPSIS

 use Math::NumSeq::PlanePathTurn;
 my $seq = Math::NumSeq::PlanePathTurn->new (planepath => 'DragonCurve',
                                             turn_type => 'Left');
 my ($i, $value) = $seq->next;

=head1 DESCRIPTION

This is a tie-in to present turns from a C<Math::PlanePath> module in the
form of a NumSeq sequence.

The C<turn_type> choices are

    "Left"      1=left  0=right or straight
    "Right"     1=right 0=left or straight
    "Straight"  1=straight, 0=left or right
    "LSR"       1=left  0=straight -1=right
    "SLR"       0=straight 1=left  2=right
    "SRL"       0=straight 1=right 2=left

In each case the value at i is the turn which occurs at N=i,

            i+1
             ^
             |
             |
    i-1 ---> i     turn at i
                   first turn at i = n_start + 1

For multiple "arms" the turn follows that particular arm so it's i-arms, i,
i+arms.  i values start C<n_start()+arms_count()> so i-arms is C<n_start()>,
the first N on the path.  A single arm path beginning N=0 has its first turn
at i=1.

For "Straight", "LSR", "SLR" and "SRL", straight means either straight ahead
or 180-degree reversal, ie. the direction N to N+1 is along the same line as
N-1 to N was.

"Left" means to the left side of the N-1 to N line, so not straight or
right.  Similarly "Right" means to the right side of the N-1 to N line, so
not straight or left.

=head1 FUNCTIONS

See L<Math::NumSeq/FUNCTIONS> for behaviour common to all sequence classes.

=over 4

=item C<$seq = Math::NumSeq::PlanePathTurn-E<gt>new (key=E<gt>value,...)>

Create and return a new sequence object.  The options are

    planepath          string, name of a PlanePath module
    planepath_object   PlanePath object
    turn_type          string, as described above

C<planepath> can be either the module part such as "SquareSpiral" or a
full class name "Math::PlanePath::SquareSpiral".

=item C<$value = $seq-E<gt>ith($i)>

Return the turn at N=$i in the PlanePath.

=item C<$bool = $seq-E<gt>pred($value)>

Return true if C<$value> occurs as a turn.  Often this is merely the
possible turn values 1,0,-1, etc, but some spiral paths for example only go
left or straight in which case only 1 and 0 occur and C<pred()> reflects
that.

=item C<$i = $seq-E<gt>i_start()>

Return the first index C<$i> in the sequence.  This is the position
C<rewind()> returns to.

This is C<$path-E<gt>n_start() - $path-E<gt>arms_count()> from the
PlanePath object.

=back

=head1 FORMULAS

=head2 Turn Left or Right

A turn left or right is identified by considering the dX,dY at N-1 and at N.

    N+1      *
             |
             |
             |   dx2,dy2
             |
    N        *
            /
           /
          /  dx1,dy1
    N-1  *

With the two vectors dx1,dy1 and dx2,dy2 at a common origin, if the dx2,dy2
is above the dx1,dy1 line then it's a turn to the left, or below is a turn
to the right

    dx2,dy2
       *
       |   * dx1,dy1
       |  /
       | /
       |/
       o

At dx2 the Y value of the dx1,dy1 vector is

    cmpY = dx2 * dy1/dx1           if dx1 != 0

    left if dy2 > cmpY
            dy2 > dx2 * dy1/dx1
       so   dy2 * dx1 > dx2 * dy1

This cross-product comparison dy2*dx1 E<gt> dx2*dy1 works when dx1=0 too,
ie. when dx1,dy1 is vertical

    left if dy2 * 0 > dx2 * dy1
                  0 > dx2*dy1
    good, left if dx2 and dy1 opposite signs

So

    dy2*dx1 > dx2*dy1      left
    dy2*dx1 < dx2*dy1      right
    dy2*dx1 = dx2*dy1      straight, including 180 degree reverse

=head1 SEE ALSO

L<Math::NumSeq>,
L<Math::NumSeq::PlanePathCoord>,
L<Math::NumSeq::PlanePathDelta>,
L<Math::NumSeq::PlanePathN>

L<Math::NumberCruncher> has a C<Clockwise()> turn calculator

=head1 HOME PAGE

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

=head1 LICENSE

Copyright 2011, 2012, 2013, 2014, 2015 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