Use bigint and float perl - perl

Question

I am extremely new to Perl, so I hope you will excuse my inexperience.
I have the following lines of code:
use warnings;
use strict;
use POSIX 'ceil';
use bigint;
my($g, $y, $n) = ($ARGV[0], $ARGV[1], $ARGV[2]);
my $z = ceil(sqrt($n-1));
my $entry;
print "list1: \n";
for my $v (0 .. $z) {
$entry = ($g ** $v) % $n;
$entry = ($entry ** ($n - 2)) % $n;
$entry = ($entry * $y) % $n;
print "$entry : $v\n";
}
print "list2: \n";
for my $u (0 .. $z) {
$entry = ($g ** ($u * $z)) % $n;
print "$entry: $u\n";
}
I need to use the bigint environment because of some following statements. Whenever I look into $z it evaluates to 6 instead of 7, when i call my program with $n = 41. It looks as if the bigint environment rounds the value of the sqrt method. I also tried to use BigFloat instead of bigint, but then the result of $entry = ($g ** ($u * $z)) % $n; gets calculated wrong (with ($g, $y, $n) = (15, 38, 41) the result is 3, when $u reached 3 in the for loop, but should be 26 instead).
Is there any option to avoid this rounding, so I can use float while calculating the square root and bigint in all following statements, so the pow operation works properly?
My call is perl program.pl 15 38 41. I try to implement the baby-step-giant-step algorithm.

Answer 1

you need to use bignum, not bigint:
$ cat bauer.pl
#!/usr/bin/perl
use warnings;
use strict;
use POSIX;
use bigint;
my($g, $y, $n) = ($ARGV[0], $ARGV[1], $ARGV[2]);
my $z = ceil(sqrt($n-1));
$ perl r.pl
1.41421356237309504880168872420969807857
With your program signature:
$ cat bauer.pl
#!/usr/bin/perl
use warnings;
use strict;
use POSIX;
use bignum;
my($g, $y, $n) = ($ARGV[0], $ARGV[1], $ARGV[2]);
my $z = ceil(sqrt($n-1));
print STDOUT "$z\n";
$ perl bauer.pl 1 2 48
7

Answer 2

I'd recommend Math::BigFloat and Math::BigInt over the bigint pragma, practically always.
The pragma is "just a thin wrapper around various modules of the Math::BigInt family" says the (linked) doc, but has very non-trivial actions (the "Description" conveys it). Instead, use the classes to set up what you want burdened with infinite precision support, itself non-trivial and costly.
use warnings;
use strict;
use feature 'say';
use Math::BigFloat;
my($g, $y, $n) = ($ARGV[0], $ARGV[1], $ARGV[2]);
my $z = sqrt($n-1);
say $z;
my $num = Math::BigFloat->new( $z );
say $num;
my $num_ceil = $num->bceil();
say $num_ceil;
Update The shown calculation has no need for a big-number exponent
use warnings;
use strict;
use feature 'say';
use POSIX 'ceil';
use Math::BigInt;
my ($g, $y, $n) = #ARGV;
my $z = ceil(sqrt($n-1));
my $bg = Math::BigInt->new($g);
my $e;
for my $u (0 .. $z) {
$e = $bg->copy->bmodpow($u*$rnd, $n);
say "$u: $e";
}
There happens to be a bmodpow method, doing exactly what's needed and being
"far superior" at it. Most arithmetic methods modify their operands, thus copy() is chained in to preserve $bg for the next iteration. See "Modifying and =" bullet under Caveats in docs.
I declare $e outside of the loop to avoid the (copy) constructor running every time in the loop as the variable becomes (is assigned) a BigInt object, returned by the method. (I am not certain that this is needed or that it helps though.)

Answer 3

Whenever I look into $z it evaluates to 6 instead of 7,
use bigint; causes numeric literals to be replaced with Math::BigInt objects. For example,
1
gets replaced with
Math::BigInt->new(1)
Math::BigInt in turn overrides a number of operators when a Math::BigInt object is used as an operand.
As such,
use bigint;
my $z = ceil(sqrt($n-1));
is equivalent to
use Math::BigInt;
my $z = ceil(sqrt($n-Math::BigInt->new(1)));
which is equivalent to
use Math::BigInt;
my $temp = Math::BigInt->new(1); # 1 [BigInt]
$temp->bneg; # -1 [BigInt]
$temp->badd($n); # 40 [BigInt]
$temp->bsqrt(); # 6 [BigInt] <--- XXX
$temp = $temp->numify; # 6 [Primitive]
my $z = ceil($temp); # 6 [Primitive]
So, you are using a Math::BigInt when you don't want to. Don't do that!!! Simply use
# No "use bigint;"!!!
my $z = ceil(sqrt($n-1));
Of course, the algorithm to which you linked actually calls for
# No "use bigint;"!!!
my $z = ceil(sqrt($n));
Because use bigint; can have large effects at a distance, I personally find use bigint; far too magical. I'd much rather use Math::BigInt->new(...) where appropriate rather than having use bigint; convert all my numerical constants into Math::BigInt objects. I'd also rather use Math::BigInt's methods instead of overloaded operators. Far less surprises that way (e.g. such as the loss of big number support when using ceil).
use warnings;
use strict;
use feature qw( say );
use Config qw( %Config );
use Math::BigInt qw( );
use POSIX qw( ceil );
# Each of the arguments is expected to be in [0, 2^32).
# Should use exponentiation by squaring instead of larger number support.
sub pow_m {
my ($base, $exp, $mod) = #_;
my $n = Math::BigInt->new($base);
$n->bpow($exp);
$n->bmod($mod);
return $n->numify();
}
# Each of the arguments is expected to be in [0, 2^32).
# Requires a 64-bit integers or $e might overflow.
sub babystep_giantstep {
my ($g, $h, $mod) = #_;
my $m = ceil(sqrt($mod));
my %table;
my $e = 1;
for my $i (0..$m-1) {
$table{$e} = $i;
$e = ($e * $g) % $mod;
}
my $factor = pow_m($g, $mod-$m-1, $mod);
$e = $h;
for my $i (0..$m-1) {
if (exists($table{$e})) {
return $i*$m + $table{$e};
}
$e = ($e * $factor) % $mod;
}
return undef;
}
{
$Config{uvsize} >= 8
or warn("Results may overflow\n");
my ($g, $h, $mod) = #ARGV;
my $log = babystep_giantstep($g, $h, $mod);
say $log;
my $test = Math::BigInt->new($g);
$test->bpow($log);
$test->bmod($mod);
$test = $test->numify;
say $test == $h ? "ok" : "not ok";
}