File Coverage

blib/lib/Math/GrahamFunction/SqFacts.pm

Criterion	Covered	Total	%
statement	78	80	97.5
branch	14	16	87.5
condition	7	7	100.0
subroutine	18	18	100.0
pod	8	8	100.0
total	125	129	96.9

package Math::GrahamFunction::SqFacts;
$Math::GrahamFunction::SqFacts::VERSION = '0.02004';
use strict;
use warnings;


use parent qw(Math::GrahamFunction::Object);

use List::Util ();
__PACKAGE__->mk_accessors(qw(n factors));

sub _initialize
{
    my $self = shift;
    my $args = shift;

    if ( $args->{n} )
    {
        $self->n( $args->{n} );

        $self->_calc_sq_factors();
    }
    elsif ( $args->{factors} )
    {
        $self->factors( $args->{factors} );
    }
    else
    {
        die "factors or n must be supplied.";
    }

    return 0;
}


sub clone
{
    my $self = shift;
    return __PACKAGE__->new( { 'factors' => [ @{ $self->factors() } ] } );
}

sub _calc_sq_factors
{
    my $self = shift;

    $self->factors( $self->_get_sq_facts( $self->n() ) );

    return 0;
}

my %gsf_cache = ( 1 => [] );

sub _get_sq_facts
{
    my $self = shift;
    my $n    = shift;

    if ( exists( $gsf_cache{$n} ) )
    {
        return $gsf_cache{$n};
    }

    my $start_from = shift || 2;

    for ( my $p = $start_from ; ; ++$p )
    {
        if ( $n % $p == 0 )
        {
            # This function is recursive to make better use of the Memoization
            # feature.
            my $division_factors = $self->_get_sq_facts( ( $n / $p ), $p );
            if ( @$division_factors && ( $division_factors->[0] == $p ) )
            {
                return ( $gsf_cache{$n} =
                        [ @{$division_factors}[ 1 .. $#$division_factors ] ] );
            }
            else
            {
                return ( $gsf_cache{$n} = [ $p, @$division_factors ] );
            }
        }
    }
}

# Removed because it is too slow - we now use our own custom memoization (
# or perhaps it is just called caching)
# memoize('get_squaring_factors', 'NORMALIZER' => sub { return $_[0]; });

# This function multiplies the squaring factors of $n and $m to receive
# the squaring factors of ($n*$m)

# OOP-Wise, it should be a multi-method, but since we don't inherit this
# object it's all-right.


sub mult_by
{
    my $n_ref = shift;
    my $m_ref = shift;

    my @n = @{ $n_ref->factors() };
    my @m = eval { @{ $m_ref->factors() }; };
    if ($@)
    {
        print "Hello\n";
    }

    my @ret = ();

    while ( scalar(@n) && scalar(@m) )
    {
        if ( $n[0] == $m[0] )
        {
            shift(@n);
            shift(@m);
        }
        elsif ( $n[0] < $m[0] )
        {
            push @ret, shift(@n);
        }
        else
        {
            push @ret, shift(@m);
        }
    }
    push @ret, @n, @m;

    $n_ref->factors( \@ret );

    # 0 for success
    return 0;
}


sub mult
{
    my $n = shift;
    my $m = shift;

    my $result = $n->clone();
    $result->mult_by($m);
    return $result;
}


sub is_square
{
    my $self = shift;
    return ( scalar( @{ $self->factors() } ) == 0 );
}


sub exists
{
    my ( $self, $factor ) = @_;

    return defined( List::Util::first { $_ == $factor } @{ $self->factors() } );
}


sub last
{
    my $self = shift;

    return $self->factors()->[-1];
}

use vars qw($a $b);


sub product
{
    my $self = shift;

    return ( List::Util::reduce { $a * $b } @{ $self->factors() } );
}


sub first
{
    my $self = shift;

    return $self->factors()->[0];
}


1;

__END__