File Coverage

blib/lib/Math/NumSeq/AsciiSelf.pm

Criterion	Covered	Total	%
statement	97	100	97.0
branch	12	12	100.0
condition	11	19	57.8
subroutine	18	19	94.7
pod	6	7	85.7
total	144	157	91.7

# Copyright 2011, 2012, 2013, 2014 Kevin Ryde

# This file is part of Math-NumSeq.
#
# Math-NumSeq 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-NumSeq 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-NumSeq.  If not, see .

# math-image --values=AsciiSelf --output=list


package Math::NumSeq::AsciiSelf;
use 5.004;
use strict;

use vars '$VERSION', '@ISA';
$VERSION = 72;
use Math::NumSeq;
@ISA = ('Math::NumSeq');
*_is_infinite = \&Math::NumSeq::_is_infinite;

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


# use constant name => Math::NumSeq::__('Ascii Self');
use constant description => Math::NumSeq::__('Sequence is itself in ASCII.');
use constant i_start => 1;
use constant characteristic_increasing => 0;
use constant characteristic_smaller => 1;
use constant characteristic_integer => 1;

# use constant characteristic_charset => 'ASCII';
# sub characteristic_charset_digits {
#   my ($self) = @_;
#   return $self->{'radix'};
# }

use Math::NumSeq::Base::Digits
  'parameter_info_array';   # radix parameter

{
  my @values_min;
  my @values_max;
  $values_min[3] = 49;
  $values_min[6] = 49;
  $values_min[8] = $values_max[8] = 54;
  $values_min[11] = 49;
  $values_min[12] = 52;
  $values_min[14] = 49;
  $values_min[15] = 51;
  $values_min[16] = $values_max[16] = 51;  # only 51s
  $values_min[20] = 50;
  $values_min[21] = 50;
  $values_min[23] = 50;
  $values_min[24] = $values_max[24] = 50;  # only 50s
  $values_min[28] = 49;
  $values_min[29] = 49;
  $values_min[30] = 49;
  $values_min[31] = 49;
  $values_min[32] = 49;
  $values_min[33] = 49;
  $values_min[34] = 49;

  $values_max[6] = 50;
  $values_max[11] = 65;
  $values_max[12] = 52;
  $values_max[13] = 67;
  $values_max[14] = 68;
  $values_max[15] = 67;
  $values_max[16] = 51;
  $values_max[17] = 71;
  $values_max[18] = 72;
  $values_max[19] = 73;
  $values_max[20] = 72;
  $values_max[21] = 70;
  $values_max[22] = 76;
  $values_max[23] = 75;
  $values_max[24] = 50;
  $values_max[25] = 79;
  $values_max[26] = 80;
  $values_max[27] = 81;
  $values_max[28] = 77;
  $values_max[29] = 83;
  $values_max[30] = 82;
  $values_max[31] = 80;
  $values_max[32] = 80;
  $values_max[33] = 87;
  $values_max[34] = 78;
  $values_max[35] = 89;

  sub values_min {
    my ($self) = @_;
    my $radix = $self->{'radix'};
    return ($values_max[$radix] || 48);
  }
  sub values_max {
    my ($self) = @_;
    my $radix = $self->{'radix'};
    return ($values_max[$radix]
            || $radix + ($radix <= 10 ? 47 : 65-10));
  }
}

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

# cf A109648 ascii with comma and space
my @oeis_anum;
$oeis_anum[10] = 'A109733';
# OEIS-Catalogue: A109733
sub oeis_anum {
  my ($self) = @_;
  return $oeis_anum[$self->{'radix'}];
}

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

# ith() on radix 7 is wrong, report it as not available
sub can {
  my ($self, $name) = @_;
  if ($name eq 'ith' && ref $self && $self->{'radix'} == 7) {
    return undef;
  }
  return $self->SUPER::can($name);
}

sub rewind {
  my ($self) = @_;
  ### AsciiSelf rewind() ...
  $self->{'i'} = $self->i_start;

  # FIXME: this is a pre-calculation rather than a rewind ...
  my $radix = $self->{'radix'};
  ### $radix;
  my $start;
  foreach my $digit (0 .. $radix-1) {
    my $ascii = _digit_to_ascii($digit);
    my $r = $self->{'map'}->[$ascii] = [ _radix_ascii($radix,$ascii) ];
    if ($r->[0] == $ascii) {
      $start ||= $r->[0];
    }
  }
  $start ||= 48;
  $self->{'width'} = scalar(@{$self->{'map'}->[48]});
  $self->{'start'} = $start;
  ### $start

  $self->{'state'} = [ $self->{'map'}->[$start] ];
  $self->{'digits'} = [ -1 ];  # to start from 0 with preincrement
}

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

  my $state = $self->{'state'};
  my $digits = $self->{'digits'};
  my $pos = 0;
  my $digit;
  for (;;) {
    if ($pos >= @$digits) {
      push @$state, $self->{'map'}->[$self->{'start'}];
      push @$digits, ($digit = 1);

      ### extend at pos: $pos
      ### extended digits: $digits
      ### extended state: $state
      last;
    }
    $digit = ++($digits->[$pos]);
    if ($digit < scalar(@{$state->[$pos]})) {
      last;
    }
    $pos++;
  }

  ### $pos
  ### $digit

  my $value = $state->[$pos]->[$digit];
  while ($pos > 0) {
    ### $value
    my $newtable = $state->[--$pos] = $self->{'map'}->[$value];
    $digits->[$pos] = 0;
    $value = $newtable->[0];
  }

  ### now digits: $digits
  ### now state: $state
  ### final value: $value

  return ($self->{'i'}++, $value);
}

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

  if (_is_infinite($i) || ($i -= 1) < 0) {
    return undef;
  }

  my $map = $self->{'map'};
  my $width = $self->{'width'};
  my @digits;
  while ($i) {
    push @digits, $i % $width;
    $i = int($i/$width);
  }

  my $value = $self->{'start'};
  while (@digits) {
    my $digit = pop @digits;
    $value = $map->[$value]->[$digit];
  }
  return $value;
}

sub _radix_ascii {
  my ($radix, $n) = @_;
  my @digits;
  while ($n) {
    my $digit = ($n % $radix);
    push @digits, _digit_to_ascii($digit);
    $n = int($n/$radix);
  }
  return reverse @digits;
}

sub _digit_to_ascii {
  my ($digit) = @_;
  ### assert: $digit >= 0
  ### assert: $digit < 36
  return $digit + ($digit < 10 ? 48 : 65-10);  # '0' or 'A'
}

1;
__END__