File Coverage

blib/lib/Math/Revhash.pm

Criterion	Covered	Total	%
statement	48	48	100.0
branch	28	28	100.0
condition	6	6	100.0
subroutine	12	12	100.0
pod	5	5	100.0
total	99	99	100.0

#!/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.03';
$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, $C) = @_;

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

    if (defined $C) {
        croak "Hash C value is invalid" unless $C > 0;
    } else {
        $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->new($A)->bmodinv($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, $C
sub revhash {
    @_ = _argsparse @_ unless $UNSAFE;

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

# Calculate original number of hash
# args: $hash, $length, $A, $B, $C
sub revunhash {
    @_ = _argsparse @_ unless $UNSAFE;

    $_[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, $C
sub new {
    my $obj;

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

    bless $obj, $_[0];
}

1; # End of Math::Revhash

__END__