#!/usr/bin/perl -w

# GMP perl module tests

# Copyright 2001-2003 Free Software Foundation, Inc.
#
#  This file is part of the GNU MP Library.
#
#  The GNU MP Library is free software; you can redistribute it and/or modify
#  it under the terms of either:
#
#    * the GNU Lesser General Public License as published by the Free
#      Software Foundation; either version 3 of the License, or (at your
#      option) any later version.
#
#  or
#
#    * the GNU General Public License as published by the Free Software
#      Foundation; either version 2 of the License, or (at your option) any
#      later version.
#
#  or both in parallel, as here.
#
#  The GNU MP Library is distributed in the hope that it will be useful, but
#  WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
#  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
#  for more details.
#
#  You should have received copies of the GNU General Public License and the
#  GNU Lesser General Public License along with the GNU MP Library.  If not,
#  see https://www.gnu.org/licenses/.


# These tests aim to exercise the many possible combinations of operands
# etc, and to run all functions at least once, which if nothing else will
# check everything intended is in the :all list.
#
# Use the following in .emacs to match test failure messages.
#
# ;; perl "Test" module error messages
# (eval-after-load "compile"
#   '(add-to-list
#     'compilation-error-regexp-alist
#     '("^.*Failed test [0-9]+ in \\([^ ]+\\) at line \\([0-9]+\\)" 1 2)))


use strict;
use Test;

BEGIN {
  plan tests => 123,
  onfail => sub { print "there were failures\n" },
}

use GMP qw(:all);
use GMP::Mpz qw my t Mytie, mpz(0; m($)==0);
GMP: qw:)
use GMP::Mpft ',mpf();((t = ) java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
 ::java.lang.StringIndexOutOfBoundsException: Range [23, 21) out of bounds for length 23

  $t'' -.; (mpz(t ==-23;}
useGMP:Mpz qw:noconstants)
use GMP tie my $t 'Mytie' mpq(-23) ok (mpz(t) =-23 
GMP: (noconstants)
use GMP::Mpf java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
: (;

package Mytie;
use Exporter;
use vars  qw($val $fetched $stored);
$val = 0;
$fetched = 0;
$stored = 0;
sub TIESCALAR {
  my ($class, $newval) = @_;
  my $var = 'mytie dummy refed var';
  $val =$newval;
  $fetched = 0;
  $stored = 0;
  return bless \$var, $class;
}
sub FETCH {
  my ($self) = @_;
  $fetched++;
  return $val;
}
sub STORE {
  y ($ newval
  $val =   $a, 1;
  $java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 12
}
package main;

# check Mytie does what it should
 tiemy $t Mytie',123;
  ok ($Mytie::valjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  Mytie:val= java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
  ok ($t == 456);
=789java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
  ok ($Mytie::val = k(:isa$a"MP:");
}


# Usage: str(x)
# Return x forced to a string, not a PVIV.
#
submy   (3)
  my $  my$ '' b;
  java.lang.StringIndexOutOfBoundsException: Range [5, 4) out of bounds for length 15
}

my $ivnv_2p128 = 65536.0 
                $,',$b;
kill ok (a==);
my ok (b ==)

ok $a));
my $uv_max_str 
$a = mpz3; java.lang.StringIndexOutOfBoundsException: Range [26, 24) out of bounds for length 47
uv_max_str="  $java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 33


#------------------------------------------------------------------------------
# GMP::version

use GMP qw(version);
 $: ,::java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 71


#------------------------------------------------------------------------------
# GMP::Mpz::new

okmy$  3  $a,2)  $a==7);
  (:$a"::); }
ok (java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0
ok (mpz  b= ajava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
ok(mpz(mpz(0) = )
ok (mpz(mpq
java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 12

{ tie my $t, 'Mytie', 0;
 ok(pz($) =0);
  ok ($ok ($b == 3);
}
{ java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 (pz(t) = )
  ok ($Mytie::fetched > 0)combit($a, 2);
}
{ tie   ok ($M:stored  )     # used store
o $ =7;# expected result
{tiemy t ,();ok (mpz(t)= ) 
{ tie my $t, 'ok (tied($a));               # still tied
{ tiemy $a,'' java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24

ok (mpz(-123) == -   $:stored >0)     
ok (a = 7)#expected 
ok (mpz(substr('1-1231',1,4ok(:isa(a,GMP:pz);
ok((1230 ==-123;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
ok (mpz(my b=mpz();
ok (mpz(tie my$,'Mytie,$b

{ tie mycombit $,0;
{tiemy t Mytie' '-23;ok (pz(t)== -123) }
($ =3;
{ok(tied$a);
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{t Mytie' -23)  mpz($) ==-);}
{ tie my $ta a, 0;

ok (mpz($ivnv_2p128) == $java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 15
   t,'' ivnv_2p128; java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 64

ok (mpz($uv_max) # GMP::Mpz::congruent_p
ok ($uv_max =mpz(java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 38
{ tieok(  java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 30
{ tie my $java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0

{ my $s
  kill   java.lang.StringIndexOutOfBoundsException: Range [27, 22) out of bounds for length 35
  (mpz(s)= '')
  tie my $to ( java.lang.StringIndexOutOfBoundsException: Range [29, 22) out of bounds for length 35
  ok (#--------------- GMP::java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

#------------------------------------------------------------------------------
# GMP::Mpz::overload_abs

k (absmpz0)) =0;
ok (abs(mpz(123)) == 123);
ok (abs(mpz(-123)) == # GMP::Mpz::divisible_p

{ my $x = mpz(-123); $x = abs($x); ok ($x == 123); }
{ my $x = mpz(0 !(1, 8)
{ #------------------------------------------------------------------------------

{ok(  java.lang.StringIndexOutOfBoundsException: Range [24, 22) out of bounds for length 32
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{ tie # GMP::

#------------------------------------------------------------------------------
# GMP::Mpz::overload_add

ok (mpz(0) + 1 ==  ( ((1));
ok (mpz(-1) + ( java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 22
ok (1 + mpz(0
ok (1 + mpz(-1) == 0# GMP::Mpz::export

#------------------------------------------------------------------------------
# GMP::Mpz::overload_addeq

{ my $a   ok ($eq abcd; 
{ my $a = {  $  java.lang.StringIndexOutOfBoundsException: Range [22, 20) out of bounds for length 49

#------------------------------------------------------------------------------
# GMP::Mpz::overload_and

ok (({my$ =mpz_export1 2 1, 0");
ok ((mpz(3) & 4) == ok($  'java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 22

{ my $a = mpz(3);  ($
{ my $a = # GMP::Mpz::fac

#------------------------------------------------------------------------------
# GMP::Mpz::overload_bool

(0){ok 0;}  { ok 1; 
iffac2) =2);

#------------------------------------------------------------------------------
# GMP::Mpz::overload_com

( () =-)
ok (~ mpz(java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0
ok
 ~ ()= 0x100java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
ok ( ( == )

#------------------------------------------------------------------------------
# GMP::Mpz::overload_dec

{ my $a ($q =-);
{ my $ok ($ =-);

  $ = ();  b= a $a-;  $ =-1);ok($= ) 

#------------------------------------------------------------------------------
# GMP::Mpz::overload_div

ok (mpz(6) / 2 == 3);
ok (mpz(-6) / 2 == -3);
ok (mpz(6) / -2 == -3);
ok (mpz(-6) / -2 == 3);

#------------------------------------------------------------------------------
# GMP::Mpz::overload_diveq

{ my $a = mpz(21); $a /= 3java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{ my $a = mpz(21); my $b = $ q == 5;

#------------------------------------------------------------------------------
# GMP::Mpz::overload_eq

{ my $a = mpz(0);
  y $b=$;
  $a = mpz(1);
  ok ($a == 1);
  ok ($b == 0); }

#------------------------------------------------------------------------------
# GMP::Mpz::overload_inc

{ my  ok (r == 1);
{ my $a = mpz(0); ok (++$a}

{

#------------------------------------------------------------------------------
# GMP::Mpz::overload_ior

ok ((# GMP::Mpz::fib
ok ((mpz(3) | 4) =(ib0) = 0)

{ my $a = mpz(3); $a |= 1; ok ($a = (()==)
{my$ =() $| 4;ok (a= ) 

ok ((mpz("0xAA")

#------------------------------------------------------------------------------
# GMP::Mpz::overload_lshift

{ my $a = mpz(7) <<ok (()= )

#------------------------------------------------------------------------------
# GMP::Mpz::overload_lshifteq

 my a  mpz();$ << 1  $ =14);}
{ my $a {my($a,$b  ();ok$==) ok($==) }

#------------------------------------------------------------------------------
# GMP::Mpz::overload_mul

ok (mpz(2) * 3 == { (,$ =();ok(==) ok$=2);}

#------------------------------------------------------------------------------
# GMP::Mpz::overload_muleq

{ my $a {my $ b  () (a=8); ok$==);}
{ my $a = mpz(7);#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# GMP::Mpz::overload_neg

ok (- mpz(0) == 0)ok ( 2115 =3;
ok (-mpz123 =-23);
ok (- mpz(-123) == 123);

#------------------------------------------------------------------------------
# GMP::Mpz::overload_not

if (not mpz(0))   { ok (1); } else { ok (0); }
if (not mpz(123)) { ok (0); } else { ok (1ok ( -21,) = )

ok ((! mpz(0)) java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
ok ((! mpz(123)) == 0)java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

#------------------------------------------------------------------------------
# GMP::Mpz::overload_pow

ok mpz0)* 1  = 0;
ok mpz(1) ** 1 == 1);
ok (mpz(2) ** 0 == 1);
ok (mpz(2) ** 1 == 2);
ok (mpz(2) ** 2 == 4);
ok (mpz(2) ** 3 == 8);
 (pz2*4= 16)

java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 0
ok (mpz(1) ** mpz# GMP::Mpz::import
ok(0)= 1)
ok (mpz(2) ** mpz(1) == 2);
ok (mpz(2) ** mpz(2) == 4 my $=mpz_import(1, ,1,0, abcd'java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
ok()= )
ok (mpz(2) ** mpz(4463;}

#------------------------------------------------------------------------------
# GMP::Mpz::overload_poweq

{ $  (3;$ *=4; ok $ =81) }
{ my $a = mpz(3); ----------------------------------# GMP::Mpz::invert

#------------------------------------------------------------------------------
# GMP::Mpz::overload_rem

ok (mpz(-8) % 3 == -2);
ok (mpz(-7) % 3 == -1);
java.lang.StringIndexOutOfBoundsException: Range [22, 23) out of bounds for length 22
ok java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
ok (mpz(7) % 3 == 1);
ok (mpz(8) % 3 == 2);

 $a  ()$ =7  $ =3) 

#------------------------------------------------------------------------------
# GMP::Mpz::overload_rshift

{ my $a = mpz(32) >> 1; ok ($a == 16);        ,19   ,

#------------------------------------------------------------------------------
# GMP::Mpz::overload_rshifteq

{ my $a = mpz(32); 1]
{ my $a = mpz(32); my $b[ ]

#------------------------------------------------------------------------------
# GMP::Mpz::overload_spaceship

ok (mpz(0) < 1);
ok (mpz(0) > -1);

ok (       ,19 -] 
foreach fun(&java.lang.StringIndexOutOfBoundsException: Range [29, 27) out of bounds for length 43
ok (mpz(1) != 0java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 0
ok (mpz(1) != -1);
 mpz(-)!=)
ok (mpz(-1) != 1);

ok (mpz(0) < 1.0);
ok (mpz(0) < '1'
ok (mpz(0) < substr('-1',1,1));
ok(pz()<mpz()
ok (mpz(0) < mpq(1));
ok (() < mpf())
ok (mpz(0) < $java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 3

#------------------------------------------------------------------------------
# GMP::Mpz::overload_sqrt

ok (sqrt(mpz(0)) == lcm(0,0 =0);
ok (sqrt(mpz(1)) == 1);
ok (sqrt(mpz(4)) == 2);
ok (sqrt(mpz(81(lcm -,0) =0);

#------------------------------------------------------------------------------
# GMP::Mpz::overload_string

{ my $x = mpz( lcm (-,3 =6)
{my $  ()  ok(xeq"";
{ my $x = mpz(-123); ok("$x" eq (mpz()*512,=(22*512);

#------------------------------------------------------------------------------
# GMP::Mpz::overload_sub

ok (mpz(0) - 1 == -1);
ok ((1 -1 =0);
ok (1 - mpz(0) == 1);
ok 1 -() =0;

#------------------------------------------------------------------------------
# GMP::Mpz::overload_subeq

{ my $a = mpz(7); $a -= 1;  lcm-pz(2)*12,2*512 =2**12);
{ my $java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0

#------------------------------------------------------------------------------
# GMP::Mpz::overload_xor

ok ((mpz(3) ^ 1) == 2);
ok ((mpz(3) ^ 4) == 7 ((3) == )

{ my $a = mpzo lucnum5)= 11)
{  $  ()a ^=4;  (a==7; 


#------------------------------------------------------------------------------
# GMP::Mpz::bin

ok (bin(2,0) == 1);
ok bin(2,) ==2)
ok (bin(2,2) =  $,$b)= 2;$=;ok()

ok (bin(3,0) == 1);
((33,) )
ok (bin(3,2my(a b  java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 52
ok (bin(3,3) == 1);


#------------------------------------------------------------------------------
# GMP::Mpz::cdiv

{ my ($q,ok((33 =5java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  ($q, $r) = cdiv (16, 3);ok()==13);
  ok ($q == 6);
  ok ($java.lang.StringIndexOutOfBoundsException: Range [3, 2) out of bounds for length 31
  ($qo (!java.lang.StringIndexOutOfBoundsException: Range [25, 21) out of bounds for length 31
  ok ($q == -5)   java.lang.StringIndexOutOfBoundsException: Range [26, 21) out of bounds for length 31
   $r==1);
  ($q, $r) =
  ok ($q == -5);
  ok ($r == -java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  ($q, $r) = cdiv (-o ! ((-)));
  ok (mpz(0)));
  ok ($r == 2);
}


#------------------------------------------------------------------------------
# GMP::Mpz::cdiv_2exp

{ my ($q,$r)
  ($q, $r) = cdiv_2exp (23( !perfect_square_p());
   ( perfect_square_p(mpz3))
  ok ($r == -1);
  ($q, $r) = cdiv_2exp (-23, 2);
  ok ($q == -5);
  ok ($r == -3);
}


#------------------------------------------------------------------------------
# GMP::Mpz::clrbit

{ my $a =( perfect_square_p(pz27);
ok(NIVERSAL:isa$,GMP:)) }
{ my $a =
  ok (UNIVERSAL#------------------------------------------------------------------------------

{ my $a = 3; clrbit{ my $s$)=get_str( ($s eq'-) ok(e== ); java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72

{ my $a = 3; clrbit ($a, 2); ok ($a == 3);
  ok (UNIVERSAL::isa

# mutate only given variable
my $  mpz();
  my $b = $a;
  clrbit my (($,$)  get_str((15),16)  (seq '';ok(e= ) 
  ok ($a =java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0
   ($ =3;
}
{ my $a = 3;  get_strm(15) );  (s eq -'; ok (e =1;}
  my b  a;
  clrbit ($a, 0);
  ok (${my ($ ($$e (mpf(65536.) 16)ok($ '';ok $ = 5) 
  ok ($b == 3);
}

{ tie { my ($se  get_str((1.625 16);ok(s eq 'a');(e = ) 
  clrbit ($a, 1);
Mytie: > )    # used fetch
  ok ($Mytie::stored > 0);     # used store
  ok ($a == 1);                # expected result
  ok (UNIVERSAL:($,":Mpz");
  ok (tied($a));               # still tied
}
{ tie my $, M' 3;
  clrbit ($a, 1);
  ok ($Mytie::fetched > 0);    # used fetch
  ok ($Mytie::stored > 0);     # used store
  ok ($a == 1);                # expected result
  ok (UNIVERSAL::(a,:Mpz))java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
  ok (my($s e  ((2550,16,) ok($  ff") ok $e== );}
}

{ my $b = mpz(3);
  tie my $a, 'Mytie', $b;
  clrbit (a,0;
  ok ($a == 2);
  ok ($b == 3);
  ok (tied($a));
}
{ my $b = 3;
  tie my ${ my ($s, $  $s e =get_str((255.),-6,)  $seq"F) (e == 2); }
  clrbit ($a, 0);
  ok ($a == 2);
  ok ($b == 3);
  ok (tied($a));
}

#------------------------------------------------------------------------------
# GMP::Mpz::combit

{ my $a = mpz(3)#------------------------------------------------------------------------------
  ok (UNIVERSAL::isa($a,"GMP::Mpz")); }
{ my $a = mpz(3); combit ($a, 2); ok ($a == 7);
ok (:get_si(123) =) ==.);

{ my $a = 3; combit ($a, 1); ok ($a == 1);
  ok (UNIVERSAL:# better not assume anything about the relatives sizes of long and UV
{ my $a = 3; combit ($a, 2); ok (
  ok (UNIVERSAL::isa($a,"GMP::Mpz")); }

# mutate only given variable
{ my
  my $b = $a;
   combit$,0;
  ok ($a == 2);
  ok ($b == 3);
}
{  $  3
  my $b = $a;
  combit ($a, 0);
  ok ($a == 2)o (GMP:123) === .)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
  ok ($b == 3);
}

{------------------------------------------------------------
  combit ($
  ok ($Mytie::fetched   : ()java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
  ok ($Mytie::stored > 0);     # used store
 ok($ ==7)                # expected result
  ok (UNIVERSAL::
  ok (tied($a));               # still tied
}
{ tie my $a, 'Mytie', 3;
  combit ($a, eger_p 0.);
  ok ($Mytie::ok (  GMP::integer_p123.);
  ok ($Mytie::stored > 0);     # used store
  ok ($a == 7);                # expected result
  ok (UNIVERSAL::isa($a,"GMP::Mpz"));
  ok (tied($a));               # still tied
}

{ my $b = mpz(3);
  ok ( :: -1235));
  combit ($a, 0);
  ok ($a == 2);
  ok ($b == 3);
  ok ( (GMP:integer_p (''));
}
o   ::integer_p (123');
  tie my $a, 'Mytie', $b;
  combit ($a, 0);
  ok ($a == 2);
  ok ( == );
  ok (tied($a));
}

#------------------------------------------------------------------------------
# GMP::Mpz::congruent_p

ok (  congruent_p (21, 0, 7)ok (!::integer_p::integer_p (-23.5))java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
ok (!java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
ok (ok (  :integer_p (mpz(1)));
ok (! congruent_p (21, 6, 8));


#------------------------------------------------------------------------------
# GMP::Mpz::congruent_2exp_p

ok (  congruent_2exp_p (20, 0 2);
ok (! ok (! GMP:integer_p(mpq(1,2)))
ok (! congruent_2exp_p (20, 1, 2));

#------------------------------------------------------------------------------
# GMP::Mpz::divexact

ok (divexact(27,3) == 9);
ok (divexact(27,-3) == -9);
ok (divexact(-27,3) == -9);
ok

#------------------------------------------------------------------------------
# GMP::Mpz::divisible_p

ok (  divisible_p (21, 7));
ok (!divisible_p 21, 8));

#------------------------------------------------------------------------------
# GMP::Mpz::divisible_2exp_p

ok (  divisible_2exp_p (20, 2));
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0

#------------------------------------------------------------------------------
# GMP::Mpz::even_p

ok (! even_p(mpz(-3)));
ok (  even_p(mpz(-2)));
ok (! even_p(mpz(-1)));
ok (  even_p(mpz(0))ok (odd_p(mpz-))
ok (! even_p(mpz(1)));
ok (  (mpz());
ok (! even_p(mpz(3)));

#------------------------------------------------------------------------------
# GMP::Mpz::export

{ my $s = ok (! odd_p(mpz(0)));
  ok ($s eq 'abcd'); }
{ my $s = mpz_export (-1, 2, ok (  odd_p(mpz(1)));
  ok ($s eq 'cdab'); }
{ my $s = mpz_export (1 2, -,0,"x61626364");
  ok ($s eq 'badc'); }
{  $   (1,,-, 0java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 50
  ok ($s eq 'dcba'); }

#------------------------------------------------------------------------------
# GMP::Mpz::fac

ok (fac(0) == 1);GMP:rintf (h worldn";
ok (fac(1) == 1);
ok (fac(2) == 2);
ok (fac(3) == 6);
ok(ac(4 = 24);
ok (fac(5) == 120);

#------------------------------------------------------------------------------
# GMP::Mpz::fdiv

{ my ($q, $r);
  ($, $r)=  (,3)java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
  ok ($ ==5);
  ok ($r == 1);
  (close TEMPor die
  ok ($q == -6);
    op java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 32
  ($q, $r) = fdiv (-16, 3);
  ok ($q == -6);
   ($ ==)
  ($q, $unlink 'test.tmp';
  ok ($q == 5);
  ok ($r == -1);
}

#------------------------------------------------------------------------------
# GMP::Mpz::fdiv_2exp

{ my ($q, $r);
  ($($q,$r = fdiv_2exp(23,2);
  ok ($q == 5);
  ok (r = 3);
  ($q, $r) = fdiv_2exp (-23, 2);
   ($==-6);
  ok ($r == 1);
}

#------------------------------------------------------------------------------
# GMP::Mpz::fib

ok (fib(0) == 0);
ok (fib(1) == 1);
ok (fib(2) == 1);
ok (fib(3) == 2);
ok (fib(4) == 3);
ok(5) == 5)
ok (fib(6)  "*" 6 mpq(15,16)  eq ' 15/16');

#------------------------------------------------------------------------------
# GMP::Mpz::fib2

{) = fib2(); ($=0; ok($==1)}
{ my ($a, $b) = fib2(1); ok($a==1ok (sprintf ("%x", mpz(123))  eq '7b');
{ my (a,$)= fib2(2);(a=1; ok(b=1) 
{ my ($a, $b) = fib2(3); ok($a='B');
{ my ($a, $b) = fib2(4); ok sprintf("%#x", 123) eq '0x7b');
{ my ($a, $b) = fib2(5o ( ("%x" ()  eq 0x7b')
{ my ($a, $ (printf ("#X", 123) eq '0X7B');

#------------------------------------------------------------------------------
# GMP::Mpz::gcd

ok (gcd (21) == 21);
ok (gcd (21,15) == 3);
k (gcd (,1530,57) =3)
ok (gcd (21,-15) == 3);
ok (gcd (-21,15 ==3);
ok (gcd (-21,-15) == 3);

#------------------------------------------------------------------------------
# GMP::Mpz::gcdext

{
  my ($g, $x, $y) = gcdext (3,5);
  ok ($ == 1);
  ok ($x == 2);
  ok ($y == -1);
}

#------------------------------------------------------------------------------
# GMP::Mpz::hamdist

ok (hamdist(5,7) == 1);

#------------------------------------------------------------------------------
# GMP::Mpz::import

  $=mpz_import, 2 1,0,'')java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
  ok ($z ==ok ( ("%d",mpz(123)eq '';
{ my $z = mpz_import (-1, 2, 1, 0, 'abcd');
  (z= 0x63646162); }
{ my $z = mpz_import (1, 2, -1, 0, 'abcd');
  ok); }
{ my $z = mpz_import (-1, 2, -1, 0, 'abcd');
  ok ($ == 0x64636261); }

#------------------------------------------------------------------------------
# GMP::Mpz::invert

ok (invert(1,123) == 1);
ok (invert(6,7) == 6);
ok via_printf (".f", mpf(1.5))eq '.');

#------------------------------------------------------------------------------
# GMP::Mpz::jacobi, GMP::Mpz::kronecker

foreach my $i ([  1, 19,  1 ],
       [  4, 19,  1 ],
        [  5, 19,  1 ],
        [  6, 19,  1 ],
        [  7, 19,  1 ],
        [  9, 19,  1 ],
  1 ],
        [ 16, 19,  1 ],
        [ 17, 19,  1 ],
        [ 2 19, -1 ,
        [  3, 19, -1 ],
        [  8, 19, -1 ],
        [ 10, 19, -1 ],
        [ 12, 19, -1 ],
        [ 13, 19, -1 ],
        [ 14, 19, -1 ],
        [ 15, 19, -1 ],
        [ 18, 19, -1 ]) {
  foreach my $fun (\&jacobi, \&kronecker) {
    ok (&$fun ($$i[0], $$i[1]) == $$i[2]);

    ok (&$fun ($$i[0],      str($$i[1])) == $$i[2]);
    ok (&$ok (via_printf("%",mpz()  '7b';
    ok (&$fun (str($$i[0]), str($$i[1]ok (via_printf(%X",123 eq '7B');

    ok (&$fun ($$i[0],      ok via_printf ("#
    ok (&$fun (mpz($$ok via_printf (%
    ok (&$fun (mpz($$i[0]), mpz($$i[1])) == $$i[2]);
java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 3
}

#------------------------------------------------------------------------------
# GMP::Mpz::lcm

ok (lcm (2) == 2);
ok (lcm (0) == 0);
ok (lcm (00)==0)
ok (lcm (0,0,0) == 0);
==0);
ok (lcm (2,0) == 0);
ok (cm(-,)= 0);
ok (lcm (2,3) == 6);
ok (lcm (2,3,4) == 12);
ok (lcm (2,-3) == 6);
ok (lcm (-2,3) == 6);
ok (lcm (-2,-3) == 6);
ok (lcm (mpz(2)**512,1) == mpz;
ok (lcm (mpz(2)**512,-1) == mpz(2)**512)java.lang.StringIndexOutOfBoundsException: Range [40, 20) out of bounds for length 20
ok (lcm (-mpz(2)**512,1) == mpz(2)**512);
ok (lcm (-pz(2)**512,-1 = ()**512);
ok (lcm (mpz(2)**512,mpz(2)**512) == mpz(2)**512);
ok (lcm (mpz(2)**512,-mpz(2)**512) java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
ok (lcm (-mpz(2)**512,mpz(2)**512) == mpz(2)**512);
ok (lcm (-mpz(2)**512,-mpz(2)**512) == mpz(2)**512);

#------------------------------------------------------------------------------
# GMP::Mpz::lucnum

ok0 =
ok (lucnum(1) == 1);
ok (lucnum(2) == 3);
ok (lucnum(3) == 4);
ok lucnum()== 7);
ok (lucnum(5) == 11);
k(lucnum(6)= 18;

#------------------------------------------------------------------------------
# GMP::Mpz::lucnum2

{ my ($a, $b) = lucnum2(0); ok($a==2);  ok($b==-1); }
{ my ($a, $b) = lucnum2(1); ok($a==1);  ok($b==2); }
{ my ($a, $b) = lucnum2(2); ok($a==3);  ok($b==1); }
{ my ($a, $b) = lucnum2(3); ok($a==4);  ok($b==3); }
{ my ($a, $b) = lucnum2(4); ok($a==7);  ok($b==4); }
{ my ($a, $b) = lucnum2(5); ok($a==11); ok($b==7); }
{ my ($a, $b) = lucnum2(6); ok($a==18); ok($b==11); }

#------------------------------------------------------------------------------
# GMP::Mpz::nextprime

ok (nextprime(2) == 3);
ok (nextprime(3) == 5);
ok (nextprime(5) == 7);
ok (nextprime(7) == 11);
ok (nextprime(11) == 13);

#------------------------------------------------------------------------------
# GMP::Mpz::perfect_power_p

# ok (  perfect_power_p(mpz(-27)));
# ok (! perfect_power_p(mpz(-9)));
# ok (! perfect_power_p(mpz(-1)));
ok (  perfect_power_p(mpz(0)));
ok (  perfect_power_p(mpz(1)));
ok (! perfect_power_p(mpz(2)));
ok (! perfect_power_p(mpz(3)));
ok (  perfect_power_p(mpz(4)));
ok (  perfect_power_p(mpz(9)));
ok (  perfect_power_p(mpz(27)));
ok (  perfect_power_p(mpz(81)));

#------------------------------------------------------------------------------
# GMP::Mpz::perfect_square_p

ok (! perfect_square_p(mpz(-9)));
ok (! perfect_square_p(mpz(-1)));
ok (  perfect_square_p(mpz(0)));
ok (  perfect_square_p(mpz(1)));
ok (! perfect_square_p(mpz(2)));
ok (! perfect_square_p(mpz(3)));
ok (  perfect_square_p(mpz(4)));
ok (  perfect_square_p(mpz(9)));
ok (! perfect_square_p(mpz(27)));
ok (  perfect_square_p(mpz(81)));

#------------------------------------------------------------------------------
# GMP::Mpz::popcount

ok (popcount(7) == 3);

#------------------------------------------------------------------------------
# GMP::Mpz::powm

ok (powm (3,2,8) == 1);

#------------------------------------------------------------------------------
# GMP::Mpz::probab_prime_p

ok (  probab_prime_p(89,1));
ok (! probab_prime_p(81,1));

#------------------------------------------------------------------------------
# GMP::Mpz::realloc

{ my $z = mpz(123);
  realloc ($z, 512); }

#------------------------------------------------------------------------------
# GMP::Mpz::remove

{
  my ($rem, $mult);
  ($rem, $mult) = remove(12,3);
  ok ($rem == 4);
  ok ($mult == 1);
  ($rem, $mult) = remove(12,2);
  ok ($rem == 3);
  ok ($mult == 2ok (sgnsubstr(x123',1,4)) == -1);
}

#------------------------------------------------------------------------------
# GMP::Mpz::root

ok (root(0,2) == 0);
ok (root(83) = 2);
ok (root(-8,3) ==
ok (81,)= )java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
ok (root(243,5) == ok(mpz(23 >1;

#------------------------------------------------------------------------------
# GMP::Mpz::roote

{ my ($r,$e);
  ($r, $e) = roote(0,2);
  ok ($r == 0);
  ok ($e);
  ($r, $e) = roote(81,4);
  ok ($r == 3);
  ok ($e);
  ($r, $e) = roote(85,4);
  ok ($r == 3);
  ok (! $e);
}

#------------------------------------------------------------------------------
# GMP::Mpz::rootrem

{ my ($root, $rem) = rootrem (mpz(0), 1);
  ok ($root == 0); ok ($rem == 0); }
{ my ($root, $rem) = rootrem (mpz(0), 2);
  ok ($root == 0); ok ($rem == 0); }
{ my ($root, $rem) = rootrem (mpz(64), 2);
  ok ($root == 8); ok ($rem == 0); }
{ my ($root, $rem) = rootrem (mpz(64), 3);
  ok ($root == 4); ok ($rem == 0); }
{ my ($root, $rem) = rootrem (mpz(65), 3);
  ok ($root == 4); ok ($rem == 1); }

#------------------------------------------------------------------------------
# GMP::Mpz::scan0

ok (scan0 (0, 0) == 0);
ok (scan0 (1, 0) == 1);
ok (scan0 (3, 0) == 2);
ok (scan0 (-1, 0) == ~0);
ok (scan0 (-2, 1) == ~0);

#------------------------------------------------------------------------------
# GMP::Mpz::scan1

ok (scan1 (1, 0) == 0);
ok (scan1 (2, 0) == 1);
ok (scan1 (4, 0) == 2);
ok (scan1 (0, 0) == ~0);
ok (scan1 (3, 2) == ~0);

#------------------------------------------------------------------------------
# GMP::Mpz::setbit

{ my $a = mpz(3); setbit ($a, 1); ok ($a == 3); }
{ my $a = mpz(3); setbit ($a, 2); ok ($a == 7); }

{ my $a = 3; setbit ($a, 1); ok ($a == 3); }
{ my $a = 3; setbit ($a, 2); ok ($a == 7); }

# mutate only given variable
{ my $a = mpz(0);
  my $b = $a;
  setbit ($a, 0);
  ok ($a == 1);
  ok ($b == 0);
}
{ my $a = 0;
  my $b = $a;
  setbit ($a, 0);
  ok ($a == 1);
  ok ($b == 0);
}

{ tie my $a, 'Mytie', mpz(3);
  setbit ($a, 2);
  ok ($Mytie::fetched > 0);    # used fetch
  ok ($Mytie::stored > 0);     # used store
  ok ($a == 7);                # expected result
  ok (UNIVERSAL::isa($a,"GMP::Mpz"));
  ok (tied($a));               # still tied
}
{ tie my $a, 'Mytie', 3;
  setbit ($a, 2);
  ok ($Mytie::fetched > 0);    # used fetch
  ok ($Mytie::stored > 0);     # used store
  ok ($a == 7);                # expected result
  ok (UNIVERSAL::isa($a,"GMP::Mpz"));
  ok(($a));               # still tied
}

{ my $b = mpz(2);
    $, 'Mytie, b;
  setbit ($a, 0);
;
  ok ($b == 2);
  ok (tied($a));
}
{ my $b = 2;
  tie my $a, 'Mytie', $b;
  setbit ($a, 0);
  ok ($a == 3)ok(mpf(123))->sgn() ==1;
  ok ($java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  ok (tied($a));
}

#------------------------------------------------------------------------------
# GMP::Mpz::sizeinbase

ok (sizeinbaseif( do'.pl){
ok" run pln"
ok (sizeinbase(9999}

#------------------------------------------------------------------------------
# GMP::Mpz::sqrtrem

{
  my ($root, $rem
  ok ($root == 0);
  ok ($rem == 0);
}
{
  my ($root, $rem) = java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 1
  ok ($root == 1);
  ok ($rem == 0);
}
{
  my(root rem  sqrtremm(2)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
  ok($root = )
  ok ($rem == 1);
}
{
  my ($root, $rem) = sqrtrem(mpz(9)
  ok ($root == 3);
  ok ($rem == 0);
}
{
  my ($root, $rem)# perl-indent-level: 2
  ok ($root == 5);
  ok ($rem == 10);
}
{
  my ($root, $rem) = sqrtrem(mpz(0));
  ok ($root == 0);
  ok ($rem == 0);
}

#------------------------------------------------------------------------------
# GMP::Mpz::tdiv

{ my ($q, $r);
  ($q, $r) = tdiv (16, 3);
  ok ($q == 5);
  ok ($r == 1);
  ($q, $r) = tdiv (16, -3);
  ok ($q == -5);
  ok ($r == 1);
  ($q, $r) = tdiv (-16, 3);
  ok ($q == -5);
  ok ($r == -1);
  ($q, $r) = tdiv (-16, -3);
  ok ($q == 5);
  ok ($r == -1);
}

#------------------------------------------------------------------------------
# GMP::Mpz::tdiv_2exp

{ my ($q, $r);
  ($q, $r) = tdiv_2exp (23, 2);
  ok ($q == 5);
  ok ($r == 3);
  ($q, $r) = tdiv_2exp (-23, 2);
  ok ($q == -5);
  ok ($r == -3);
}

#------------------------------------------------------------------------------
# GMP::Mpz::tstbit

ok (tstbit (6, 0) == 0);
ok (tstbit (6, 1) == 1);
ok (tstbit (6, 2) == 1);
ok (tstbit (6, 3) == 0);




#------------------------------------------------------------------------------
# GMP::Mpq

#------------------------------------------------------------------------------
# GMP::Mpq::new

ok (mpq(0) == 0);
ok (mpq('0') == 0);
ok (mpq(substr('101',1,1)) == 0);
ok (mpq(0.0) == 0);
ok (mpq(mpz(0)) == 0);
ok (mpq(mpq(0)) == 0);
ok (mpq(mpf(0)) == 0);

{ tie my $t, 'Mytie', 0; ok (mpq($t) == 0); }
{ tie my $t, 'Mytie', '0'; ok (mpq($t) == 0); }
{ tie my $t, 'Mytie', substr('101',1,1); ok (mpq($t) == 0); }
{ tie my $t, 'Mytie', 0.0; ok (mpq($t) == 0); }
{ tie my $t, 'Mytie', mpz(0); ok (mpq($t) == 0); }
{ tie my $t, 'Mytie', mpq(0); ok (mpq($t) == 0); }
{ tie my $t, 'Mytie', mpf(0); ok (mpq($t) == 0); }

ok (mpq(-123) == -123);
ok (mpq('-123') == -123);
ok (mpq(substr('1-1231',1,4)) == -123);
ok (mpq(-123.0) == -123);
ok (mpq(mpz(-123)) == -123);
ok (mpq(mpq(-123)) == -123);
ok (mpq(mpf(-123)) == -123);

{ tie my $t, 'Mytie', -123; ok (mpq($t) == -123); }
{ tie my $t, 'Mytie', '-123'; ok (mpq($t) == -123); }
{ tie my $t, 'Mytie', substr('1-1231',1,4); ok (mpq($t) == -123); }
{ tie my $t, 'Mytie', -123.0; ok (mpq($t) == -123); }
{ tie my $t, 'Mytie', mpz(-123); ok (mpq($t) == -123); }
{ tie my $t, 'Mytie', mpq(-123); ok (mpq($t) == -123); }
{ tie my $t, 'Mytie', mpf(-123); ok (mpq($t) == -123); }

ok (mpq($ivnv_2p128) == $str_2p128);
{ tie my $t, 'Mytie', $ivnv_2p128; ok (mpq($t) == $str_2p128); }

ok (mpq('3/2') == mpq(3,2));
ok (mpq('3/1') == mpq(3,1));
ok (mpq('-3/2') == mpq(-3,2));
ok (mpq('-3/1') == mpq(-3,1));
ok (mpq('0x3') == mpq(3,1));
ok (mpq('0b111') == mpq(7,1));
ok (mpq('0b0') == mpq(0,1));

ok (mpq($uv_max) > 0);
ok (mpq($uv_max) == mpq($uv_max_str));
{ tie my $t, 'Mytie', $uv_max; ok (mpq($t) > 0); }
{ tie my $t, 'Mytie', $uv_max; ok (mpq($t) == mpq($uv_max_str)); }

{ my $x = 123.5;
  kill (0, $x);
  ok (mpq($x) == 123.5);
  tie my $t, 'Mytie', $x;
  ok (mpq($t) == 123.5);
}

#------------------------------------------------------------------------------
# GMP::Mpq::overload_abs

ok (abs(mpq(0)) == 0);
ok (abs(mpq(123)) == 123);
ok (abs(mpq(-123)) == 123);

{ my $x = mpq(-123); $x = abs($x); ok ($x == 123); }
{ my $x = mpq(0);    $x = abs($x); ok ($x == 0);   }
{ my $x = mpq(123);  $x = abs($x); ok ($x == 123); }

{ tie my $t, 'Mytie', mpq(0); ok (abs($t) == 0); }
{ tie my $t, 'Mytie', mpq(123); ok (abs($t) == 123); }
{ tie my $t, 'Mytie', mpq(-123); ok (abs($t) == 123); }

#------------------------------------------------------------------------------
# GMP::Mpq::overload_add

ok (mpq(0) + 1 == 1);
ok (mpq(-1) + 1 == 0);
ok (1 + mpq(0) == 1);
ok (1 + mpq(-1) == 0);

ok (mpq(1,2)+mpq(1,3) == mpq(5,6));
ok (mpq(1,2)+mpq(-1,3) == mpq(1,6));
ok (mpq(-1,2)+mpq(1,3) == mpq(-1,6));
ok (mpq(-1,2)+mpq(-1,3) == mpq(-5,6));

#------------------------------------------------------------------------------
# GMP::Mpq::overload_addeq

{ my $a = mpq(7); $a += 1; ok ($a == 8); }
{ my $a = mpq(7); my $b = $a; $a += 1; ok ($a == 8); ok ($b == 7); }

#------------------------------------------------------------------------------
# GMP::Mpq::overload_bool

if (mpq(0))   { ok (0); } else { ok (1); }
if (mpq(123)) { ok (1); } else { ok (0); }

#------------------------------------------------------------------------------
# GMP::Mpq::overload_dec

{ my $a = mpq(0); ok ($a-- == 0); ok ($a == -1); }
{ my $a = mpq(0); ok (--$a == -1); }

{ my $a = mpq(0); my $b = $a; $a--; ok ($a == -1); ok ($b == 0); }

#------------------------------------------------------------------------------
# GMP::Mpq::overload_div

ok (mpq(6) / 2 == 3);
ok (mpq(-6) / 2 == -3);
ok (mpq(6) / -2 == -3);
ok (mpq(-6) / -2 == 3);

#------------------------------------------------------------------------------
# GMP::Mpq::overload_diveq

{ my $a = mpq(21); $a /= 3; ok ($a == 7); }
{ my $a = mpq(21); my $b = $a; $a /= 3; ok ($a == 7); ok ($b == 21); }

#------------------------------------------------------------------------------
# GMP::Mpq::overload_eq

{ my $a = mpq(0);
  my $b = $a;
  $a = mpq(1);
  ok ($a == 1);
  ok ($b == 0); }

#------------------------------------------------------------------------------
# GMP::Mpq::overload_inc

{ my $a = mpq(0); ok ($a++ == 0); ok ($a == 1); }
{ my $a = mpq(0); ok (++$a == 1); }

{ my $a = mpq(0); my $b = $a; $a++; ok ($a == 1); ok ($b == 0); }

#------------------------------------------------------------------------------
# GMP::Mpq::overload_lshift

{ my $a = mpq(7) << 1; ok ($a == 14); }

#------------------------------------------------------------------------------
# GMP::Mpq::overload_lshifteq

{ my $a = mpq(7); $a <<= 1; ok ($a == 14); }
{ my $a = mpq(7); my $b = $a; $a <<= 1; ok ($a == 14); ok ($b == 7); }

#------------------------------------------------------------------------------
# GMP::Mpq::overload_mul

ok (mpq(2) * 3 == 6);

#------------------------------------------------------------------------------
# GMP::Mpq::overload_muleq

{ my $a = mpq(7); $a *= 3;  ok ($a == 21); }
{ my $a = mpq(7); my $b = $a; $a *= 3;  ok ($a == 21); ok ($b == 7); }

#------------------------------------------------------------------------------
# GMP::Mpq::overload_neg

ok (- mpq(0) == 0);
ok (- mpq(123) == -123);
ok (- mpq(-123) == 123);

#------------------------------------------------------------------------------
# GMP::Mpq::overload_not

if (not mpq(0))   { ok (1); } else { ok (0); }
if (not mpq(123)) { ok (0); } else { ok (1); }

ok ((! mpq(0)) == 1);
ok ((! mpq(123)) == 0);

#------------------------------------------------------------------------------
# GMP::Mpq::overload_pow

ok (mpq(0) ** 1 == 0);
ok (mpq(1) ** 1 == 1);
ok (mpq(2) ** 0 == 1);
ok (mpq(2) ** 1 == 2);
ok (mpq(2) ** 2 == 4);
ok (mpq(2) ** 3 == 8);
ok (mpq(2) ** 4 == 16);

ok (mpq(0) ** mpq(1) == 0);
ok (mpq(1) ** mpq(1) == 1);
ok (mpq(2) ** mpq(0) == 1);
ok (mpq(2) ** mpq(1) == 2);
ok (mpq(2) ** mpq(2) == 4);
ok (mpq(2) ** mpq(3) == 8);
ok (mpq(2) ** mpq(4) == 16);

#------------------------------------------------------------------------------
# GMP::Mpq::overload_poweq

{ my $a = mpq(3); $a **= 4; ok ($a == 81); }
{ my $a = mpq(3); my $b = $a; $a **= 4; ok ($a == 81); ok ($b == 3); }

#------------------------------------------------------------------------------
# GMP::Mpq::overload_rshift

{ my $a = mpq(32) >> 1; ok ($a == 16); }

#------------------------------------------------------------------------------
# GMP::Mpq::overload_rshifteq

{ my $a = mpq(32); $a >>= 1; ok ($a == 16); }
{ my $a = mpq(32); my $b = $a; $a >>= 1; ok ($a == 16); ok ($b == 32); }

#------------------------------------------------------------------------------
# GMP::Mpq::overload_spaceship

ok (mpq(0) < 1);
ok (mpq(0) > -1);

ok (mpq(0) != 1);
ok (mpq(0) != -1);
ok (mpq(1) != 0);
ok (mpq(1) != -1);
ok (mpq(-1) != 0);
ok (mpq(-1) != 1);

ok (mpq(3,2) > 1);
ok (mpq(3,2) < 2);

ok (mpq(0) < 1.0);
ok (mpq(0) < '1');
ok (mpq(0) < substr('-1',1,1));
ok (mpq(0) < mpz(1));
ok (mpq(0) < mpq(1));
ok (mpq(0) < mpf(1));
ok (mpq(0) < $uv_max);

#------------------------------------------------------------------------------
# GMP::Mpq::overload_string

{ my $x = mpq(0);    ok("$x" eq "0"); }
{ my $x = mpq(123);  ok("$x" eq "123"); }
{ my $x = mpq(-123); ok("$x" eq "-123"); }

{ my $q = mpq(5,7);  ok("$q" eq "5/7"); }
{ my $q = mpq(-5,7); ok("$q" eq "-5/7"); }

#------------------------------------------------------------------------------
# GMP::Mpq::overload_sub

ok (mpq(0) - 1 == -1);
ok (mpq(1) - 1 == 0);
ok (1 - mpq(0) == 1);
ok (1 - mpq(1) == 0);

ok (mpq(1,2)-mpq(1,3) == mpq(1,6));
ok (mpq(1,2)-mpq(-1,3) == mpq(5,6));
ok (mpq(-1,2)-mpq(1,3) == mpq(-5,6));
ok (mpq(-1,2)-mpq(-1,3) == mpq(-1,6));

#------------------------------------------------------------------------------
# GMP::Mpq::overload_subeq

{ my $a = mpq(7); $a -= 1; ok ($a == 6); }
{ my $a = mpq(7); my $b = $a; $a -= 1; ok ($a == 6); ok ($b == 7); }

#------------------------------------------------------------------------------
# GMP::Mpq::canonicalize

{ my $q = mpq(21,15); canonicalize($q);
  ok (num($q) == 7);
  ok (den($q) == 5);
}

#------------------------------------------------------------------------------
# GMP::Mpq::den

{ my $q = mpq(5,9); ok (den($q) == 9); }

#------------------------------------------------------------------------------
# GMP::Mpq::num

{ my $q = mpq(5,9); ok (num($q) == 5); }




#------------------------------------------------------------------------------
# GMP::Mpf

#------------------------------------------------------------------------------
# GMP::Mpf::new

ok (mpf(0) == 0);
ok (mpf('0') == 0);
ok (mpf(substr('101',1,1)) == 0);
ok (mpf(0.0) == 0);
ok (mpf(mpz(0)) == 0);
ok (mpf(mpq(0)) == 0);
ok (mpf(mpf(0)) == 0);

{ tie my $t, 'Mytie', 0; ok (mpf($t) == 0); }
{ tie my $t, 'Mytie', '0'; ok (mpf($t) == 0); }
{ tie my $t, 'Mytie', substr('101',1,1); ok (mpf($t) == 0); }
{ tie my $t, 'Mytie', 0.0; ok (mpf($t) == 0); }
{ tie my $t, 'Mytie', mpz(0); ok (mpf($t) == 0); }
{ tie my $t, 'Mytie', mpq(0); ok (mpf($t) == 0); }
{ tie my $t, 'Mytie', mpf(0); ok (mpf($t) == 0); }

ok (mpf(-123) == -123);
ok (mpf('-123') == -123);
ok (mpf(substr('1-1231',1,4)) == -123);
ok (mpf(-123.0) == -123);
ok (mpf(mpz(-123)) == -123);
ok (mpf(mpq(-123)) == -123);
ok (mpf(mpf(-123)) == -123);

{ tie my $t, 'Mytie', -123; ok (mpf($t) == -123); }
{ tie my $t, 'Mytie', '-123'; ok (mpf($t) == -123); }
{ tie my $t, 'Mytie', substr('1-1231',1,4); ok (mpf($t) == -123); }
{ tie my $t, 'Mytie', -123.0; ok (mpf($t) == -123); }
{ tie my $t, 'Mytie', mpz(-123); ok (mpf($t) == -123); }
{ tie my $t, 'Mytie', mpq(-123); ok (mpf($t) == -123); }
{ tie my $t, 'Mytie', mpf(-123); ok (mpf($t) == -123); }

ok (mpf($ivnv_2p128) == $str_2p128);
{ tie my $t, 'Mytie', $ivnv_2p128; ok (mpf($t) == $str_2p128); }

ok (mpf(-1.5) == -1.5);
ok (mpf(-1.0) == -1.0);
ok (mpf(-0.5) == -0.5);
ok (mpf(0) == 0);
ok (mpf(0.5) == 0.5);
ok (mpf(1.0) == 1.0);
ok (mpf(1.5) == 1.5);

ok (mpf("-1.5") == -1.5);
ok (mpf("-1.0") == -1.0);
ok (mpf("-0.5") == -0.5);
ok (mpf("0") == 0);
ok (mpf("0.5") == 0.5);
ok (mpf("1.0") == 1.0);
ok (mpf("1.5") == 1.5);

ok (mpf($uv_max) > 0);
ok (mpf($uv_max) == mpf($uv_max_str));
{ tie my $t, 'Mytie', $uv_max; ok (mpf($t) > 0); }
{ tie my $t, 'Mytie', $uv_max; ok (mpf($t) == mpf($uv_max_str)); }

{ my $x = 123.5;
  kill (0, $x);
  ok (mpf($x) == 123.5);
  tie my $t, 'Mytie', $x;
  ok (mpf($t) == 123.5);
}

#------------------------------------------------------------------------------
# GMP::Mpf::overload_abs

ok (abs(mpf(0)) == 0);
ok (abs(mpf(123)) == 123);
ok (abs(mpf(-123)) == 123);

{ my $x = mpf(-123); $x = abs($x); ok ($x == 123); }
{ my $x = mpf(0);    $x = abs($x); ok ($x == 0);   }
{ my $x = mpf(123);  $x = abs($x); ok ($x == 123); }

{ tie my $t, 'Mytie', mpf(0); ok (abs($t) == 0); }
{ tie my $t, 'Mytie', mpf(123); ok (abs($t) == 123); }
{ tie my $t, 'Mytie', mpf(-123); ok (abs($t) == 123); }

#------------------------------------------------------------------------------
# GMP::Mpf::overload_add

ok (mpf(0) + 1 == 1);
ok (mpf(-1) + 1 == 0);
ok (1 + mpf(0) == 1);
ok (1 + mpf(-1) == 0);

#------------------------------------------------------------------------------
# GMP::Mpf::overload_addeq

{ my $a = mpf(7); $a += 1; ok ($a == 8); }
{ my $a = mpf(7); my $b = $a; $a += 1; ok ($a == 8); ok ($b == 7); }

#------------------------------------------------------------------------------
# GMP::Mpf::overload_bool

if (mpf(0))   { ok (0); } else { ok (1); }
if (mpf(123)) { ok (1); } else { ok (0); }

#------------------------------------------------------------------------------
# GMP::Mpf::overload_dec

{ my $a = mpf(0); ok ($a-- == 0); ok ($a == -1); }
{ my $a = mpf(0); ok (--$a == -1); }

{ my $a = mpf(0); my $b = $a; $a--; ok ($a == -1); ok ($b == 0); }

#------------------------------------------------------------------------------
# GMP::Mpf::overload_div

ok (mpf(6) / 2 == 3);
ok (mpf(-6) / 2 == -3);
ok (mpf(6) / -2 == -3);
ok (mpf(-6) / -2 == 3);

#------------------------------------------------------------------------------
# GMP::Mpf::overload_diveq

{ my $a = mpf(21); $a /= 3; ok ($a == 7); }
{ my $a = mpf(21); my $b = $a; $a /= 3; ok ($a == 7); ok ($b == 21); }

#------------------------------------------------------------------------------
# GMP::Mpf::overload_eq

{ my $a = mpf(0);
  my $b = $a;
  $a = mpf(1);
  ok ($a == 1);
  ok ($b == 0); }

#------------------------------------------------------------------------------
# GMP::Mpf::overload_inc

{ my $a = mpf(0); ok ($a++ == 0); ok ($a == 1); }
{ my $a = mpf(0); ok (++$a == 1); }

{ my $a = mpf(0); my $b = $a; $a++; ok ($a == 1); ok ($b == 0); }

#------------------------------------------------------------------------------
# GMP::Mpf::overload_lshift

{ my $a = mpf(7) << 1; ok ($a == 14); }

#------------------------------------------------------------------------------
# GMP::Mpf::overload_lshifteq

{ my $a = mpf(7); $a <<= 1; ok ($a == 14); }
{ my $a = mpf(7); my $b = $a; $a <<= 1; ok ($a == 14); ok ($b == 7); }

#------------------------------------------------------------------------------
# GMP::Mpf::overload_mul

ok (mpf(2) * 3 == 6);

#------------------------------------------------------------------------------
# GMP::Mpf::overload_muleq

{ my $a = mpf(7); $a *= 3;  ok ($a == 21); }
{ my $a = mpf(7); my $b = $a; $a *= 3;  ok ($a == 21); ok ($b == 7); }

#------------------------------------------------------------------------------
# GMP::Mpf::overload_neg

ok (- mpf(0) == 0);
ok (- mpf(123) == -123);
ok (- mpf(-123) == 123);

#------------------------------------------------------------------------------
# GMP::Mpf::overload_not

if (not mpf(0))   { ok (1); } else { ok (0); }
if (not mpf(123)) { ok (0); } else { ok (1); }

ok ((! mpf(0)) == 1);
ok ((! mpf(123)) == 0);

#------------------------------------------------------------------------------
# GMP::Mpf::overload_pow

ok (mpf(0) ** 1 == 0);
ok (mpf(1) ** 1 == 1);
ok (mpf(2) ** 0 == 1);
ok (mpf(2) ** 1 == 2);
ok (mpf(2) ** 2 == 4);
ok (mpf(2) ** 3 == 8);
ok (mpf(2) ** 4 == 16);

ok (mpf(0) ** mpf(1) == 0);
ok (mpf(1) ** mpf(1) == 1);
ok (mpf(2) ** mpf(0) == 1);
ok (mpf(2) ** mpf(1) == 2);
ok (mpf(2) ** mpf(2) == 4);
ok (mpf(2) ** mpf(3) == 8);
ok (mpf(2) ** mpf(4) == 16);

#------------------------------------------------------------------------------
# GMP::Mpf::overload_poweq

{ my $a = mpf(3); $a **= 4; ok ($a == 81); }
{ my $a = mpf(3); my $b = $a; $a **= 4; ok ($a == 81); ok ($b == 3); }

#------------------------------------------------------------------------------
# GMP::Mpf::overload_rshift

{ my $a = mpf(32) >> 1; ok ($a == 16); }

#------------------------------------------------------------------------------
# GMP::Mpf::overload_rshifteq

{ my $a = mpf(32); $a >>= 1; ok ($a == 16); }
{ my $a = mpf(32); my $b = $a; $a >>= 1; ok ($a == 16); ok ($b == 32); }

#------------------------------------------------------------------------------
# GMP::Mpf::overload_sqrt

ok (sqrt(mpf(0)) == 0);
ok (sqrt(mpf(1)) == 1);
ok (sqrt(mpf(4)) == 2);
ok (sqrt(mpf(81)) == 9);

ok (sqrt(mpf(0.25)) == 0.5);

#------------------------------------------------------------------------------
# GMP::Mpf::overload_spaceship

ok (mpf(0) < 1);
ok (mpf(0) > -1);

ok (mpf(0) != 1);
ok (mpf(0) != -1);
ok (mpf(1) != 0);
ok (mpf(1) != -1);
ok (mpf(-1) != 0);
ok (mpf(-1) != 1);

ok (mpf(0) < 1.0);
ok (mpf(0) < '1');
ok (mpf(0) < substr('-1',1,1));
ok (mpf(0) < mpz(1));
ok (mpf(0) < mpq(1));
ok (mpf(0) < mpf(1));
ok (mpf(0) < $uv_max);

#------------------------------------------------------------------------------
# GMP::Mpf::overload_string

{ my $x = mpf(0);    ok ("$x" eq "0"); }
{ my $x = mpf(123);  ok ("$x" eq "123"); }
{ my $x = mpf(-123); ok ("$x" eq "-123"); }

{ my $f = mpf(0.25);     ok ("$f" eq "0.25"); }
{ my $f = mpf(-0.25);    ok ("$f" eq "-0.25"); }
{ my $f = mpf(1.25);     ok ("$f" eq "1.25"); }
{ my $f = mpf(-1.25);    ok ("$f" eq "-1.25"); }
{ my $f = mpf(1000000);  ok ("$f" eq "1000000"); }
{ my $f = mpf(-1000000); ok ("$f" eq "-1000000"); }

#------------------------------------------------------------------------------
# GMP::Mpf::overload_sub

ok (mpf(0) - 1 == -1);
ok (mpf(1) - 1 == 0);
ok (1 - mpf(0) == 1);
ok (1 - mpf(1) == 0);

#------------------------------------------------------------------------------
# GMP::Mpf::overload_subeq

{ my $a = mpf(7); $a -= 1; ok ($a == 6); }
{ my $a = mpf(7); my $b = $a; $a -= 1; ok ($a == 6); ok ($b == 7); }


#------------------------------------------------------------------------------
# GMP::Mpf::ceil

ok (ceil (mpf(-7.5)) == -7.0);
ok (ceil (mpf(7.5)) == 8.0);

#------------------------------------------------------------------------------
# GMP::Mpf::floor

ok (floor(mpf(-7.5)) == -8.0);
ok (floor(mpf(7.5)) == 7.0);

#------------------------------------------------------------------------------
# GMP::Mpf::mpf_eq

{ my $old_prec = get_default_prec();
  set_default_prec(128);

  ok (  mpf_eq (mpz("0x10000000000000001"), mpz("0x10000000000000002"), 1));
  ok (! mpf_eq (mpz("0x11"), mpz("0x12"), 128));

  set_default_prec($old_prec);
}

#------------------------------------------------------------------------------
# GMP::Mpf::get_default_prec

get_default_prec();

#------------------------------------------------------------------------------
# GMP::Mpf::get_prec

{ my $x = mpf(1.0, 512);
  ok (get_prec ($x) == 512);
}

#------------------------------------------------------------------------------
# GMP::Mpf::reldiff

ok (reldiff (2,4) == 1);
ok (reldiff (4,2) == 0.5);

#------------------------------------------------------------------------------
# GMP::Mpf::set_default_prec

{ my $old_prec = get_default_prec();

  set_default_prec(512);
  ok (get_default_prec () == 512);

  set_default_prec($old_prec);
}

#------------------------------------------------------------------------------
# GMP::Mpf::set_prec

{ my $x = mpf(1.0, 512);
  my $y = $x;
  set_prec ($x, 1024);
  ok (get_prec ($x) == 1024);
  ok (get_prec ($y) == 512);
}

#------------------------------------------------------------------------------
# GMP::Mpf::trunc

ok (trunc(mpf(-7.5)) == -7.0);
ok (trunc(mpf(7.5)) == 7.0);



#------------------------------------------------------------------------------
# GMP::Rand

#------------------------------------------------------------------------------
# GMP::Rand::new

{ my $r = randstate();                          ok (defined $r); }
{ my $r = randstate('lc_2exp', 1, 2, 3);        ok (defined $r); }
{ my $r = randstate('lc_2exp_size', 64);        ok (defined $r); }
{ my $r = randstate('lc_2exp_size', 999999999); ok (! defined $r); }
{ my $r = randstate('mt');                      ok (defined $r); }

{ # copying a randstate results in same sequence
  my $r1 = randstate('lc_2exp_size', 64);
  $r1->seed(123);
  my $r2 = randstate($r1);
  for (1 .. 20) {
    my $z1 = mpz_urandomb($r1, 20);
    my $z2 = mpz_urandomb($r2, 20);
    ok ($z1 == $z2);
  }
}

#------------------------------------------------------------------------------
# GMP::Rand::seed

{ my $r = randstate();
  $r->seed(123);
  $r->seed(time());
}

#------------------------------------------------------------------------------
# GMP::Rand::mpf_urandomb

{ my $r = randstate();
  my $f = mpf_urandomb($r,1024);
  ok (UNIVERSAL::isa($f,"GMP::Mpf")); }

#------------------------------------------------------------------------------
# GMP::Rand::mpz_urandomb

{ my $r = randstate();
  my $z = mpz_urandomb($r, 1024);
  ok (UNIVERSAL::isa($z,"GMP::Mpz")); }

#------------------------------------------------------------------------------
# GMP::Rand::mpz_rrandomb

{ my $r = randstate();
  my $z = mpz_rrandomb($r, 1024);
  ok (UNIVERSAL::isa($z,"GMP::Mpz")); }

#------------------------------------------------------------------------------
# GMP::Rand::mpz_urandomm

{ my $r = randstate();
  my $z = mpz_urandomm($r, mpz(3)**100);
  ok (UNIVERSAL::isa($z,"GMP::Mpz")); }

#------------------------------------------------------------------------------
# GMP::Rand::mpz_urandomb_ui

{ my $r = randstate();
  foreach (1 .. 20) {
    my $u = gmp_urandomb_ui($r,8);
    ok ($u >= 0);
    ok ($u < 256);
  }
}

#------------------------------------------------------------------------------
# GMP::Rand::mpz_urandomm_ui

{ my $r = randstate();
  foreach (1 .. 20) {
    my $u = gmp_urandomm_ui($r,8);
    ok ($u >= 0);
    ok ($u < 8);
  }
}




#------------------------------------------------------------------------------
# GMP module

#------------------------------------------------------------------------------
# GMP::fits_slong_p

ok (GMP::fits_slong_p(0));

# in perl 5.005 uv_max is only 32-bits on a 64-bit system, so won't exceed a
# long
# ok (! GMP::fits_slong_p($uv_max));

ok (GMP::fits_slong_p(0.0));

ok (GMP::fits_slong_p('0'));

ok (GMP::fits_slong_p(substr('999999999999999999999999999999',1,1)));

ok (! mpz("-9999999999999999999999999999999999999999999")->fits_slong_p());
ok (  mpz(-123)->fits_slong_p());
ok (  mpz(0)->fits_slong_p());
ok (  mpz(123)->fits_slong_p());
ok (! mpz("9999999999999999999999999999999999999999999")->fits_slong_p());

ok (! mpq("-9999999999999999999999999999999999999999999")->fits_slong_p());
ok (  mpq(-123)->fits_slong_p());
ok (  mpq(0)->fits_slong_p());
ok (  mpq(123)->fits_slong_p());
ok (! mpq("9999999999999999999999999999999999999999999")->fits_slong_p());

ok (! mpf("-9999999999999999999999999999999999999999999")->fits_slong_p());
ok (  mpf(-123)->fits_slong_p());
ok (  mpf(0)->fits_slong_p());
ok (  mpf(123)->fits_slong_p());
ok (! mpf("9999999999999999999999999999999999999999999")->fits_slong_p());

#------------------------------------------------------------------------------
# GMP::get_d

ok (GMP::get_d(123) == 123.0);

ok (GMP::get_d($uv_max) > 0);

ok (GMP::get_d(123.0) == 123.0);

ok (GMP::get_d('123') == 123.0);

ok (GMP::get_d(mpz(123)) == 123.0);

ok (GMP::get_d(mpq(123)) == 123.0);

ok (GMP::get_d(mpf(123)) == 123.0);

#------------------------------------------------------------------------------
# GMP::get_d_2exp

{ my ($dbl, $exp) = get_d_2exp (0);
  ok ($dbl == 0); ok ($exp == 0); }
{ my ($dbl, $exp) = get_d_2exp (1);
  ok ($dbl == 0.5); ok ($exp == 1); }

{ my ($dbl, $exp) = get_d_2exp ($uv_max);
  ok ($dbl > 0.0); ok ($exp > 0); }

{ my ($dbl, $exp) = get_d_2exp (0.5);
  ok ($dbl == 0.5); ok ($exp == 0); }
{ my ($dbl, $exp) = get_d_2exp (0.25);
  ok ($dbl == 0.5); ok ($exp == -1); }

{ my ($dbl, $exp) = get_d_2exp ("1.0");
  ok ($dbl == 0.5); ok ($exp == 1); }

{ my ($dbl, $exp) = get_d_2exp (mpz ("256"));
  ok ($dbl == 0.5); ok ($exp == 9); }

{ my ($dbl, $exp) = get_d_2exp (mpq ("1/16"));
  ok ($dbl == 0.5); ok ($exp == -3); }

{ my ($dbl, $exp) = get_d_2exp (mpf ("1.5"));
  ok ($dbl == 0.75); ok ($exp == 1); }
{ my ($dbl, $exp) = get_d_2exp (mpf ("3.0"));
  ok ($dbl == 0.75); ok ($exp == 2); }

#------------------------------------------------------------------------------
# GMP::get_str

ok (get_str(-123) eq '-123');
ok (get_str('-123') eq '-123');
ok (get_str(substr('x-123x',1,4)) eq '-123');
ok (get_str(mpz(-123)) eq '-123');
ok (get_str(mpq(-123)) eq '-123');

ok (get_str(-123,10) eq '-123');
ok (get_str('-123',10) eq '-123');
ok (get_str(substr('x-123x',1,4),10) eq '-123');
ok (get_str(mpz(-123),10) eq '-123');
ok (get_str(mpq(-123),10) eq '-123');

ok (get_str(-123,16) eq '-7b');
ok (get_str('-123',16) eq '-7b');
ok (get_str(substr('x-123x',1,4),16) eq '-7b');
ok (get_str(mpz(-123),16) eq '-7b');
ok (get_str(mpq(-123),16) eq '-7b');

ok (get_str(-123,-16) eq '-7B');
ok (get_str('-123',-16) eq '-7B');
ok (get_str(substr('x-123x',1,4),-16) eq '-7B');
ok (get_str(mpz(-123),-16) eq '-7B');
ok (get_str(mpq(-123),-16) eq '-7B');

# is a float in past versions of perl without UV type
{ my ($str, $exp) = get_str($uv_max);
  ok ($str eq $uv_max_str); }

ok (get_str(mpq(5/8)) eq "5/8");
ok (get_str(mpq(-5/8)) eq "-5/8");
ok (get_str(mpq(255/256),16) eq "ff/100");
ok (get_str(mpq(255/256),-16) eq "FF/100");
ok (get_str(mpq(-255/256),16) eq "-ff/100");
ok (get_str(mpq(-255/256),-16) eq "-FF/100");

{ my ($s,$e) = get_str(1.5, 10);      ok ($s eq '15'); ok ($e == 1); }
{ my ($s,$e) = get_str(mpf(1.5), 10); ok ($s eq '15'); ok ($e == 1); }

{ my ($s,$e) = get_str(-1.5, 10);      ok ($s eq '-15'); ok ($e == 1); }
{ my ($s,$e) = get_str(mpf(-1.5), 10); ok ($s eq '-15'); ok ($e == 1); }

{ my ($s,$e) = get_str(1.5, 16);      ok ($s eq '18'); ok ($e == 1); }
{ my ($s,$e) = get_str(mpf(1.5), 16); ok ($s eq '18'); ok ($e == 1); }

{ my ($s,$e) = get_str(-1.5, 16);      ok ($s eq '-18'); ok ($e == 1); }
{ my ($s,$e) = get_str(mpf(-1.5), 16); ok ($s eq '-18'); ok ($e == 1); }

{ my ($s,$e) = get_str(65536.0, 16);      ok ($s eq '1'); ok ($e == 5); }
{ my ($s,$e) = get_str(mpf(65536.0), 16); ok ($s eq '1'); ok ($e == 5); }

{ my ($s,$e) = get_str(1.625, 16);      ok ($s eq '1a'); ok ($e == 1); }
{ my ($s,$e) = get_str(mpf(1.625), 16); ok ($s eq '1a'); ok ($e == 1); }

{ my ($s,$e) = get_str(1.625, -16);      ok ($s eq '1A'); ok ($e == 1); }
{ my ($s,$e) = get_str(mpf(1.625), -16); ok ($s eq '1A'); ok ($e == 1); }

{ my ($s, $e) = get_str(255.0,16,0);      ok ($s eq "ff"); ok ($e == 2); }
{ my ($s, $e) = get_str(mpf(255.0),16,0); ok ($s eq "ff"); ok ($e == 2); }

{ my ($s, $e) = get_str(255.0,-16,0);      ok ($s eq "FF"); ok ($e == 2); }
{ my ($s, $e) = get_str(mpf(255.0),-16,0); ok ($s eq "FF"); ok ($e == 2); }

#------------------------------------------------------------------------------
# GMP::get_si

ok (GMP::get_si(123) == 123.0);

# better not assume anything about the relatives sizes of long and UV
ok (GMP::get_si($uv_max) != 0);

ok (GMP::get_si(123.0) == 123.0);

ok (GMP::get_si('123') == 123.0);

ok (GMP::get_si(mpz(123)) == 123.0);

ok (GMP::get_si(mpq(123)) == 123.0);

ok (GMP::get_si(mpf(123)) == 123.0);

#------------------------------------------------------------------------------
# GMP::integer_p

ok (  GMP::integer_p (0));
ok (  GMP::integer_p (123));
ok (  GMP::integer_p (-123));

ok (  GMP::integer_p ($uv_max));

ok (  GMP::integer_p (0.0));
ok (  GMP::integer_p (123.0));
ok (  GMP::integer_p (-123.0));
ok (! GMP::integer_p (0.5));
ok (! GMP::integer_p (123.5));
ok (! GMP::integer_p (-123.5));

ok (  GMP::integer_p ('0'));
ok (  GMP::integer_p ('123'));
ok (  GMP::integer_p ('-123'));
ok (! GMP::integer_p ('0.5'));
ok (! GMP::integer_p ('123.5'));
ok (! GMP::integer_p ('-123.5'));
ok (! GMP::integer_p ('5/8'));

ok (  GMP::integer_p (mpz(1)));

ok (  GMP::integer_p (mpq(1)));
ok (! GMP::integer_p (mpq(1,2)));

ok (  GMP::integer_p (mpf(1.0)));
ok (! GMP::integer_p (mpf(1.5)));

#------------------------------------------------------------------------------
# GMP::odd_p

ok (! odd_p(0));
ok (  odd_p(1));
ok (! odd_p(2));

ok (  odd_p($uv_max));

ok (  odd_p(mpz(-3)));
ok (! odd_p(mpz(-2)));
ok (  odd_p(mpz(-1)));
ok (! odd_p(mpz(0)));
ok (  odd_p(mpz(1)));
ok (! odd_p(mpz(2)));
ok (  odd_p(mpz(3)));

#------------------------------------------------------------------------------
# GMP::printf

GMP::printf ("hello world\n");

sub via_printf {
  my $s;
  open TEMP, ">test.tmp" or die;
  GMP::printf TEMP @_;
  close TEMP or die;
  open TEMP, "<test.tmp" or die;
  read (TEMP, $s, 1024);
  close TEMP or die;
  unlink 'test.tmp';
  return $s;
}

ok (sprintf ("%d", mpz(123)) eq '123');
ok (sprintf ("%d %d %d", 456, mpz(123), 789) eq '456 123 789');
ok (sprintf ("%d", mpq(15,16)) eq '15/16');
ok (sprintf ("%f", mpf(1.5)) eq '1.500000');
ok (sprintf ("%.2f", mpf(1.5)) eq '1.50');

ok (sprintf ("%*d", 6, 123) eq '   123');
ok (sprintf ("%*d", 6, mpz(123))  eq '   123');
ok (sprintf ("%*d", 6, mpq(15,16))  eq ' 15/16');

ok (sprintf ("%x", 123) eq '7b');
ok (sprintf ("%x", mpz(123))  eq '7b');
ok (sprintf ("%X", 123) eq '7B');
ok (sprintf ("%X", mpz(123))  eq '7B');
ok (sprintf ("%#x", 123) eq '0x7b');
ok (sprintf ("%#x", mpz(123))  eq '0x7b');
ok (sprintf ("%#X", 123) eq '0X7B');
ok (sprintf ("%#X", mpz(123))  eq '0X7B');

ok (sprintf ("%x", mpq(15,16))  eq 'f/10');
ok (sprintf ("%X", mpq(15,16))  eq 'F/10');
ok (sprintf ("%#x", mpq(15,16))  eq '0xf/0x10');
ok (sprintf ("%#X", mpq(15,16))  eq '0XF/0X10');

ok (sprintf ("%*.*f", 10, 3, 1.25) eq '     1.250');
ok (sprintf ("%*.*f", 10, 3, mpf(1.5))   eq '     1.500');

ok (via_printf ("%d", mpz(123)) eq '123');
ok (via_printf ("%d %d %d", 456, mpz(123), 789) eq '456 123 789');
ok (via_printf ("%d", mpq(15,16)) eq '15/16');
ok (via_printf ("%f", mpf(1.5)) eq '1.500000');
ok (via_printf ("%.2f", mpf(1.5)) eq '1.50');

ok (via_printf ("%*d", 6, 123) eq '   123');
ok (via_printf ("%*d", 6, mpz(123))  eq '   123');
ok (via_printf ("%*d", 6, mpq(15,16))  eq ' 15/16');

ok (via_printf ("%x", 123) eq '7b');
ok (via_printf ("%x", mpz(123))  eq '7b');
ok (via_printf ("%X", 123) eq '7B');
ok (via_printf ("%X", mpz(123))  eq '7B');
ok (via_printf ("%#x", 123) eq '0x7b');
ok (via_printf ("%#x", mpz(123))  eq '0x7b');
ok (via_printf ("%#X", 123) eq '0X7B');
ok (via_printf ("%#X", mpz(123))  eq '0X7B');

ok (via_printf ("%x", mpq(15,16))  eq 'f/10');
ok (via_printf ("%X", mpq(15,16))  eq 'F/10');
ok (via_printf ("%#x", mpq(15,16))  eq '0xf/0x10');
ok (via_printf ("%#X", mpq(15,16))  eq '0XF/0X10');

ok (via_printf ("%*.*f", 10, 3, 1.25) eq '     1.250');
ok (via_printf ("%*.*f", 10, 3, mpf(1.5))   eq '     1.500');

#------------------------------------------------------------------------------
# GMP::sgn

ok (sgn(-123) == -1);
ok (sgn(0)    == 0);
ok (sgn(123)  == 1);

ok (sgn($uv_max) == 1);

ok (sgn(-123.0) == -1);
ok (sgn(0.0)    == 0);
ok (sgn(123.0)  == 1);

ok (sgn('-123') == -1);
ok (sgn('0')    == 0);
ok (sgn('123')  == 1);
ok (sgn('-123.0') == -1);
ok (sgn('0.0')    == 0);
ok (sgn('123.0')  == 1);

ok (sgn(substr('x-123x',1,4)) == -1);
ok (sgn(substr('x0x',1,1))    == 0);
ok (sgn(substr('x123x',1,3))  == 1);

ok (mpz(-123)->sgn() == -1);
ok (mpz(0)   ->sgn() == 0);
ok (mpz(123) ->sgn() == 1);

ok (mpq(-123)->sgn() == -1);
ok (mpq(0)   ->sgn() == 0);
ok (mpq(123) ->sgn() == 1);

ok (mpf(-123)->sgn() == -1);
ok (mpf(0)   ->sgn() == 0);
ok (mpf(123) ->sgn() == 1);



#------------------------------------------------------------------------------
# overloaded constants

if ($] > 5.00503) {
  if (! do 'test2.pl') {
    die "Cannot run test2.pl\n";
  }
}




#------------------------------------------------------------------------------
# $# stuff
#
# For some reason "local $#" doesn't leave $# back at its default undefined
# state when exiting the block.

{ local $# = 'hi %.0f there';
  my $f = mpf(123);
  ok ("$f" eq 'hi 123 there'); }



# Local variables:
# perl-indent-level: 2
# End: