File Coverage

blib/lib/ConstantCalculus/CircleConstant.pm

Criterion	Covered	Total	%
statement	22	127	17.3
branch	0	38	0.0
condition			n/a
subroutine	8	17	47.0
pod	0	9	0.0
total	30	191	15.7

package ConstantCalculus::CircleConstant;

# Set the VERSION.
our $VERSION = "0.01";

# Load the Perl pragmas.
use 5.008009;
use strict;
use warnings;

# Load the Perl pragma Exporter.
use vars qw(@ISA @EXPORT @EXPORT_OK);
use Exporter 'import';

# Base class of this (tron_addr) module.
our @ISA = qw(Exporter);

# Exporting the implemented subroutine.
our @EXPORT = qw(
    pi_chudnovsky
    pi_chudnovsky_algorithm
    tau_chudnovsky
    tau_chudnovsky_algorithm
    $CONTROL_OUTPUT
);

# Exporting the multiply and divide  routine on demand basis.
@EXPORT_OK = qw(
    truncate_places
    chudnovsky_terms
    factorial
    pi
    tau
);

# Define the Perl BEGIN block.
BEGIN {
    # Set the subroutine aliases.
    *pi = \&pi_chudnovsky;
    *tau = \&tau_chudnovsky;
};

# Disable a warning.
no warnings 'recursion';

# Load the Perl module.
use bignum;;

# Set the precision for bignum.
bignum -> precision(-14);

# Set the zeros.
my $NEXT_DIGIT = int((log(151931373056000)/log(10))+1);

# Set verbose flag.
our $CONTROL_OUTPUT = 0;

# Flush output immediately to the terminal window.
local $| = 1;

#------------------------------------------------------------------------------#
# Subroutine is_unsigned_int()                                                 #
#------------------------------------------------------------------------------#
sub is_unsigned_int {
    # Assign the subroutine argument to the local variable.
    my $arg = (defined $_[0] ? $_[0] : '');
    # Set the Perl conform regex pattern.
    my $re = qr/^(([1-9][0-9]*)|0)$/;
    # Check the argument with the regex pattern.
    my $is_unsigned_int = (($arg =~ $re) ? 1 : 0);
    # Return 0 (false) or 1 (true).
    return $is_unsigned_int;
};

# ---------------------------------------------------------------------------- #
# Subroutine factorial()                                                       #
# ---------------------------------------------------------------------------- #
sub factorial {
  my $n = $_[0];
  my $fac = ($n == 0 ? 1 : factorial($n-1)*$n);
  return $fac;
};

# ---------------------------------------------------------------------------- #
# Subroutine chudnovsky_terms()                                                #
# ---------------------------------------------------------------------------- #
sub chudnovsky_terms {
    # Assign the subroutine argument to the local variable.
    my $places = (defined $_[0] ? $_[0] : 0);
    # Determine the estimated number of terms.
    my $number_terms = undef;
    if ($places <= 1) {
        $number_terms = $places;
    } elsif ($places <= 14) {
        $number_terms = 1;
    } else {
        $number_terms = int($places / $NEXT_DIGIT) + 2;
        $number_terms += ($number_terms % 2 == 0 ? 1 : 0);
    };
    # Return the estimated number of terms.
    return $number_terms;
};

# ---------------------------------------------------------------------------- #
# Subroutine truncate_places()                                                 #
# ---------------------------------------------------------------------------- #
sub truncate_places {
    my $decimal = $_[0];
    my $places = $_[1];
    my $factor = 10**$places;
    $decimal = int($decimal*$factor) / ($factor);
    $decimal = substr($decimal, 0, $places+2);
    return $decimal;
};

# ---------------------------------------------------------------------------- #
# Subroutine control_output()                                                  #
# ---------------------------------------------------------------------------- #
sub control_output {
    my $places = $_[0];
    my $terms = $_[1];
    my $precision = $_[2];
    my $type = $_[3];
    my $formula = $_[4];
    printf("%s\n", "Calculation Data");
    printf("%s\n", "================");
    printf("%-10s %s\n", "Formula:", $formula);
    printf("%-10s %s\n", "Type:", $type);
    printf("%-10s %s\n", "Precision:", $precision);
    printf("%-10s %s\n", "Places:", $places);
    printf("%-10s %s\n", "Terms:", $terms);
};

# ---------------------------------------------------------------------------- #
# Subroutine pi_chudnovsky_algorithm()                                         #
# ---------------------------------------------------------------------------- #
sub pi_chudnovsky_algorithm {
    # Assign the subroutine arguments to the local variables.
    my $places = (defined $_[0] ? $_[0] : 0);
    my $n = (defined $_[1] ? $_[1] : 0);
    my $p = (defined $_[2] ? $_[2] : 0);
    # Set the precision.
    bignum -> precision(-$p);
    # Initialise the return variable.
    my $pi = 0;
    # Set the local integer constants.
    my $c0 = 545140134;
    my $c1 = 13591409;
    my $c2 = 640320;
    my $c3 = 4270934400;
    my $c4 = 10005;
    # Set the initial values.
    my $a_k = 0;
    my $a_sum = 0;
    my $numerator = 0;
    my $denominator = 0;
    # Set the sign to 1.
    my $sign = 1;
    # Run index is of type int.
    for (my $k = 0; $k <= $n; $k++) {
        # Calculate numerator and denominator.
        $numerator = factorial(6*$k)*($c0*$k+$c1);
        $denominator = factorial(3*$k)*(factorial($k)**3)*($c2**(3*$k));
        # Calculate the quotient.
        $a_k = $sign*($numerator/$denominator);
        # Add quotient to total sum.
        $a_sum += $a_k;
        # Change the sign.
        $sign *= -1;
    };
    # Calculate the value of Pi.
    $pi = $c3 / (sqrt($c4)*$a_sum);
    # Return the value of Pi.
    return "$pi";
};

# ---------------------------------------------------------------------------- #
# Subroutine pi_chudnovsky()                                                   #
# ---------------------------------------------------------------------------- #
sub pi_chudnovsky {
    # Assign the subroutine arguments to the local variables.
    my $places = (defined $_[0] ? $_[0] : 0);
    # Check if places are valid numbers.
    if (is_unsigned_int($places) != 1) {
        print "The given number of places is not valid. Terminating processing. Bye!\n";
        exit;
    };
    # Calculate the number of needed terms.
    my $terms = chudnovsky_terms($places);
    # Set the precision for the calculation.
    my $precision = $places + $NEXT_DIGIT;
    # Print control output to the terminal window.
    if ($CONTROL_OUTPUT == 1) {
        my $formula = "Chudnovsky (Pi)";
        my $type = "decimal";
        control_output($places, $terms, $precision, $type, $formula);
    };
    # Get value of Pi from calculation.
    my $pi = pi_chudnovsky_algorithm($places, $terms, $precision);
    # Cut the decimal number to the needed places.
    $pi = truncate_places($pi, $places);
    # Return the value of pi.
    return "$pi";
};

# ---------------------------------------------------------------------------- #
# Subroutine tau_chudnovsky_algorithm()                                        #
# ---------------------------------------------------------------------------- #
sub tau_chudnovsky_algorithm {
    # Assign the subroutine arguments to the local variables.
    my $places = (defined $_[0] ? $_[0] : 0);
    my $n = (defined $_[1] ? $_[1] : 0);
    my $p = (defined $_[2] ? $_[2] : 0);
    # Set the precision.
    bignum -> precision(-$p);
    # Initialise the return variable.
    my $tau = 0;
    # Set the local integer constants.
    my $c0 = 545140134;
    my $c1 = 13591409;
    my $c2 = 640320;
    my $c3 = 4270934400;
    my $c4 = 10005;
    # Set the initial values.
    my $a_k = 0;
    my $a_sum = 0;
    my $numerator = 0;
    my $denominator = 0;
    # Set the sign to 1.
    my $sign = 1;
    # Run index is of type int.
    for (my $k = 0; $k <= $n; $k++) {
        # Calculate numerator and denominator.
        $numerator = factorial(6*$k)*($c0*$k+$c1);
        $denominator = factorial(3*$k)*(factorial($k)**3)*($c2**(3*$k));
        # Calculate the quotient.
        $a_k = $sign*($numerator/$denominator);
        # Add quotient to total sum.
        $a_sum += $a_k;
        # Change the sign.
        $sign *= -1;
    };
    # Calculate the value of Tau.
    $tau = (2*$c3) / (sqrt($c4)*$a_sum);
    # Return the value of Tau.
    return "$tau";
};

# ---------------------------------------------------------------------------- #
# Subroutine tau_chudnovsky()                                                  #
# ---------------------------------------------------------------------------- #
sub tau_chudnovsky {
    # Assign the subroutine arguments to the local variables.
    my $places = (defined $_[0] ? $_[0] : 0);
    # Check if places are valid numbers.
    if (is_unsigned_int($places) != 1) {
        print "The given number of places is not valid. Terminating processing. Bye!\n";
        exit;
    };
    # Calculate the number of needed terms.
    my $terms = chudnovsky_terms($places);
    # Set the precision for the calculation.
    my $precision = $places + $NEXT_DIGIT;
    # Print control output to the terminal window.
    if ($CONTROL_OUTPUT == 1) {
        my $formula = "Chudnovsky (Tau)";
        my $type = "decimal";
        control_output($places, $terms, $precision, $type, $formula);
    };
    # Get value of Pi from calculation.
    my $tau = tau_chudnovsky_algorithm($places, $terms, $precision);
    # Cut the decimal number to the needed places.
    $tau = truncate_places($tau, $places);
    # Return the value of pi.
    return "$tau";
};

1;
__END__