# -*- mode: perl; -*-

# Note that this does not test Math::BigFloat upgrading.

use strict;
use warnings;

use Test::More tests => 93;

use Math::BigInt   upgrade   => 'Math::BigFloat';
use Math::BigFloat downgrade => 'Math::BigInt';

is(Math::BigFloat->downgrade(), 'Math::BigInt', 'Math::BigFloat->downgrade()');
is(Math::BigInt->upgrade(), 'Math::BigFloat', 'Math::BigInt->upgrade()');

# bug until v1.67:

subtest 'Math::BigFloat->new("0.2E0")' => sub {
    plan tests => 2;
    my $x = Math::BigFloat->new("0.2E0");
    is($x, "0.2", 'value of $x');
    is(ref($x), "Math::BigFloat", '$x is a Math::BigFloat');
};

subtest 'Math::BigFloat->new("0.2E1")' => sub {
    plan tests => 2;
    my $x = Math::BigFloat->new("2");
    is($x, "2", 'value of $x');
    is(ref($x), "Math::BigInt", '$x is downgraded to a Math::BigInt');
};

subtest 'Math::BigFloat->new("0.2E2")' => sub {
    plan tests => 2;
    my $x = Math::BigFloat->new("20");
    is($x, "20", 'value of $x');
    is(ref($x), "Math::BigInt", '$x is downgraded to a Math::BigInt');
};

# $x is a downgraded to a Math::BigInt, but bpow() and bsqrt() upgrades to
# Math::BigFloat.

Math::BigFloat -> div_scale(20);        # make it a bit faster

my ($x, $y, $z);
subtest '$x = Math::BigFloat -> new(2);' => sub {
    plan tests => 2;
    $x = Math::BigFloat -> new(2);     # downgrades
    is(ref($x), 'Math::BigInt', '$x is downgraded to a Math::BigInt');
    cmp_ok($x, "==", 2, 'value of $x');
};

subtest '$y = Math::BigFloat -> bpow("2", "0.5");' => sub {
    plan tests => 2;
    $y = Math::BigFloat -> bpow("2", "0.5");
    is(ref($y), 'Math::BigFloat', '$y is a Math::BigFloat');
    cmp_ok($y, "==", "1.4142135623730950488", 'value of $y');
};

subtest '$z = $x -> bsqrt();' => sub {
    plan tests => 2;
    $z = $x -> bsqrt();
    is(ref($z), 'Math::BigFloat', '$y is a Math::BigFloat');
    cmp_ok($z, "==", "1.4142135623730950488", 'value of $z');
};

# log_2(16) = 4

subtest '$x = Math::BigFloat -> new(16); $y = $x -> blog(2);' => sub {
    plan tests => 4;
    $x = Math::BigFloat -> new(16);
    is(ref($x), 'Math::BigInt', '$x is downgraded to a Math::BigInt');
    cmp_ok($x, "==", 16, 'value of $x');
    $y = $x -> blog(2);
    is(ref($y), 'Math::BigInt', '$y is downgraded to a Math::BigInt');
    cmp_ok($y, "==", 4, 'value of $y');
};

# log_16(2) = 1/4

subtest '$x = Math::BigFloat -> new(2); $y = $x -> blog(16);' => sub {
    plan tests => 4;
    $x = Math::BigFloat -> new(2);
    is(ref($x), 'Math::BigInt', '$x is downgraded to a Math::BigInt');
    cmp_ok($x, "==", 2, 'value of $x');
    $y = $x -> blog(16);
    is(ref($y), 'Math::BigFloat', '$y is a Math::BigFloat');
    cmp_ok($y, "==", 0.25, 'value of $y');
};

################################################################################
# Verify that constructors downgrade when they should.

note("Enable downgrading, and see if constructors downgrade");

note("testing new()");

$x = Math::BigFloat -> new("0.5");
subtest '$x = Math::BigFloat -> new("0.5")' => sub {
    plan tests => 2;
    cmp_ok($x, "==", 0.5, 'value of $x');
    is(ref $x, "Math::BigFloat", "does not downgrade from Math::BigFloat");
};

$x = Math::BigFloat -> new("4");
subtest '$x = Math::BigFloat -> new("4")' => sub {
    plan tests => 2;
    cmp_ok($x, "==", 4, 'value of $x');
    is(ref $x, "Math::BigInt", "downgrades to Math::BigInt");
};

$x = Math::BigFloat -> new("0");
subtest '$x = Math::BigFloat -> new("0")' => sub {
    plan tests => 2;
    cmp_ok($x, "==", 0, 'value of $x');
    is(ref $x, "Math::BigInt", "downgrades to Math::BigInt");
};

$x = Math::BigFloat -> new("1");
subtest '$x = Math::BigFloat -> new("1")' => sub {
    plan tests => 2;
    cmp_ok($x, "==", 1, 'value of $x');
    is(ref $x, "Math::BigInt", "downgrades to Math::BigInt");
};

$x = Math::BigFloat -> new("Inf");
subtest '$x = Math::BigFloat -> new("inf")' => sub {
    plan tests => 2;
    cmp_ok($x, "==", "Inf", 'value of $x');
    is(ref $x, "Math::BigInt", "downgrades to Math::BigInt");
};

$x = Math::BigFloat -> new("NaN");
subtest '$x = Math::BigFloat -> new("NaN")' => sub {
    plan tests => 2;
    is($x, "NaN", );
    is(ref $x, "Math::BigInt", "downgrades to Math::BigInt");
};

note("testing bzero()");

$x = Math::BigFloat -> bzero();
subtest '$x = Math::BigFloat -> bzero()' => sub {
    plan tests => 2;
    cmp_ok($x, '==', 0, 'value of $x');
    is(ref $x, 'Math::BigInt', 'downgrades to Math::BigInt');
};

note("testing bone()");

$x = Math::BigFloat -> bone();
subtest '$x = Math::BigFloat -> bone()' => sub {
    plan tests => 2;
    cmp_ok($x, '==', 1, 'value of $x');
    is(ref $x, 'Math::BigInt', 'downgrades to Math::BigInt');
};

note("testing binf()");

$x = Math::BigFloat -> binf();
subtest '$x = Math::BigFloat -> binf()' => sub {
    plan tests => 2;
    cmp_ok($x, '==', 'Inf', 'value of $x');
    is(ref $x, 'Math::BigInt', 'downgrades to Math::BigInt');
};

note("testing bnan()");

$x = Math::BigFloat -> bnan();
subtest '$x = Math::BigFloat -> bnan()' => sub {
    plan tests => 2;
    is($x, 'NaN', 'value of $x');
    is(ref $x, 'Math::BigInt', 'downgrades to Math::BigInt');
};

note("testing from_dec()");

$x = Math::BigFloat -> from_dec('3.14e2');
subtest '$x = Math::BigFloat -> from_dec("3.14e2")' => sub {
    plan tests => 2;
    cmp_ok($x, '==', 314, 'value of $x');
    is(ref $x, 'Math::BigInt', 'downgrades to Math::BigInt');
};

note("testing from_hex()");

$x = Math::BigFloat -> from_hex('0x1.3ap+8');
subtest '$x = Math::BigFloat -> from_hex("3.14e2")' => sub {
    plan tests => 2;
    cmp_ok($x, '==', 314, 'value of $x');
    is(ref $x, 'Math::BigInt', 'downgrades to Math::BigInt');
};

note("testing from_oct()");

$x = Math::BigFloat -> from_oct('0o1.164p+8');
subtest '$x = Math::BigFloat -> from_oct("0o1.164p+8")' => sub {
    plan tests => 2;
    cmp_ok($x, '==', 314, 'value of $x');
    is(ref $x, 'Math::BigInt', 'downgrades to Math::BigInt');
};

note("testing from_bin()");

$x = Math::BigFloat -> from_bin('0b1.0011101p+8');
subtest '$x = Math::BigFloat -> from_bin("0b1.0011101p+8")' => sub {
    plan tests => 2;
    cmp_ok($x, '==', 314, 'value of $x');
    is(ref $x, 'Math::BigInt', 'downgrades to Math::BigInt');
};

note("testing from_ieee754()");

$x = Math::BigFloat -> from_ieee754("\x43\x9d\x00\x00", "binary32");
subtest '$x = Math::BigFloat -> from_ieee754("\x43\x9d\x00\x00", "binary32")' => sub {
    plan tests => 2;
    cmp_ok($x, "==", 314, 'value of $x');
    is(ref $x, "Math::BigInt", 'downgrades to Math::BigInt');
};

note("Disable downgrading, and see if constructors downgrade");

Math::BigFloat -> downgrade(undef);

my $zero = Math::BigFloat -> bzero();
my $half = Math::BigFloat -> new("0.5");
my $one  = Math::BigFloat -> bone();
my $four = Math::BigFloat -> new("4");
my $inf  = Math::BigFloat -> binf();
my $nan  = Math::BigFloat -> bnan();

is(ref $zero, "Math::BigFloat", "Creating a 0 does not downgrade");
is(ref $half, "Math::BigFloat", "Creating a 0.5 does not downgrade");
is(ref $one,  "Math::BigFloat", "Creating a 1 does not downgrade");
is(ref $four, "Math::BigFloat", "Creating a 4 does not downgrade");
is(ref $inf,  "Math::BigFloat", "Creating an Inf does not downgrade");
is(ref $nan,  "Math::BigFloat", "Creating a NaN does not downgrade");

################################################################################
# Verify that other methods downgrade when they should.

Math::BigFloat -> downgrade("Math::BigInt");

note("testing bneg()");

$x = $zero -> copy() -> bneg();
subtest '$x = $zero -> copy() -> bneg();' => sub {
    plan tests => 2;
    cmp_ok($x, '==', 0, '-(0) = 0');
    is(ref($x), 'Math::BigInt', '-(0) => Math::BigInt');
};

$x = $four -> copy() -> bneg();
subtest '$x = $four -> copy() -> bneg();' => sub {
    plan tests => 2;
    cmp_ok($x, '==', -4, '-(4) = -4');
    is(ref($x), 'Math::BigInt', '-(4) => Math::BigInt');
};

$x = $inf -> copy() -> bneg();
subtest '$x = $inf -> copy() -> bneg();' => sub {
    plan tests => 2;
    cmp_ok($x, '==', '-inf', '-(Inf) = -Inf');
    is(ref($x), 'Math::BigInt', '-(Inf) => Math::BigInt');
};

$x = $nan -> copy() -> bneg();
subtest '$x = $nan -> copy() -> bneg();' => sub {
    plan tests => 2;
    is($x, 'NaN', '-(NaN) = NaN');
    is(ref($x), 'Math::BigInt', '-(NaN) => Math::BigInt');
};

note("testing bnorm()");

$x = $zero -> copy() -> bnorm();
subtest '$x = $zero -> copy() -> bnorm();' => sub {
    plan tests => 2;
    cmp_ok($x, '==', 0, 'value of $x');
    is(ref($x), 'Math::BigInt', 'bnorm(0) => Math::BigInt');
};

$x = $four -> copy() -> bnorm();
subtest '$x = $four -> copy() -> bnorm();' => sub {
    plan tests => 2;
    cmp_ok($x, '==', 4, 'value of $x');
    is(ref($x), 'Math::BigInt', 'bnorm(4) => Math::BigInt');
};

$x = $inf -> copy() -> bnorm();
subtest '$x = $inf -> copy() -> bnorm();' => sub {
    plan tests => 2;
    cmp_ok($x, '==', 'inf', 'value of $x');
    is(ref($x), 'Math::BigInt', 'bnorm(Inf) => Math::BigInt');
};

$x = $nan -> copy() -> bnorm();
subtest '$x = $nan -> copy() -> bnorm();' => sub {
    plan tests => 2;
    is($x, 'NaN', 'bnorm(NaN)');
    is(ref($x), 'Math::BigInt', 'bnorm(NaN) => Math::BigInt');
};

note("testing binc()");

$x = $zero -> copy() -> binc();
subtest '$x = $zero -> copy() -> binc();' => sub {
    plan tests => 2;
    cmp_ok($x, '==', 1, 'binc(0)');
    is(ref($x), 'Math::BigInt', 'binc(0) => Math::BigInt');
};

$x = $four -> copy() -> binc();
subtest '$x = $four -> copy() -> binc();' => sub {
    plan tests => 2;
    cmp_ok($x, '==', 5, 'binc(4)');
    is(ref($x), 'Math::BigInt', 'binc(4) => Math::BigInt');
};

$x = $inf -> copy() -> binc();
subtest '$x = $inf -> copy() -> binc();' => sub {
    plan tests => 2;
    cmp_ok($x, '==', 'inf', 'binc(Inf)');
    is(ref($x), 'Math::BigInt', 'binc(Inf) => Math::BigInt');
};

$x = $nan -> copy() -> binc();
subtest '$x = $nan -> copy() -> binc();' => sub {
    plan tests => 2;
    is($x, 'NaN', 'binc(NaN)');
    is(ref($x), 'Math::BigInt', 'binc(NaN) => Math::BigInt');
};

note("testing bdec()");

$x = $zero -> copy() -> bdec();
subtest '$x = $zero -> copy() -> bdec();' => sub {
    plan tests => 2;
    cmp_ok($x, '==', -1, 'bdec(0)');
    is(ref($x), 'Math::BigInt', 'bdec(0) => Math::BigInt');
};

$x = $four -> copy() -> bdec();
subtest '$x = $four -> copy() -> bdec();' => sub {
    plan tests => 2;
    cmp_ok($x, '==', 3, 'bdec(4)');
    is(ref($x), 'Math::BigInt', 'bdec(4) => Math::BigInt');
};

$x = $inf -> copy() -> bdec();
subtest '$x = $inf -> copy() -> bdec();' => sub {
    plan tests => 2;
    cmp_ok($x, '==', 'inf', 'bdec(Inf)');
    is(ref($x), 'Math::BigInt', 'bdec(Inf) => Math::BigInt');
};

$x = $nan -> copy() -> bdec();
subtest '$x = $nan -> copy() -> bdec();' => sub {
    plan tests => 2;
    is($x, 'NaN', 'bdec(NaN)');
    is(ref($x), 'Math::BigInt', 'bdec(NaN) => Math::BigInt');
};

note("testing badd()");

$x = $half -> copy() -> badd($nan);
subtest '$x = $half -> copy() -> badd($nan);' => sub {
    plan tests => 2;
    is($x, 'NaN', '0.5 + NaN = NaN');
    is(ref($x), 'Math::BigInt', '0.5 + NaN => Math::BigInt');
};

$x = $half -> copy() -> badd($inf);
subtest '$x = $half -> copy() -> badd($inf);' => sub {
    plan tests => 2;
    cmp_ok($x, '==', '+Inf', '0.5 + Inf = Inf');
    is(ref($x), 'Math::BigInt', '2.5 + Inf => Math::BigInt');
};

$x = $half -> copy() -> badd($half);
subtest '$x = $half -> copy() -> badd($half);' => sub {
    plan tests => 2;
    cmp_ok($x, '==', 1, '0.5 + 0.5 = 1');
    is(ref($x), 'Math::BigInt', '0.5 + 0.5 => Math::BigInt');
};

$x = $half -> copy() -> badd($half -> copy() -> bneg());
subtest '$x = $half -> copy() -> badd($half -> copy() -> bneg());' => sub {
    plan tests => 2;
    cmp_ok($x, '==', 0, '0.5 + -0.5 = 0');
    is(ref($x), 'Math::BigInt', '0.5 + -0.5 => Math::BigInt');
};

$x = $four -> copy() -> badd($zero);
subtest '$x = $four -> copy() -> badd($zero);' => sub {
    plan tests => 2;
    cmp_ok($x, '==', 4, '4 + 0 = 4');
    is(ref($x), 'Math::BigInt', '4 + 0 => Math::BigInt');
};

$x = $zero -> copy() -> badd($four);
subtest '$x = $zero -> copy() -> badd($four);' => sub {
    plan tests => 2;
    cmp_ok($x, '==', 4, '0 + 4 = 4');
    is(ref($x), 'Math::BigInt', '0 + 4 => Math::BigInt');
};

$x = $inf -> copy() -> badd($four);
subtest '$x = $inf -> copy() -> badd($four);' => sub {
    plan tests => 2;
    cmp_ok($x, '==', '+Inf', 'Inf + 4 = Inf');
    is(ref($x), 'Math::BigInt', 'Inf + 4 => Math::BigInt');
};

$x = $nan -> copy() -> badd($four);
subtest '$x = $nan -> copy() -> badd($four);' => sub {
    plan tests => 2;
    is($x, 'NaN', 'NaN + 4 = NaN');
    is(ref($x), 'Math::BigInt', 'NaN + 4 => Math::BigInt');
};

note("testing bsub()");

$x = $half -> copy() -> bsub($nan);
subtest '$x = $half -> copy() -> bsub($nan);' => sub {
    plan tests => 2;
    is($x, 'NaN', '0.5 - NaN = NaN');
    is(ref($x), 'Math::BigInt', '0.5 - NaN => Math::BigInt');
};

$x = $half -> copy() -> bsub($inf);
subtest '$x = $half -> copy() -> bsub($inf);' => sub {
    plan tests => 2;
    cmp_ok($x, '==', '-Inf', '2.5 - Inf = -Inf');
    is(ref($x), 'Math::BigInt', '2.5 - Inf => Math::BigInt');
};

$x = $half -> copy() -> bsub($half);
subtest '$x = $half -> copy() -> bsub($half);' => sub {
    plan tests => 2;
    cmp_ok($x, '==', 0, '0.5 + 0.5 = 0');
    is(ref($x), 'Math::BigInt', '0.5 - 0.5 => Math::BigInt');
};

$x = $half -> copy() -> bsub($half -> copy() -> bneg());
subtest '$x = $half -> copy() -> bsub($half -> copy() -> bneg());' => sub {
    plan tests => 2;
    cmp_ok($x, '==', 1, '0.5 - -0.5 = 1');
    is(ref($x), 'Math::BigInt', '0.5 - -0.5 => Math::BigInt');
};

$x = $four -> copy() -> bsub($zero);
subtest '$x = $four -> copy() -> bsub($zero);' => sub {
    plan tests => 2;
    cmp_ok($x, '==', 4, '4 - 0 = 4');
    is(ref($x), 'Math::BigInt', '4 - 0 => Math::BigInt');
};

$x = $zero -> copy() -> bsub($four);
subtest '$x = $zero -> copy() -> bsub($four);' => sub {
    plan tests => 2;
    cmp_ok($x, '==', -4, '0 - 4 = -4');
    is(ref($x), 'Math::BigInt', '0 - 4 => Math::BigInt');
};

$x = $inf -> copy() -> bsub($four);
subtest '$x = $inf -> copy() -> bsub($four);' => sub {
    plan tests => 2;
    cmp_ok($x, '==', 'Inf', 'Inf - 4 = Inf');
    is(ref($x), 'Math::BigInt', 'Inf - 4 => Math::BigInt');
};

$x = $nan -> copy() -> bsub($four);
subtest '$x = $nan -> copy() -> bsub($four);' => sub {
    plan tests => 2;
    is($x, 'NaN', 'NaN - 4 = NaN');
    is(ref($x), 'Math::BigInt', 'NaN - 4 => Math::BigInt');
};

note("testing bmul()");

$x = $zero -> copy() -> bmul($four);
subtest '$x = $zero -> copy() -> bmul($four);' => sub {
    plan tests => 2;
    cmp_ok($x, '==', 0, 'bmul(0, 4) = 0');
    is(ref($x), 'Math::BigInt', 'bmul(0, 4) => Math::BigInt');
};

$x = $four -> copy() -> bmul($four);
subtest '$x = $four -> copy() -> bmul($four);' => sub {
    plan tests => 2;
    cmp_ok($x, '==', 16, 'bmul(4, 4) = 16');
    is(ref($x), 'Math::BigInt', 'bmul(4, 4) => Math::BigInt');
};

$x = $inf -> copy() -> bmul($four);
subtest '$x = $inf -> copy() -> bmul($four);' => sub {
    plan tests => 2;
    cmp_ok($x, '==', 'inf', 'bmul(Inf, 4) = Inf');
    is(ref($x), 'Math::BigInt', 'bmul(Inf, 4) => Math::BigInt');
};

$x = $nan -> copy() -> bmul($four);
subtest '$x = $nan -> copy() -> bmul($four);' => sub {
    plan tests => 2;
    is($x, 'NaN', 'bmul(NaN, 4) = NaN');
    is(ref($x), 'Math::BigInt', 'bmul(NaN, 4) => Math::BigInt');
};

$x = $four -> copy() -> bmul("0.5");
subtest '$four -> copy() -> bmul("0.5");' => sub {
    plan tests => 2;
    cmp_ok($x, '==', 2, 'bmul(4, 0.5) = 2');
    is(ref($x), 'Math::BigInt', 'bmul(4, 0.5) => Math::BigInt');
};

note("testing bmuladd()");

$x = $zero -> copy() -> bmuladd($four, $four);
subtest '$x = $zero -> copy() -> bmuladd($four, $four);' => sub {
    plan tests => 2;
    cmp_ok($x, '==', 4, 'bmuladd(0, 4, 4) = 4');
    is(ref($x), 'Math::BigInt', 'bmuladd(0, 4, 4) => Math::BigInt');
};

$x = $four -> copy() -> bmuladd($four, $four);
subtest '$x = $four -> copy() -> bmuladd($four, $four);' => sub {
    plan tests => 2;
    cmp_ok($x, '==', 20, 'bmuladd(4, 4, 4) = 20');
    is(ref($x), 'Math::BigInt', 'bmuladd(4, 4, 4) => Math::BigInt');
};

$x = $four -> copy() -> bmuladd($four, $inf);
subtest '$x = $four -> copy() -> bmuladd($four, $inf);' => sub {
    plan tests => 2;
    cmp_ok($x, '==', 'inf', 'bmuladd(4, 4, Inf) = Inf');
    is(ref($x), 'Math::BigInt', 'bmuladd(4, 4, Inf) => Math::BigInt');
};

$x = $inf -> copy() -> bmuladd($four, $four);
subtest '$x = $inf -> copy() -> bmuladd($four, $four);' => sub {
    plan tests => 2;
    cmp_ok($x, '==', 'inf', 'bmuladd(Inf, 4, 4) = Inf');
    is(ref($x), 'Math::BigInt', 'bmuladd(Inf, 4, 4) => Math::BigInt');
};

$x = $inf -> copy() -> bmuladd($four, $four);
subtest '$x = $inf -> copy() -> bmuladd($four, $four);' => sub {
    plan tests => 2;
    cmp_ok($x, '==', 'inf', 'bmuladd(Inf, 4, 4) = Inf');
    is(ref($x), 'Math::BigInt', 'bmuladd(Inf, 4, 4) => Math::BigInt');
};

$x = $nan -> copy() -> bmuladd($four, $four);
subtest '$x = $nan -> copy() -> bmuladd($four, $four);' => sub {
    plan tests => 2;
    is($x, 'NaN', 'bmuladd(NaN, 4, 4) = NaN');
    is(ref($x), 'Math::BigInt', 'bmuladd(NaN, 4, 4) => Math::BigInt');
};

$x = $four -> copy() -> bmuladd("0.5", $four);
subtest '$x = $four -> copy() -> bmuladd("0.5", $four);' => sub {
    plan tests => 2;
    cmp_ok($x, '==', 6, 'bmuladd(4, 0.5, 4) = 6');
    is(ref($x), 'Math::BigInt', 'bmuladd(4, 0.5, 4) => Math::BigInt');
};

note("testing bdiv()");

$x = $zero -> copy() -> bdiv($one);
subtest '$x = $zero -> copy() -> bdiv($one);' => sub {
    plan tests => 2;
    cmp_ok($x, '==', 0, 'bdiv(0, 1) = 0');
    is(ref($x), 'Math::BigInt', 'bdiv(0, 1) => Math::BigInt');
};

note("testing bmod()");

note("testing bmodpow()");

note("testing bpow()");

note("testing blog()");

note("testing bexp()");

note("testing bnok()");

note("testing bsin()");

note("testing bcos()");

note("testing batan()");

note("testing batan()");

note("testing bsqrt()");

note("testing broot()");

note("testing bfac()");

note("testing bdfac()");

note("testing btfac()");

note("testing bmfac()");

note("testing blsft()");

note("testing brsft()");

note("testing band()");

note("testing bior()");

note("testing bxor()");

note("testing bnot()");

note("testing bround()");

note("testing Add tests for rounding a non-integer to an integer. Fixme!");

$x = $zero -> copy() -> bround();
subtest '$x = $zero -> copy() -> bround();' => sub {
    plan tests => 2;
    cmp_ok($x, '==', 0, 'bround(0)');
    is(ref($x), 'Math::BigInt', 'bround(0) => Math::BigInt');
};

$x = $four -> copy() -> bround();
subtest '$x = $four -> copy() -> bround();' => sub {
    plan tests => 2;
    cmp_ok($x, '==', 4, 'bround(4)');
    is(ref($x), 'Math::BigInt', 'bround(4) => Math::BigInt');
};

$x = $inf -> copy() -> bround();
subtest '$x = $inf -> copy() -> bround();' => sub {
    plan tests => 2;
    cmp_ok($x, '==', 'inf', 'bround(Inf)');
    is(ref($x), 'Math::BigInt', 'bround(Inf) => Math::BigInt');
};

$x = $nan -> copy() -> bround();
subtest '$x = $nan -> copy() -> bround();' => sub {
    plan tests => 2;
    is($x, 'NaN', 'bround(NaN)');
    is(ref($x), 'Math::BigInt', 'bround(NaN) => Math::BigInt');
};

note("testing bfround()");

note("testing Add tests for rounding a non-integer to an integer. Fixme!");

$x = $zero -> copy() -> bfround();
subtest '$x = $zero -> copy() -> bfround();' => sub {
    plan tests => 2;
    cmp_ok($x, '==', 0, 'bfround(0)');
    is(ref($x), 'Math::BigInt', 'bfround(0) => Math::BigInt');
};

$x = $four -> copy() -> bfround();
subtest '$x = $four -> copy() -> bfround();' => sub {
    plan tests => 2;
    cmp_ok($x, '==', 4, 'bfround(4)');
    is(ref($x), 'Math::BigInt', 'bfround(4) => Math::BigInt');
};

$x = $inf -> copy() -> bfround();
subtest '$x = $inf -> copy() -> bfround();' => sub {
    plan tests => 2;
    cmp_ok($x, '==', 'inf', 'bfround(Inf)');
    is(ref($x), 'Math::BigInt', 'bfround(Inf) => Math::BigInt');
};

$x = $nan -> copy() -> bfround();
subtest '$x = $nan -> copy() -> bfround();' => sub {
    plan tests => 2;
    is($x, 'NaN', 'bfround(NaN)');
    is(ref($x), 'Math::BigInt', 'bfround(NaN) => Math::BigInt');
};

note("testing bfloor()");

$x = $half -> copy() -> bfloor();
subtest '$x = $half -> copy() -> bfloor();' => sub {
    plan tests => 2;
    cmp_ok($x, '==', 0, 'bfloor(0)');
    is(ref($x), 'Math::BigInt', 'bfloor(0) => Math::BigInt');
};

$x = $inf -> copy() -> bfloor();
subtest '$x = $inf -> copy() -> bfloor();' => sub {
    plan tests => 2;
    cmp_ok($x, '==', 'Inf', 'bfloor(Inf)');
    is(ref($x), 'Math::BigInt', 'bfloor(Inf) => Math::BigInt');
};

$x = $nan -> copy() -> bfloor();
subtest '$x = $nan -> copy() -> bfloor();' => sub {
    plan tests => 2;
    is($x, 'NaN', 'bfloor(NaN)');
    is(ref($x), 'Math::BigInt', 'bfloor(NaN) => Math::BigInt');
};

note("testing bceil()");

$x = $half -> copy() -> bceil();
subtest '$x = $half -> copy() -> bceil();' => sub {
    plan tests => 2;
    cmp_ok($x, '==', 1, 'bceil(0)');
    is(ref($x), 'Math::BigInt', 'bceil(0) => Math::BigInt');
};

$x = $inf -> copy() -> bceil();
subtest '$x = $inf -> copy() -> bceil();' => sub {
    plan tests => 2;
    cmp_ok($x, '==', 'Inf', 'bceil(Inf)');
    is(ref($x), 'Math::BigInt', 'bceil(Inf) => Math::BigInt');
};

$x = $nan -> copy() -> bceil();
subtest '$x = $nan -> copy() -> bceil();' => sub {
    plan tests => 2;
    is($x, 'NaN', 'bceil(NaN)');
    is(ref($x), 'Math::BigInt', 'bceil(NaN) => Math::BigInt');
};

note("testing bint()");

$x = $half -> copy() -> bint();
subtest '$x = $half -> copy() -> bint();' => sub {
    plan tests => 2;
    cmp_ok($x, '==', 0, 'bint(0)');
    is(ref($x), 'Math::BigInt', 'bint(0) => Math::BigInt');
};

$x = $inf -> copy() -> bint();
subtest '$x = $inf -> copy() -> bint();' => sub {
    plan tests => 2;
    cmp_ok($x, '==', 'Inf', 'bint(Inf)');
    is(ref($x), 'Math::BigInt', 'bint(Inf) => Math::BigInt');
};

$x = $nan -> copy() -> bint();
subtest '$x = $nan -> copy() -> bint();' => sub {
    plan tests => 2;
    is($x, 'NaN', 'bint(NaN)');
    is(ref($x), 'Math::BigInt', 'bint(NaN) => Math::BigInt');
};

note("testing bgcd()");

note("testing blcm()");

note("testing mantissa()");

note("testing exponent()");

note("testing parts()");

note("testing sparts()");

note("testing nparts()");

note("testing eparts()");

note("testing dparts()");

note("testing fparts()");

note("testing numerator()");

note("testing denominator()");
