File Coverage

blib/lib/Math/Revhash.pm

Criterion	Covered	Total	%
statement	48	50	96.0
branch	22	24	91.6
condition	5	6	83.3
subroutine	12	12	100.0
pod	5	6	83.3
total	92	98	93.8

#!/usr/bin/perl
#made by: KorG
# vim: sw=4 ts=4 et cc=79 :

package Math::Revhash;

use 5.008;
use strict;
use warnings FATAL => 'all';
use Carp;
use Exporter 'import';
use Math::BigInt;

our $VERSION = '0.01';
$VERSION =~ tr/_//d;

our @EXPORT_OK = qw( revhash revunhash );

# Fast hashing is based on reverse modulo operations.
# Given HASH = NUMBER * A % C, then NUMBER = HASH * B % C in case of B is
# a modular inverse of A.
# To avoid hash collisions A should be a primary number.

# Pre-defined $A and $B for certain lengths
my $AB = {
    1 => [ 103, 7 ],
    2 => [ 929, 69 ],
    3 => [ 1619, 979 ],
    4 => [ 17027, 9963 ],
    5 => [ 88651, 58851 ],
    6 => [ 894407, 991543 ],
    7 => [ 16006519, 8315079 ],
    8 => [ 130067887, 91167823 ],
    9 => [ 2700655597, 882024933 ],
};

# See UNSAFE MODE
our $UNSAFE = 0;

# Parse and prepare arguments
# This function is used by revhash, revunhash and new subroutines
sub argsparse {
    my ($data, $len, $A, $B) = @_;

    croak "data not defined" unless defined $data;
    croak "Invalid length specified" unless defined $len and $len > 0;

    my $C = 10 ** $len;

    croak "data ($data) is out of range" unless $data > 0 and $data < $C;

    if (defined $A) {
        croak "Hash A value is invalid" unless $A > 0;
    } else {
        $A = $AB->{$len}->[0];
    }
    croak "Hash A value is undefined" unless defined $A;

    if (defined $B) {
        croak "Hash B value is invalid" unless $B > 0;
    } else {
        $B = $AB->{$len}->[1];
    }
    $B = Math::BigInt->bmodinv($A, $C) unless defined $B;
    croak "Invalid B value for such length and A" if Math::BigInt->is_nan($B);

    return ($data, $len, $A, $B, $C);
}

# Calculate hash of number
# args: $number, $length, $A, $B
sub revhash {
    if ($UNSAFE) {
        $_[4] = 10 ** $_[1];
    } else {
        @_ = argsparse @_;
    }

    sprintf "%0$_[1]d", $_[0] * $_[2] % $_[4];
}

# Calculate original number of hash
# args: $hash, $length, $A, $B
sub revunhash {
    if ($UNSAFE) {
        $_[4] = 10 ** $_[1];
    } else {
        @_ = argsparse @_;
    }

    $_[0] * $_[3] % $_[4];
}

# OO alias
sub hash { @_ = ($_[1], @{$_[0]}); goto &revhash }

# OO alias
sub unhash { @_ = ($_[1], @{$_[0]}); goto &revunhash }

# OO ctor
# args: $class, $length, $A, $B
sub new {
    my $obj;

    (undef, @{$obj}) = argsparse(1, @_[1..3]);

    bless $obj, $_[0];
}

1; # End of Math::Revhash

__END__