File Coverage

blib/lib/Math/Rand48/Cursor.pm

Criterion	Covered	Total	%
statement	75	75	100.0
branch	9	10	90.0
condition	6	6	100.0
subroutine	15	15	100.0
pod	8	8	100.0
total	113	114	99.1

package Math::Rand48::Cursor;

use v5.34;
use warnings;
use experimental qw(signatures);
use Carp         qw(croak);
use Math::BigInt;
use Math::BigFloat;

our $VERSION = '0.001';

my $M  = Math::BigInt->bone->blsft(48);
my $A  = Math::BigInt->from_hex('5DEECE66D');    # drand48 multiplier
my $C  = Math::BigInt->new(11);                  # drand48 increment
my $AI = $A->copy->bmodinv($M);
my $CI = ( -$AI * $C ) % $M;

# Compose the step x -> a*x + c with itself n times, by squaring.
sub _affine_pow ( $a, $c, $n ) {
    my ( $ra, $rc ) = ( Math::BigInt->bone, Math::BigInt->bzero );
    my ( $ba, $bc ) = ( $a->copy, $c->copy );
    until ( $n->is_zero ) {
        ( $ra, $rc ) = ( ( $ba * $ra ) % $M, ( $ba * $rc + $bc ) % $M )
          if $n->is_odd;
        ( $ba, $bc ) = ( ( $ba * $ba ) % $M, ( $ba * $bc + $bc ) % $M );
        $n->brsft(1);
    }
    return ( $ra, $rc );
}

sub new ( $class, %arg ) {
    my $state =
      defined $arg{state}
      ? Math::BigInt->new("$arg{state}")
      : Math::BigInt->bzero;
    return bless { state => $state % $M }, $class;
}

sub from_rand ( $class, $obs ) {
    return $class->new( state => sprintf '%.0f', $obs * 2**48 );
}

sub from_seed48 ( $class, $seed ) {
    my $n = Math::BigFloat->new("$seed");
    croak "from_seed48() seed must be a finite number, got '$seed'"
      if $n->is_nan || $n->is_inf;
    my $int = $n->babs->bfloor->as_int;
    my $x   = $int->blsft(16)->bior( Math::BigInt->from_hex('330e') );
    return $class->new( state => $x );
}

sub state ($self) { $self->{state}->copy }
sub rand  ($self) { $self->{state}->numify / 2**48 }

sub seek ( $self, $n ) {
    my $steps = Math::BigInt->new("$n");
    croak "seek() count must be a finite integer, got '$n'"
      if $steps->is_nan || $steps->is_inf;
    my ( $a,  $c )  = $steps->is_negative ? ( $AI, $CI ) : ( $A, $C );
    my ( $pa, $pc ) = _affine_pow( $a, $c, $steps->babs );
    $self->{state} = ( $pa * $self->{state} + $pc ) % $M;
    return $self;
}

sub forward  ($self) { $self->seek(1) }
sub backward ($self) { $self->seek(-1) }

1;

__END__