File Coverage

blib/lib/Math/NumSeq/Primorials.pm

Criterion	Covered	Total	%
statement	94	97	96.9
branch	19	22	86.3
condition	4	6	66.6
subroutine	18	18	100.0
pod	5	5	100.0
total	140	148	94.5

# Copyright2011, 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::Primorials;
use 5.004;
use strict;
use Math::Prime::XS;

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

# use constant name => Math::NumSeq::__('Primorials');
use constant description => Math::NumSeq::__('The primorials 1, 2, 6, 30, 210, etc, 2*3*5*7*...Prime(n).');
use constant i_start => 0;
use constant characteristic_increasing => 1;
use constant characteristic_integer => 1;
use constant values_min => 1;

# cf A034386 product of primes p <= i, so repeating 1, 2, 6, 6, 30, 30,
#    A143293 partial sums of primorials
#
use constant oeis_anum => 'A002110'; # starting at 1

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

use constant 1.02;  # for leading underscore
use constant _UV_LIMIT => do {
  my $u = ~0 >> 1;
  my $limit = 1;
  for my $p (Math::Prime::XS::sieve_primes(100)) {
    ### $p
    if ($u < $p) {
      ### _UV_LIMIT stop before prime: "p=$p"
      last;
    }
    $u -= ($u % $p);
    $u /= $p;
    $limit *= $p;
  }
  $limit
};
### _UV_LIMIT: _UV_LIMIT()

sub rewind {
  my ($self) = @_;
  ### Primorials rewind()
  $self->{'prime'} = 1;
  $self->{'i'} = $self->i_start;
  $self->{'f'} = 1;
}
sub next {
  my ($self) = @_;
  ### Primorials next() ...

  if (my $i = $self->{'i'}++) {
    my $f = $self->{'f'};
    if ($f >= _UV_LIMIT && ! ref $f) {
      $self->{'f'} = Math::NumSeq::_to_bigint($f);
    }
    my $prime;
    do {
      $prime = $self->{'prime'}++;
    } until (Math::Prime::XS::is_prime($prime));
    return ($i, $self->{'f'} *= $prime);

  } else {
    return (0, 1);
  }
}

sub ith {
  my ($self, $i) = @_;
  ### Primorials ith(): $i
  if (_is_infinite($i)) {
    return $i;
  }
  my $f = 1;
  my $prime = 1;
  while ($i-- > 0) {
    if ($f >= _UV_LIMIT && ! ref $f) {
      $f = Math::NumSeq::_to_bigint($f);
    }
    until (Math::Prime::XS::is_prime(++$prime)) {}
    $f *= $prime;
  }
  return $f;
}

sub pred {
  my ($self, $value) = @_;
  ### Primorials pred()
  my $prime = 2;
  for (;;) {
    if ($value <= 1) {
      return ($value == 1);
    }
    if ($value % $prime) {
      return 0;  # not divisible by this prime
    }

    $value /= $prime;
    if (($value % $prime) == 0) {
      return 0;  # doubled prime factor
    }

    until (Math::Prime::XS::is_prime(++$prime)) {}  # next $prime
  }
}

sub value_to_i_floor {
  my ($self, $value) = @_;
  if (_is_infinite($value)) {
    return $value;
  }
  if ($value < 2) {
    return $self->i_start;
  }

  my $i = 0;
  my $prime = 2;
  for (;;) {
    ### $value
    ### $i

    if ($value < $prime) {
      return $i;
    }
    $value = int($value/$prime);

    $i++;
    until (Math::Prime::XS::is_prime(++$prime)) {}  # next $prime
  }
}

# ENHANCE-ME: maybe a slightly squashed down log() would be close enough
#
*value_to_i_estimate = \&value_to_i_floor;

1;
__END__