File Coverage

blib/lib/Algorithm/LSH.pm

Criterion	Covered	Total	%
statement	39	90	43.3
branch	2	6	33.3
condition	3	11	27.2
subroutine	10	18	55.5
pod	9	9	100.0
total	63	134	47.0

package Algorithm::LSH;
use strict;
use warnings;
use base qw(Algorithm::LSH::Base);
use Algorithm::LSH::Bucket;
use UNIVERSAL::require;
use Scalar::Util qw(blessed);
use Carp;
use Storable qw( retrieve store );

our $VERSION = '0.00001_01';

__PACKAGE__->mk_accessors($_) for qw( hash bucket storage );

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

sub insert {
    my $self = shift;
    my ( $label, $vector ) = @_;
    my $hashed_arrayref = $self->hash->do_hashing($vector);
    $self->bucket->insert( $label, $vector, $hashed_arrayref );
}

sub nn {
    my $self = shift;
    my $nn   = $self->nearest_neighbours(@_);
    return $nn;
}

sub nearest_neighbours {
    my $self         = shift;
    my $vector       = shift;
    my $without_self = shift;
    my $neighbours   = $self->neighbours( $vector, $without_self );
    my $nn           = $self->nearest( $vector, $neighbours );
    return $nn;
}

sub neighbours {
    my $self            = shift;
    my $vector          = shift;
    my $without_self    = shift;
    my $hashed_arrayref = $self->hash->do_hashing($vector);
    my $neighbours =
      $self->bucket->select( $vector, $hashed_arrayref, $without_self );
    return $neighbours;
}

sub nearest {
    my $self       = shift;
    my $vector     = shift;
    my $neighbours = shift;
    my %nearest;
    for (@$neighbours) {
        my ( $n_label, $n_vector ) = each %$_;
        my $dist = $self->distance( $vector, $n_vector );
        if ( ! defined $nearest{distance} || $dist < $nearest{distance} ) {
            $nearest{label}    = $n_label;
            $nearest{vector}   = $n_vector;
            $nearest{distance} = $dist;
        }
    }
    return \%nearest;
}

sub distance {
    my $self     = shift;
    my $vector_1 = shift;
    my $vector_2 = shift;
    my $sum;
    for my $i ( 0 .. @{$vector_1} - 1 ) {
        my $d = ( $vector_1->[$i] - $vector_2->[$i] )**2;
        $sum += $d;
    }
    my $distance = sqrt($sum);
    return $distance;
}

sub save {
    my $self = shift;
    my $file_path = shift || './save.bin';
    $self->storage->save($file_path);
}

sub load {
    my $self      = shift;
    my $file_path = shift || './save.bin';
    my $data      = $self->storage->load($file_path);
    my $class     = blessed $data->hash;
    $class->use;
    for ( keys %$data ) {
        $self->$_( $data->$_ );
    }
}

sub _setup {
    my $self = shift;

    # param check
    $self->_check_parameters;

    # dynamic load (hash class)
    my $hash_class = delete $self->{hash_class};
    $hash_class ||= 'Algorithm::LSH::Hash::Hamming';
    $hash_class->require or croak $@;
    $self->hash( $hash_class->new( context => $self, @_ ) );

    # dynamic loading (storage class)
    my $storage_class = delete $self->{storage_class};
    $storage_class ||= 'Algorithm::LSH::Storage::Storable';
    $storage_class->require or croak $@;
    $self->storage( $storage_class->new( context => $self, @_ ) );

    # bucket class
    $self->bucket( Algorithm::LSH::Bucket->new( context => $self, @_ ) );
}

1;
__END__