File Coverage

blib/lib/Math/NumSeq/SelfLengthCumulative.pm

Criterion	Covered	Total	%
statement	75	76	98.6
branch	13	14	92.8
condition	2	3	66.6
subroutine	17	17	100.0
pod	5	5	100.0
total	112	115	97.3

# Copyright 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 .

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

use vars '$VERSION', '@ISA';
$VERSION = 72;

use Math::NumSeq;
@ISA = ('Math::NumSeq');
*_is_infinite = \&Math::NumSeq::_is_infinite;

use Math::NumSeq::Fibonacci;
*_blog2_estimate = \&Math::NumSeq::Fibonacci::_blog2_estimate;

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


use constant name => Math::NumSeq::__('Self Length Cumulative');
use constant description => Math::NumSeq::__('Cumulative digit length of own values.');
use constant default_i_start => 1;
use constant characteristic_increasing => 1;
use constant characteristic_integer => 1;
use constant values_min => 1;

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


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

my @oeis_anum;
$oeis_anum[10] = 'A064223';
# OEIS-Catalogue: A064223

sub oeis_anum {
  my ($self) = @_;
  return $oeis_anum[$self->{'radix'}];
}


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

sub rewind {
  my ($self) = @_;
  $self->{'i'} = $self->i_start;
  $self->{'value'} = 1;
  $self->{'power'} = $self->{'radix'};
  $self->{'length'} = 1;
}
sub next {
  my ($self) = @_;

  my $value = $self->{'value'};
  if ($value >= $self->{'power'}) {
    $self->{'power'} *= $self->{'radix'};
    $self->{'length'}++;
  }
  $self->{'value'} += $self->{'length'};
  return ($self->{'i'}++, $value);
}

sub pred {
  my ($self, $value) = @_;

  if ($value < 1 || $value != int($value)) {
    return 0;
  }
  if (_is_infinite($value)) {
    return undef;
  }

  my $length = 1;
  my $radix = $self->{'radix'};
  my $power = ($value * 0) + $radix;  # inherit bignum $value
  my $upto = 1;
  for (;;) {
    if ($value < $power) {
      return (($value - $upto) % $length) == 0;
    }
    $upto = $power + ($upto-$power)%$length;

    $power *= $radix;
    $length++;
  }
}

# value = 10  i=10
# value = 100  i=10+90/2
# value = 1000  i=10+90/2+900/3
#
# value = R^k
# i = R + R^2/2 + R^3/3 + ... + R^k/k
# i = R + R^2/2 + R^3/3 + ... + R^k/k
#   <= (R + R^2 + R^3 + ... + R^k)/k
#    = (R^(k+1)-1)/(R-1) /k
#   ~= R^k/k
# i ~= value/logR(value)
# logR(value) = log(value)/log(R)
#
# est(R^k) = R^k/k
# log(est(R^k)) = log(R^k/k)
#               = log(value) - log(k)
#
sub value_to_i_estimate {
  my ($self, $value) = @_;

  if ($value <= 1) {
    return 0;
  }

  my $t;
  if (defined (my $blog2 = _blog2_estimate($value))) {
    $t = $blog2 * log(2);
  } else {
    $t = log($value);
  }

  $self->{'logR'} = log($self->{'radix'});

  # integer divisor to help Math::BigInt
  my $div = int($t/$self->{'logR'});
  if ($div > 1) {
    $value /= $div;
  }
  return int($value);
}

1;
__END__