File Coverage

blib/lib/Math/NumSeq/LiouvilleFunction.pm

Criterion	Covered	Total	%
statement	47	53	88.6
branch	4	4	100.0
condition	2	9	22.2
subroutine	15	18	83.3
pod	5	7	71.4
total	73	91	80.2

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

package Math::NumSeq::LiouvilleFunction;
use 5.004;
use strict;
use List::Util 'max','min';

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

use Math::NumSeq;
use Math::NumSeq::Base::IterateIth;
@ISA = ('Math::NumSeq::Base::IterateIth',
        'Math::NumSeq');

use Math::NumSeq::PrimeFactorCount;
*_prime_factors = \&Math::NumSeq::PrimeFactorCount::_prime_factors;

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


# use constant name => Math::NumSeq::__('Liouville Function');
use constant default_i_start => 1;

use constant parameter_info_array =>
  [ {
     name    => 'values_type',
     share_key => 'values_type_1-1_01_10',
     type    => 'enum',
     default => '1,-1',
     choices => ['1,-1',
                 '0,1',
                 '1,0',
                ],
     # TRANSLATORS: "1,-1" offered for translation of the "," if that might look like a decimal point, otherwise can be left unchanged
     choices_display => [Math::NumSeq::__('1,-1'),
                         Math::NumSeq::__('0,1'),
                         Math::NumSeq::__('1,0'),
                        ],
     description => Math::NumSeq::__('The values to give for even or odd parity.'),
    },
  ];

sub description {
  my ($self) = @_;
  my ($even,$odd) = (ref $self ? @{$self->{'values'}} : (1,-1));
  # ENHANCE-ME: use __x(), maybe
  return sprintf(Math::NumSeq::__('The Liouville function, being %s for an even number of prime factors or %s for an odd number.'),
                 $even, $odd);
}

use constant characteristic_increasing => 0;
sub characteristic_integer {
  my ($self) = @_;
  return (_is_integer($self->{'values_min'})
          && _is_integer($self->{'values_max'}));
}
sub characteristic_pn1 {
  my ($self) = @_;
  return ($self->{'values_min'} == -1 && $self->{'values_max'} == 1);
}

#------------------------------------------------------------------------------
# cf A026424  the -1 positions, odd number of primes
#    A028260  the 1 positions, even number of primes
#    A072203  cumulative +/-1
#    A055038  cumulative 1=odd
#    A028488  where cumulative==0
#    A051470  first cumulative==n

my %oeis_anum = ('1,-1' => 'A008836',  # liouville 1,-1
                 '0,1'  => 'A066829',  # 0 and 1
                 '1,0'  => 'A065043',  # 1 and 0
                 # OEIS-Catalogue: A008836
                 # OEIS-Catalogue: A066829 values_type=0,1
                 # OEIS-Catalogue: A065043 values_type=1,0
                );
sub oeis_anum {
  my ($self) = @_;
  return $oeis_anum{join(',',@{$self->{'values'}})};
}


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

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

  my @values = split /,/, $self->{'values_type'};
  $self->{'values'} = \@values;
  $self->{'values_min'} = min(@values);
  $self->{'values_max'} = max(@values);
  return $self;
}

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

  my ($good, @primes) = _prime_factors($i);
  return ($good
          ? $self->{'values'}->[scalar(@primes) & 1]
          : undef);
}

sub pred {
  my ($self, $value) = @_;
  return ($value == $self->{'values'}->[0]
          || $value == $self->{'values'}->[1]);
}

#------------------------------------------------------------------------------
# generic

sub _is_integer {
  my ($n) = @_;
  return ($n == int($n));
}

1;
__END__