File Coverage

blib/lib/Algorithm/SlopeOne.pm

Criterion	Covered	Total	%
statement	51	51	100.0
branch	8	8	100.0
condition			n/a
subroutine	10	10	100.0
pod	5	6	83.3
total	74	75	98.6

package Algorithm::SlopeOne;
# ABSTRACT: Slope One collaborative filtering for rated resources


use strict;
use utf8;
use warnings qw(all);

use Carp qw(confess);

our $VERSION = '0.004'; # VERSION


sub new {
    my ($class) = @_;
    return bless {
        diffs   => {},
        freqs   => {},
    } => $class;
}


sub diffs {
    my ($self) = @_;
    return $self->{diffs};
}

sub freqs {
    my ($self) = @_;
    return $self->{freqs};
}


sub clear {
    my ($self) = @_;

    for (qw(diffs freqs)) {
        delete $self->{$_};
        $self->{$_} = {};
    }

    return $self;
}


sub add {
    my ($self, $userprefs) = @_;

    my $type = ref $userprefs;
    if ($type eq q(HASH)) {
        $userprefs = [ $userprefs ];
    } elsif ($type eq q(ARRAY)) {
    } else {
        confess q(Expects a HashRef or an ArrayRef of HashRefs);
    }

    for my $ratings (@{$userprefs}) {
        for my $item1 (keys %{$ratings}) {
            for my $item2 (keys %{$ratings}) {
                $self->freqs->{$item1}{$item2} ++;
                $self->diffs->{$item1}{$item2} += $ratings->{$item1} - $ratings->{$item2};
            }
        }
    }

    return $self;
}


sub predict {
    my ($self, $userprefs) = @_;

    confess q(Expects a HashRef)
        unless q(HASH) eq ref $userprefs;

    my (%preds, %freqs);
    while (my ($item, $rating) = each %{$userprefs}) {
        while (my ($diffitem, $diffratings) = each %{$self->diffs}) {
            my $freq = $self->freqs->{$diffitem}{$item};
            next unless defined $freq;
            $preds{$diffitem} += $diffratings->{$item} + ($freq * $rating);
            $freqs{$diffitem} += $freq;
        }
    }

    return {
        map { $_ => $preds{$_} / $freqs{$_} }
        grep { not exists $userprefs->{$_} }
        keys %preds
    };
}


1;

__END__