File Coverage

blib/lib/Math/PlanePath/AztecDiamondRings.pm

Criterion	Covered	Total	%
statement	101	106	95.2
branch	29	30	96.6
condition			n/a
subroutine	23	25	92.0
pod	6	6	100.0
total	159	167	95.2

# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020 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 .



# cute groupings
# AztecDiamondRings, FibonacciWord fibonacci_word_type plain, 10x10 scale 15


package Math::PlanePath::AztecDiamondRings;
use 5.004;
use strict;
#use List::Util 'min', 'max';
*min = \&Math::PlanePath::_min;
*max = \&Math::PlanePath::_max;

use vars '$VERSION', '@ISA';
$VERSION = 129;
use Math::PlanePath;
@ISA = ('Math::PlanePath');
*_sqrtint = \&Math::PlanePath::_sqrtint;

use Math::PlanePath::Base::Generic
  'round_nearest';

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


use constant parameter_info_array =>
  [
   Math::PlanePath::Base::Generic::parameter_info_nstart1(),
  ];

use constant n_frac_discontinuity => 0;
use constant xy_is_visited => 1;

sub x_negative_at_n {
  my ($self) = @_;
  return $self->n_start + 1;
}
sub y_negative_at_n {
  my ($self) = @_;
  return $self->n_start + 2;
}
use constant dx_minimum => -1;
use constant dx_maximum => 1;
use constant dy_minimum => -1;
use constant dy_maximum => 1;
use constant 1.02 _UNDOCUMENTED__dxdy_list => (1,0,   # E
                                               1,1,   # NE
                                               # not North
                                               -1,1,  # NW
                                               -1,0,  # W
                                               -1,-1, # SW
                                               0,-1,  # S
                                               1,-1); # SE;
use constant dsumxy_minimum => -2; # diagonals
use constant dsumxy_maximum => 2;
use constant ddiffxy_minimum => -2;
use constant ddiffxy_maximum => 2;
use constant dir_maximum_dxdy => (1,-1); # South-East
use constant turn_any_right => 0; # only left or straight


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

sub new {
  my $self = shift->SUPER::new(@_);
  if (! defined $self->{'n_start'}) {
    $self->{'n_start'} = $self->default_n_start;
  }
  return $self;
}

# starting from X axis and n_start=0
# d = [ 1, 2, 3, 4, 5 ]
# n = [ 0,4,12,24,40 ]
# N = (2 d^2 - 2 d)
#   = (2*$d**2 - 2*$d)
#   = ((2*$d - 2)*$d)
# d = 1/2 + sqrt(1/2 * $n + 1/4)
#   = (sqrt(2*$n+1) + 1)/2
#
# X negative axis
# d = [ 1, 2, 3, 4,5 ]
# n = [ 2, 8, 18, 32, 50 ]
# N = (2 d^2)

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

  # adjust to N=0 at origin X=0,Y=0
  $n = $n - $self->{'n_start'};
  if ($n < 0) { return; }

  my $d = int( (_sqrtint(2*$n+1) + 1)/2 );
  $n -= 2*$d*$d;   # to $n=0 half way around at horiz Y=-1 X<-1

  if ($n < 0) {
    my $x = -$d-$n-1;
    if ($n < -$d) {
      # top-right
      return ($x,
              min($n+2*$d, $d-1));
    } else {
      # top-left
      return (max($x, -$d),
              -1-$n);
    }
  } else {
    my $x = $n-$d;
    if ($n < $d) {
      # bottom-left
      my $y = -1-$n;
      return ($x,
              max($y, -$d));
    } else {
      # bottom-right
      return (min($x, $d-1),
              $n-2*$d);
    }
  }
}

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

  $x = round_nearest ($x);
  $y = round_nearest ($y);

  if ($x >= 0) {
    my $d = $x + abs($y);
    return (2*$d + 2)*$d + $y + $self->{'n_start'};
  }
  if ($y >= 0) {
    my $d = $y - $x;
    return 2*$d*$d - 1 - $y + $self->{'n_start'};
  } else {
    my $d = $y + $x;
    return (2*$d + 4)*$d + 1 - $y + $self->{'n_start'};
  }
}


#          |                   |  x2>=-x1         |
#    M---+ |               M-------M              |  +---M
#    |   | |               |   |   |              |  |   |
#    +---m |               +----m--+              |  m---+
#          |                   |                  |
#     -----+------      -------+-------      -----+--------
#          |                   |                  |
#
#          |                   |                  |
#    M---+ |               M-------M  y2>=-y1     |  +---M
#    |   | |               |   |   |              |  |   |
#    |   m |               |   |   |              |  m   |
#   -------+------      -------m-------      -----+--------
#    |   | |               |   |   |              |  |   |
#    M---+ |               M-------M              |  +---M
#          |                   |                  |
#
#          |                   |                  |
#     -----+------      -------+-------      -----+--------
#          |                   |                  |
#    +---m |               +--m----+              |  m---+
#    |   | |               |   |   |              |  |   |
#    M---+ |               M-------M              |  +---M
#          |                   |                  |

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

  $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;

  my $min_x = 0;
  my $min_y = ($y2 < 0   ? ($min_x = -1, $y2)
               : $y1 > 0 ? $y1
               : 0);
  if ($x2 < $min_x)    { $min_x = $x2 }  # right edge if 0/-1 not covered
  elsif ($x1 > $min_x) { $min_x = $x1 }  # left edge if 0/-1 not covered

  my $max_y = ($y2 >= -$y1 ? $y2 : $y1);
  my $max_x = ($x2 >= -$x1-($max_y<0) ? $x2 : $x1);

  ### min at: "$min_x, $min_y"
  ### max at: "$max_x, $max_y"
  return ($self->xy_to_n($min_x,$min_y),
          $self->xy_to_n($max_x,$max_y));
}

1;
__END__