Upgrade from Math::BigInt version 1.999715 to 1.999724

41 files changed, 14627 insertions, 9515 deletions

diff --git a/cpan/Math-BigInt/lib/Math/BigFloat.pm b/cpan/Math-BigInt/lib/Math/BigFloat.pm
index 4c2c9b80f0..45c32c9576 100644
--- a/cpan/Math-BigInt/lib/Math/BigFloat.pm
+++ b/cpan/Math-BigInt/lib/Math/BigFloat.pm
@@ -1,27 +1,30 @@
 package Math::BigFloat;
 
-# 
+#
 # Mike grinned. 'Two down, infinity to go' - Mike Nostrus in 'Before and After'
 #
 
-# The following hash values are internally used:
-#   _e	: exponent (ref to $CALC object)
-#   _m	: mantissa (ref to $CALC object)
-#   _es	: sign of _e
-# sign	: +,-,+inf,-inf, or "NaN" if not a number
-#   _a	: accuracy
-#   _p	: precision
+# The following hash values are used internally:
+# sign  : "+", "-", "+inf", "-inf", or "NaN" if not a number
+#   _m  : mantissa ($CALC object)
+#   _es : sign of _e
+#   _e  : exponent ($CALC object)
+#   _a  : accuracy
+#   _p  : precision
 
 use 5.006001;
 use strict;
 use warnings;
 
-our $VERSION = '1.999715';
+use Carp ();
+use Math::BigInt ();
+
+our $VERSION = '1.999724';
 $VERSION = eval $VERSION;
 
 require Exporter;
-our @ISA	= qw/Math::BigInt/;
-our @EXPORT_OK	= qw/bpi/;
+our @ISA        = qw/Math::BigInt/;
+our @EXPORT_OK  = qw/bpi/;
 
 # $_trap_inf/$_trap_nan are internal and should never be accessed from outside
 our ($AUTOLOAD, $accuracy, $precision, $div_scale, $round_mode, $rnd_mode,
@@ -30,20 +33,174 @@ our ($AUTOLOAD, $accuracy, $precision, $div_scale, $round_mode, $rnd_mode,
 my $class = "Math::BigFloat";
 
 use overload
-  '<=>'	=>	sub { my $rc = $_[2] ? ref($_[0])->bcmp($_[1], $_[0])
-                                     : ref($_[0])->bcmp($_[0], $_[1]);
-		      $rc = 1 unless defined $rc;
-		      $rc <=> 0;
-		},
-# we need '>=' to get things like "1 >= NaN" right:
-  '>='	=>	sub { my $rc = $_[2] ? ref($_[0])->bcmp($_[1],$_[0])
-                                     : ref($_[0])->bcmp($_[0],$_[1]);
-		      # if there was a NaN involved, return false
-		      return '' unless defined $rc;
-		      $rc >= 0;
-		},
-  'int'	=>	sub { $_[0]->as_number() },		# 'trunc' to bigint
-;
+
+  # overload key: with_assign
+
+  '+'     =>      sub { $_[0] -> copy() -> badd($_[1]); },
+
+  '-'     =>      sub { my $c = $_[0] -> copy();
+                        $_[2] ? $c -> bneg() -> badd($_[1])
+                              : $c -> bsub($_[1]); },
+
+  '*'     =>      sub { $_[0] -> copy() -> bmul($_[1]); },
+
+  '/'     =>      sub { $_[2] ? ref($_[0]) -> new($_[1]) -> bdiv($_[0])
+                              : $_[0] -> copy() -> bdiv($_[1]); },
+
+  '%'     =>      sub { $_[2] ? ref($_[0]) -> new($_[1]) -> bmod($_[0])
+                              : $_[0] -> copy() -> bmod($_[1]); },
+
+  '**'    =>      sub { $_[2] ? ref($_[0]) -> new($_[1]) -> bpow($_[0])
+                              : $_[0] -> copy() -> bpow($_[1]); },
+
+  '<<'    =>      sub { $_[2] ? ref($_[0]) -> new($_[1]) -> blsft($_[0])
+                              : $_[0] -> copy() -> blsft($_[1]); },
+
+  '>>'    =>      sub { $_[2] ? ref($_[0]) -> new($_[1]) -> brsft($_[0])
+                              : $_[0] -> copy() -> brsft($_[1]); },
+
+  # overload key: assign
+
+  '+='    =>      sub { $_[0]->badd($_[1]); },
+
+  '-='    =>      sub { $_[0]->bsub($_[1]); },
+
+  '*='    =>      sub { $_[0]->bmul($_[1]); },
+
+  '/='    =>      sub { scalar $_[0]->bdiv($_[1]); },
+
+  '%='    =>      sub { $_[0]->bmod($_[1]); },
+
+  '**='   =>      sub { $_[0]->bpow($_[1]); },
+
+
+  '<<='   =>      sub { $_[0]->blsft($_[1]); },
+
+  '>>='   =>      sub { $_[0]->brsft($_[1]); },
+
+#  'x='    =>      sub { },
+
+#  '.='    =>      sub { },
+
+  # overload key: num_comparison
+
+  '<'     =>      sub { $_[2] ? ref($_[0]) -> new($_[1]) -> blt($_[0])
+                              : $_[0] -> blt($_[1]); },
+
+  '<='    =>      sub { $_[2] ? ref($_[0]) -> new($_[1]) -> ble($_[0])
+                              : $_[0] -> ble($_[1]); },
+
+  '>'     =>      sub { $_[2] ? ref($_[0]) -> new($_[1]) -> bgt($_[0])
+                              : $_[0] -> bgt($_[1]); },
+
+  '>='    =>      sub { $_[2] ? ref($_[0]) -> new($_[1]) -> bge($_[0])
+                              : $_[0] -> bge($_[1]); },
+
+  '=='    =>      sub { $_[0] -> beq($_[1]); },
+
+  '!='    =>      sub { $_[0] -> bne($_[1]); },
+
+  # overload key: 3way_comparison
+
+  '<=>'   =>      sub { my $cmp = $_[0] -> bcmp($_[1]);
+                        defined($cmp) && $_[2] ? -$cmp : $cmp; },
+
+  'cmp'   =>      sub { $_[2] ? "$_[1]" cmp $_[0] -> bstr()
+                              : $_[0] -> bstr() cmp "$_[1]"; },
+
+  # overload key: str_comparison
+
+#  'lt'    =>      sub { $_[2] ? ref($_[0]) -> new($_[1]) -> bstrlt($_[0])
+#                              : $_[0] -> bstrlt($_[1]); },
+#
+#  'le'    =>      sub { $_[2] ? ref($_[0]) -> new($_[1]) -> bstrle($_[0])
+#                              : $_[0] -> bstrle($_[1]); },
+#
+#  'gt'    =>      sub { $_[2] ? ref($_[0]) -> new($_[1]) -> bstrgt($_[0])
+#                              : $_[0] -> bstrgt($_[1]); },
+#
+#  'ge'    =>      sub { $_[2] ? ref($_[0]) -> new($_[1]) -> bstrge($_[0])
+#                              : $_[0] -> bstrge($_[1]); },
+#
+#  'eq'    =>      sub { $_[0] -> bstreq($_[1]); },
+#
+#  'ne'    =>      sub { $_[0] -> bstrne($_[1]); },
+
+  # overload key: binary
+
+  '&'     =>      sub { $_[2] ? ref($_[0]) -> new($_[1]) -> band($_[0])
+                              : $_[0] -> copy() -> band($_[1]); },
+
+  '&='    =>      sub { $_[0] -> band($_[1]); },
+
+  '|'     =>      sub { $_[2] ? ref($_[0]) -> new($_[1]) -> bior($_[0])
+                              : $_[0] -> copy() -> bior($_[1]); },
+
+  '|='    =>      sub { $_[0] -> bior($_[1]); },
+
+  '^'     =>      sub { $_[2] ? ref($_[0]) -> new($_[1]) -> bxor($_[0])
+                              : $_[0] -> copy() -> bxor($_[1]); },
+
+  '^='    =>      sub { $_[0] -> bxor($_[1]); },
+
+#  '&.'    =>      sub { },
+
+#  '&.='   =>      sub { },
+
+#  '|.'    =>      sub { },
+
+#  '|.='   =>      sub { },
+
+#  '^.'    =>      sub { },
+
+#  '^.='   =>      sub { },
+
+  # overload key: unary
+
+  'neg'   =>      sub { $_[0] -> copy() -> bneg(); },
+
+#  '!'     =>      sub { },
+
+  '~'     =>      sub { $_[0] -> copy() -> bnot(); },
+
+#  '~.'    =>      sub { },
+
+  # overload key: mutators
+
+  '++'    =>      sub { $_[0] -> binc() },
+
+  '--'    =>      sub { $_[0] -> bdec() },
+
+  # overload key: func
+
+  'atan2' =>      sub { $_[2] ? ref($_[0]) -> new($_[1]) -> batan2($_[0])
+                              : $_[0] -> copy() -> batan2($_[1]); },
+
+  'cos'   =>      sub { $_[0] -> copy() -> bcos(); },
+
+  'sin'   =>      sub { $_[0] -> copy() -> bsin(); },
+
+  'exp'   =>      sub { $_[0] -> copy() -> bexp($_[1]); },
+
+  'abs'   =>      sub { $_[0] -> copy() -> babs(); },
+
+  'log'   =>      sub { $_[0] -> copy() -> blog(); },
+
+  'sqrt'  =>      sub { $_[0] -> copy() -> bsqrt(); },
+
+  'int'   =>      sub { $_[0] -> copy() -> bint(); },
+
+  # overload key: conversion
+
+  'bool'  =>      sub { $_[0] -> is_zero() ? '' : 1; },
+
+  '""'    =>      sub { $_[0] -> bstr(); },
+
+  '0+'    =>      sub { $_[0] -> numify(); },
+
+  '='     =>      sub { $_[0]->copy(); },
+
+  ;
 
 ##############################################################################
 # global constants, flags and assorted stuff
@@ -70,67 +227,135 @@ $_trap_nan = 0;
 $_trap_inf = 0;
 
 # constant for easier life
-my $nan = 'NaN'; 
+my $nan = 'NaN';
 
-my $IMPORT = 0;	# was import() called yet? used to make require work
+my $IMPORT = 0; # was import() called yet? used to make require work
 
-# some digits of accuracy for blog(undef,10); which we use in blog() for speed
-my $LOG_10 = 
+# some digits of accuracy for blog(undef, 10); which we use in blog() for speed
+my $LOG_10 =
  '2.3025850929940456840179914546843642076011014886287729760333279009675726097';
 my $LOG_10_A = length($LOG_10)-1;
 # ditto for log(2)
-my $LOG_2 = 
+my $LOG_2 =
  '0.6931471805599453094172321214581765680755001343602552541206800094933936220';
 my $LOG_2_A = length($LOG_2)-1;
-my $HALF = '0.5';			# made into an object if nec.
+my $HALF = '0.5';                       # made into an object if nec.
 
 ##############################################################################
 # the old code had $rnd_mode, so we need to support it, too
 
-sub TIESCALAR   { my ($class) = @_; bless \$round_mode, $class; }
-sub FETCH       { return $round_mode; }
-sub STORE       { $rnd_mode = $_[0]->round_mode($_[1]); }
+sub TIESCALAR {
+    my ($class) = @_;
+    bless \$round_mode, $class;
+}
+
+sub FETCH {
+    return $round_mode;
+}
+
+sub STORE {
+    $rnd_mode = $_[0]->round_mode($_[1]);
+}
+
+BEGIN {
+    # when someone sets $rnd_mode, we catch this and check the value to see
+    # whether it is valid or not.
+    $rnd_mode   = 'even';
+    tie $rnd_mode, 'Math::BigFloat';
+
+    # we need both of them in this package:
+    *as_int = \&as_number;
+}
+
+sub DESTROY {
+    # going through AUTOLOAD for every DESTROY is costly, avoid it by empty sub
+}
 
-BEGIN
-  {
-  # when someone sets $rnd_mode, we catch this and check the value to see
-  # whether it is valid or not. 
-  $rnd_mode   = 'even'; tie $rnd_mode, 'Math::BigFloat';
+sub AUTOLOAD {
+    # make fxxx and bxxx both work by selectively mapping fxxx() to MBF::bxxx()
+    # or falling back to MBI::bxxx()
+    my $name = $AUTOLOAD;
+
+    $name =~ s/(.*):://;        # split package
+    my $c = $1 || $class;
+    no strict 'refs';
+    $c->import() if $IMPORT == 0;
+    if (!_method_alias($name)) {
+        if (!defined $name) {
+            # delayed load of Carp and avoid recursion
+            Carp::croak("$c: Can't call a method without name");
+        }
+        if (!_method_hand_up($name)) {
+            # delayed load of Carp and avoid recursion
+            Carp::croak("Can't call $c\-\>$name, not a valid method");
+        }
+        # try one level up, but subst. bxxx() for fxxx() since MBI only got bxxx()
+        $name =~ s/^f/b/;
+        return &{"Math::BigInt"."::$name"}(@_);
+    }
+    my $bname = $name;
+    $bname =~ s/^f/b/;
+    $c .= "::$name";
+    *{$c} = \&{$bname};
+    &{$c};                      # uses @_
+}
 
-  # we need both of them in this package:
-  *as_int = \&as_number;
-  }
- 
 ##############################################################################
 
 {
-  # valid method aliases for AUTOLOAD
-  my %methods = map { $_ => 1 }  
-   qw / fadd fsub fmul fdiv fround ffround fsqrt fmod fstr fsstr fpow fnorm
-        fint facmp fcmp fzero fnan finf finc fdec ffac fneg
-	fceil ffloor frsft flsft fone flog froot fexp
-      /;
-  # valid methods that can be handed up (for AUTOLOAD)
-  my %hand_ups = map { $_ => 1 }  
-   qw / is_nan is_inf is_negative is_positive is_pos is_neg
-        accuracy precision div_scale round_mode fabs fnot
-        objectify upgrade downgrade
-	bone binf bnan bzero
-	bsub
-      /;
-
-  sub _method_alias { exists $methods{$_[0]||''}; } 
-  sub _method_hand_up { exists $hand_ups{$_[0]||''}; } 
+    # valid method aliases for AUTOLOAD
+    my %methods = map { $_ => 1 }
+      qw / fadd fsub fmul fdiv fround ffround fsqrt fmod fstr fsstr fpow fnorm
+           fint facmp fcmp fzero fnan finf finc fdec ffac fneg
+           fceil ffloor frsft flsft fone flog froot fexp
+         /;
+    # valid methods that can be handed up (for AUTOLOAD)
+    my %hand_ups = map { $_ => 1 }
+      qw / is_nan is_inf is_negative is_positive is_pos is_neg
+           accuracy precision div_scale round_mode fabs fnot
+           objectify upgrade downgrade
+           bone binf bnan bzero
+           bsub
+         /;
+
+    sub _method_alias { exists $methods{$_[0]||''}; }
+    sub _method_hand_up { exists $hand_ups{$_[0]||''}; }
 }
 
-##############################################################################
-# constructors
+sub DEBUG () { 0; }
+
+sub isa {
+    my ($self, $class) = @_;
+    return if $class =~ /^Math::BigInt/; # we aren't one of these
+    UNIVERSAL::isa($self, $class);
+}
+
+sub config {
+    # return (later set?) configuration data as hash ref
+    my $class = shift || 'Math::BigFloat';
+
+    if (@_ == 1 && ref($_[0]) ne 'HASH') {
+        my $cfg = $class->SUPER::config();
+        return $cfg->{$_[0]};
+    }
+
+    my $cfg = $class->SUPER::config(@_);
+
+    # now we need only to override the ones that are different from our parent
+    $cfg->{class} = $class;
+    $cfg->{with} = $MBI;
+    $cfg;
+}
+
+###############################################################################
+# Constructor methods
+###############################################################################
 
 sub new {
-    # Create a new BigFloat object from a string or another bigfloat object.
+    # Create a new Math::BigFloat object from a string or another bigfloat object.
     # _e: exponent
     # _m: mantissa
-    # sign  => sign ("+", "-", "+inf", "-inf", or "NaN"
+    # sign  => ("+", "-", "+inf", "-inf", or "NaN")
 
     my $self    = shift;
     my $selfref = ref $self;
@@ -141,8 +366,7 @@ sub new {
     # avoid numify-calls by not using || on $wanted!
 
     unless (defined $wanted) {
-        require Carp;
-        Carp::carp("Use of uninitialized value in new");
+        #Carp::carp("Use of uninitialized value in new");
         return $self->bzero(@r);
     }
 
@@ -185,1695 +409,1350 @@ sub new {
         return $self->binf($sgn);
     }
 
+    # Handle explicit NaNs (not the ones returned due to invalid input).
+
+    if ($wanted =~ /^\s*([+-]?)nan\s*\z/i) {
+        return $downgrade->new($wanted) if $downgrade;
+        $self = $class -> bnan();
+        $self->round(@r) unless @r >= 2 && !defined $r[0] && !defined $r[1];
+        return $self;
+    }
+
+    # Handle hexadecimal numbers.
+
+    if ($wanted =~ /^\s*[+-]?0[Xx]/) {
+        $self = $class -> from_hex($wanted);
+        $self->round(@r) unless @r >= 2 && !defined $r[0] && !defined $r[1];
+        return $self;
+    }
+
+    # Handle binary numbers.
+
+    if ($wanted =~ /^\s*[+-]?0[Bb]/) {
+        $self = $class -> from_bin($wanted);
+        $self->round(@r) unless @r >= 2 && !defined $r[0] && !defined $r[1];
+        return $self;
+    }
+
     # Shortcut for simple forms like '12' that have no trailing zeros.
     if ($wanted =~ /^([+-]?)0*([1-9][0-9]*[1-9])$/) {
-        $self->{_e} = $MBI->_zero();
-        $self->{_es} = '+';
+        $self->{_e}   = $MBI -> _zero();
+        $self->{_es}  = '+';
         $self->{sign} = $1 || '+';
-        $self->{_m} = $MBI->_new($2);
-        return $self->round(@r) if !$downgrade;
+        $self->{_m}   = $MBI -> _new($2);
+        if (!$downgrade) {
+            $self->round(@r) unless @r >= 2 && !defined $r[0] && !defined $r[1];
+            return $self;
+        }
     }
 
-  my ($mis,$miv,$mfv,$es,$ev) = Math::BigInt::_split($wanted);
-  if (!ref $mis)
-    {
-    if ($_trap_nan)
-      {
-      require Carp;
-      Carp::croak ("$wanted is not a number initialized to $class");
-      }
-    
-    return $downgrade->bnan() if $downgrade;
-    
-    $self->{_e} = $MBI->_zero();
-    $self->{_es} = '+';
-    $self->{_m} = $MBI->_zero();
-    $self->{sign} = $nan;
-    }
-  else
-    {
-    # make integer from mantissa by adjusting exp, then convert to int
-    $self->{_e} = $MBI->_new($$ev);		# exponent
-    $self->{_es} = $$es || '+';
-    my $mantissa = "$$miv$$mfv"; 		# create mant.
-    $mantissa =~ s/^0+(\d)/$1/;			# strip leading zeros
-    $self->{_m} = $MBI->_new($mantissa); 	# create mant.
-
-    # 3.123E0 = 3123E-3, and 3.123E-2 => 3123E-5
-    if (CORE::length($$mfv) != 0)
-      {
-      my $len = $MBI->_new( CORE::length($$mfv));
-      ($self->{_e}, $self->{_es}) =
-	_e_sub ($self->{_e}, $len, $self->{_es}, '+');
-      }
-    # we can only have trailing zeros on the mantissa if $$mfv eq ''
-    else
-      {
-      # Use a regexp to count the trailing zeros in $$miv instead of _zeros()
-      # because that is faster, especially when _m is not stored in base 10.
-      my $zeros = 0; $zeros = CORE::length($1) if $$miv =~ /[1-9](0*)$/; 
-      if ($zeros != 0)
-        {
-        my $z = $MBI->_new($zeros);
-        # turn '120e2' into '12e3'
-        $MBI->_rsft ( $self->{_m}, $z, 10);
-        ($self->{_e}, $self->{_es}) =
-	  _e_add ( $self->{_e}, $z, $self->{_es}, '+');
+    my ($mis, $miv, $mfv, $es, $ev) = Math::BigInt::_split($wanted);
+    if (!ref $mis) {
+        if ($_trap_nan) {
+            Carp::croak("$wanted is not a number initialized to $class");
+        }
+
+        return $downgrade->bnan() if $downgrade;
+
+        $self->{_e} = $MBI->_zero();
+        $self->{_es} = '+';
+        $self->{_m} = $MBI->_zero();
+        $self->{sign} = $nan;
+    } else {
+        # make integer from mantissa by adjusting exp, then convert to int
+        $self->{_e} = $MBI->_new($$ev); # exponent
+        $self->{_es} = $$es || '+';
+        my $mantissa = "$$miv$$mfv";     # create mant.
+        $mantissa =~ s/^0+(\d)/$1/;      # strip leading zeros
+        $self->{_m} = $MBI->_new($mantissa); # create mant.
+
+        # 3.123E0 = 3123E-3, and 3.123E-2 => 3123E-5
+        if (CORE::length($$mfv) != 0) {
+            my $len = $MBI->_new(CORE::length($$mfv));
+            ($self->{_e}, $self->{_es}) =
+              _e_sub($self->{_e}, $len, $self->{_es}, '+');
+        }
+        # we can only have trailing zeros on the mantissa if $$mfv eq ''
+        else {
+            # Use a regexp to count the trailing zeros in $$miv instead of
+            # _zeros() because that is faster, especially when _m is not stored
+            # in base 10.
+            my $zeros = 0;
+            $zeros = CORE::length($1) if $$miv =~ /[1-9](0*)$/;
+            if ($zeros != 0) {
+                my $z = $MBI->_new($zeros);
+                # turn '120e2' into '12e3'
+                $MBI->_rsft($self->{_m}, $z, 10);
+                ($self->{_e}, $self->{_es}) =
+                  _e_add($self->{_e}, $z, $self->{_es}, '+');
+            }
         }
-      }
-    $self->{sign} = $$mis;
+        $self->{sign} = $$mis;
 
-    # for something like 0Ey, set y to 0, and -0 => +0
-    # Check $$miv for being '0' and $$mfv eq '', because otherwise _m could not
-    # have become 0. That's faster than to call $MBI->_is_zero().
-    $self->{sign} = '+', $self->{_e} = $MBI->_zero()
-     if $$miv eq '0' and $$mfv eq '';
+        # for something like 0Ey, set y to 0, and -0 => +0
+        # Check $$miv for being '0' and $$mfv eq '', because otherwise _m could not
+        # have become 0. That's faster than to call $MBI->_is_zero().
+        $self->{sign} = '+', $self->{_e} = $MBI->_zero()
+          if $$miv eq '0' and $$mfv eq '';
 
-    return $self->round(@r) if !$downgrade;
+        if (!$downgrade) {
+            $self->round(@r) unless @r >= 2 && !defined $r[0] && !defined $r[1];
+            return $self;
+        }
     }
-  # if downgrade, inf, NaN or integers go down
 
-  if ($downgrade && $self->{_es} eq '+')
-    {
-    if ($MBI->_is_zero( $self->{_e} ))
-      {
-      return $downgrade->new($$mis . $MBI->_str( $self->{_m} ));
-      }
-    return $downgrade->new($self->bsstr()); 
+    # if downgrade, inf, NaN or integers go down
+
+    if ($downgrade && $self->{_es} eq '+') {
+        if ($MBI->_is_zero($self->{_e})) {
+            return $downgrade->new($$mis . $MBI->_str($self->{_m}));
+        }
+        return $downgrade->new($self->bsstr());
     }
-  $self->bnorm()->round(@r);			# first normalize, then round
-  }
+    $self->bnorm();
+    $self->round(@r) unless @r >= 2 && !defined $r[0] && !defined $r[1];
+    return $self;
+}
 
-sub copy {
+sub from_hex {
     my $self    = shift;
     my $selfref = ref $self;
     my $class   = $selfref || $self;
 
-    # If called as a class method, the object to copy is the next argument.
+    my $str = shift;
 
-    $self = shift() unless $selfref;
+    # If called as a class method, initialize a new object.
 
-    my $copy = bless {}, $class;
+    $self = $class -> bzero() unless $selfref;
 
-    $copy->{sign} = $self->{sign};
-    $copy->{_es}  = $self->{_es};
-    $copy->{_m}   = $MBI->_copy($self->{_m});
-    $copy->{_e}   = $MBI->_copy($self->{_e});
-    $copy->{_a}   = $self->{_a} if exists $self->{_a};
-    $copy->{_p}   = $self->{_p} if exists $self->{_p};
+    if ($str =~ s/
+                     ^
 
-    return $copy;
-}
+                     # sign
+                     ( [+-]? )
 
-sub _bnan
-  {
-  # used by parent class bone() to initialize number to NaN
-  my $self = shift;
-  
-  if ($_trap_nan)
-    {
-    require Carp;
-    my $class = ref($self);
-    Carp::croak ("Tried to set $self to NaN in $class\::_bnan()");
-    }
-
-  $IMPORT=1;					# call our import only once
-  $self->{_m} = $MBI->_zero();
-  $self->{_e} = $MBI->_zero();
-  $self->{_es} = '+';
-  }
-
-sub _binf
-  {
-  # used by parent class bone() to initialize number to +-inf
-  my $self = shift;
-  
-  if ($_trap_inf)
-    {
-    require Carp;
-    my $class = ref($self);
-    Carp::croak ("Tried to set $self to +-inf in $class\::_binf()");
-    }
-
-  $IMPORT=1;					# call our import only once
-  $self->{_m} = $MBI->_zero();
-  $self->{_e} = $MBI->_zero();
-  $self->{_es} = '+';
-  }
-
-sub _bone
-  {
-  # used by parent class bone() to initialize number to 1
-  my $self = shift;
-  $IMPORT=1;					# call our import only once
-  $self->{_m} = $MBI->_one();
-  $self->{_e} = $MBI->_zero();
-  $self->{_es} = '+';
-  }
-
-sub _bzero
-  {
-  # used by parent class bzero() to initialize number to 0
-  my $self = shift;
-  $IMPORT=1;					# call our import only once
-  $self->{_m} = $MBI->_zero();
-  $self->{_e} = $MBI->_zero();
-  $self->{_es} = '+';
-  }
-
-sub isa
-  {
-  my ($self,$class) = @_;
-  return if $class =~ /^Math::BigInt/;		# we aren't one of these
-  UNIVERSAL::isa($self,$class);
-  }
-
-sub config
-  {
-  # return (later set?) configuration data as hash ref
-  my $class = shift || 'Math::BigFloat';
-
-  if (@_ == 1 && ref($_[0]) ne 'HASH')
-    {
-    my $cfg = $class->SUPER::config();
-    return $cfg->{$_[0]};
-    }
+                     # optional "hex marker"
+                     (?: 0? x )?
 
-  my $cfg = $class->SUPER::config(@_);
+                     # significand using the hex digits 0..9 and a..f
+                     (
+                         [0-9a-fA-F]+ (?: _ [0-9a-fA-F]+ )*
+                         (?:
+                             \.
+                             (?: [0-9a-fA-F]+ (?: _ [0-9a-fA-F]+ )* )?
+                         )?
+                     |
+                         \.
+                         [0-9a-fA-F]+ (?: _ [0-9a-fA-F]+ )*
+                     )
 
-  # now we need only to override the ones that are different from our parent
-  $cfg->{class} = $class;
-  $cfg->{with} = $MBI;
-  $cfg;
-  }
+                     # exponent (power of 2) using decimal digits
+                     (?:
+                         [Pp]
+                         ( [+-]? )
+                         ( \d+ (?: _ \d+ )* )
+                     )?
 
-##############################################################################
-# string conversion
+                     $
+                 //x)
+    {
+        my $s_sign  = $1 || '+';
+        my $s_value = $2;
+        my $e_sign  = $3 || '+';
+        my $e_value = $4 || '0';
+        $s_value =~ tr/_//d;
+        $e_value =~ tr/_//d;
 
-sub bstr 
-  {
-  # (ref to BFLOAT or num_str ) return num_str
-  # Convert number from internal format to (non-scientific) string format.
-  # internal format is always normalized (no leading zeros, "-0" => "+0")
-  my ($self,$x) = ref($_[0]) ? (undef,$_[0]) : objectify(1,@_);
+        # The significand must be multiplied by 2 raised to this exponent.
 
-  if ($x->{sign} !~ /^[+-]$/)
-    {
-    return $x->{sign} unless $x->{sign} eq '+inf';      # -inf, NaN
-    return 'inf';                                       # +inf
-    }
+        my $two_expon = $class -> new($e_value);
+        $two_expon -> bneg() if $e_sign eq '-';
 
-  my $es = '0'; my $len = 1; my $cad = 0; my $dot = '.';
+        # If there is a dot in the significand, remove it and adjust the
+        # exponent according to the number of digits in the fraction part of
+        # the significand. Since the digits in the significand are in base 16,
+        # but the exponent is only in base 2, multiply the exponent adjustment
+        # value by log(16) / log(2) = 4.
 
-  # $x is zero?
-  my $not_zero = !($x->{sign} eq '+' && $MBI->_is_zero($x->{_m}));
-  if ($not_zero)
-    {
-    $es = $MBI->_str($x->{_m});
-    $len = CORE::length($es);
-    my $e = $MBI->_num($x->{_e});	
-    $e = -$e if $x->{_es} eq '-';
-    if ($e < 0)
-      {
-      $dot = '';
-      # if _e is bigger than a scalar, the following will blow your memory
-      if ($e <= -$len)
-        {
-        my $r = abs($e) - $len;
-        $es = '0.'. ('0' x $r) . $es; $cad = -($len+$r);
+        my $idx = index($s_value, '.');
+        if ($idx >= 0) {
+            substr($s_value, $idx, 1) = '';
+            $two_expon -= $class -> new(CORE::length($s_value))
+                                 -> bsub($idx)
+                                 -> bmul("4");
         }
-      else
-        {
-        substr($es,$e,0) = '.'; $cad = $MBI->_num($x->{_e});
-        $cad = -$cad if $x->{_es} eq '-';
+
+        $self -> {sign} = $s_sign;
+        $self -> {_m}   = $MBI -> _from_hex('0x' . $s_value);
+
+        if ($two_expon > 0) {
+            my $factor = $class -> new("2") -> bpow($two_expon);
+            $self -> bmul($factor);
+        } elsif ($two_expon < 0) {
+            my $factor = $class -> new("0.5") -> bpow(-$two_expon);
+            $self -> bmul($factor);
         }
-      }
-    elsif ($e > 0)
-      {
-      # expand with zeros
-      $es .= '0' x $e; $len += $e; $cad = 0;
-      }
-    } # if not zero
-
-  $es = '-'.$es if $x->{sign} eq '-';
-  # if set accuracy or precision, pad with zeros on the right side
-  if ((defined $x->{_a}) && ($not_zero))
-    {
-    # 123400 => 6, 0.1234 => 4, 0.001234 => 4
-    my $zeros = $x->{_a} - $cad;		# cad == 0 => 12340
-    $zeros = $x->{_a} - $len if $cad != $len;
-    $es .= $dot.'0' x $zeros if $zeros > 0;
-    }
-  elsif ((($x->{_p} || 0) < 0))
-    {
-    # 123400 => 6, 0.1234 => 4, 0.001234 => 6
-    my $zeros = -$x->{_p} + $cad;
-    $es .= $dot.'0' x $zeros if $zeros > 0;
+
+        return $self;
     }
-  $es;
-  }
 
-sub bsstr
-  {
-  # (ref to BFLOAT or num_str ) return num_str
-  # Convert number from internal format to scientific string format.
-  # internal format is always normalized (no leading zeros, "-0E0" => "+0E0")
-  my ($self,$x) = ref($_[0]) ? (undef,$_[0]) : objectify(1,@_);
+    return $self->bnan();
+}
 
-  if ($x->{sign} !~ /^[+-]$/)
-    {
-    return $x->{sign} unless $x->{sign} eq '+inf';      # -inf, NaN
-    return 'inf';                                       # +inf
-    }
-  my $sep = 'e'.$x->{_es};
-  my $sign = $x->{sign}; $sign = '' if $sign eq '+';
-  $sign . $MBI->_str($x->{_m}) . $sep . $MBI->_str($x->{_e});
-  }
-    
-sub numify 
-  {
-  # Make a Perl scalar number from a Math::BigFloat object.
-  my ($self,$x) = ref($_[0]) ? (undef,$_[0]) : objectify(1,@_);
-
-  if ($x -> is_nan()) {
-      require Math::Complex;
-      my $inf = Math::Complex::Inf();
-      return $inf - $inf;
-  }
-
-  if ($x -> is_inf()) {
-      require Math::Complex;
-      my $inf = Math::Complex::Inf();
-      return $x -> is_negative() ? -$inf : $inf;
-  }
-
-  # Create a string and let Perl's atoi()/atof() handle the rest.
-  return 0 + $x -> bsstr();
-  }
+sub from_oct {
+    my $self    = shift;
+    my $selfref = ref $self;
+    my $class   = $selfref || $self;
 
-##############################################################################
-# public stuff (usually prefixed with "b")
-
-sub bneg
-  {
-  # (BINT or num_str) return BINT
-  # negate number or make a negated number from string
-  my ($self,$x) = ref($_[0]) ? (undef,$_[0]) : objectify(1,@_);
-
-  return $x if $x->modify('bneg');
-
-  # for +0 do not negate (to have always normalized +0). Does nothing for 'NaN'
-  $x->{sign} =~ tr/+-/-+/ unless ($x->{sign} eq '+' && $MBI->_is_zero($x->{_m}));
-  $x;
-  }
-
-# tels 2001-08-04 
-# XXX TODO this must be overwritten and return NaN for non-integer values
-# band(), bior(), bxor(), too
-#sub bnot
-#  {
-#  $class->SUPER::bnot($class,@_);
-#  }
-
-sub bcmp 
-  {
-  # Compares 2 values.  Returns one of undef, <0, =0, >0. (suitable for sort)
-
-  # set up parameters
-  my ($self,$x,$y) = (ref($_[0]),@_);
-
-  # objectify is costly, so avoid it
-  if ((!ref($_[0])) || (ref($_[0]) ne ref($_[1])))
-    {
-    ($self,$x,$y) = objectify(2,@_);
-    }
+    my $str = shift;
 
-  return $upgrade->bcmp($x,$y) if defined $upgrade &&
-    ((!$x->isa($self)) || (!$y->isa($self)));
+    # If called as a class method, initialize a new object.
 
-  # Handle all 'nan' cases.
+    $self = $class -> bzero() unless $selfref;
 
-  return undef if ($x->{sign} eq $nan) || ($y->{sign} eq $nan);
+    if ($str =~ s/
+                     ^
 
-  # Handle all '+inf' and '-inf' cases.
+                     # sign
+                     ( [+-]? )
 
-  return  0 if ($x->{sign} eq '+inf' && $y->{sign} eq '+inf' ||
-                $x->{sign} eq '-inf' && $y->{sign} eq '-inf');
-  return +1 if $x->{sign} eq '+inf';    # x = +inf and y < +inf
-  return -1 if $x->{sign} eq '-inf';    # x = -inf and y > -inf
-  return -1 if $y->{sign} eq '+inf';    # x < +inf and y = +inf
-  return +1 if $y->{sign} eq '-inf';    # x > -inf and y = -inf
+                     # significand using the octal digits 0..7
+                     (
+                         [0-7]+ (?: _ [0-7]+ )*
+                         (?:
+                             \.
+                             (?: [0-7]+ (?: _ [0-7]+ )* )?
+                         )?
+                     |
+                         \.
+                         [0-7]+ (?: _ [0-7]+ )*
+                     )
 
-  # Handle all cases with opposite signs.
+                     # exponent (power of 2) using decimal digits
+                     (?:
+                         [Pp]
+                         ( [+-]? )
+                         ( \d+ (?: _ \d+ )* )
+                     )?
 
-  return +1 if $x->{sign} eq '+' && $y->{sign} eq '-';  # also does 0 <=> -y
-  return -1 if $x->{sign} eq '-' && $y->{sign} eq '+';  # also does -x <=> 0
+                     $
+                 //x)
+    {
+        my $s_sign  = $1 || '+';
+        my $s_value = $2;
+        my $e_sign  = $3 || '+';
+        my $e_value = $4 || '0';
+        $s_value =~ tr/_//d;
+        $e_value =~ tr/_//d;
 
-  # Handle all remaining zero cases.
+        # The significand must be multiplied by 2 raised to this exponent.
 
-  my $xz = $x->is_zero();
-  my $yz = $y->is_zero();
-  return  0 if $xz && $yz;                              # 0 <=> 0
-  return -1 if $xz && $y->{sign} eq '+';                # 0 <=> +y
-  return +1 if $yz && $x->{sign} eq '+';                # +x <=> 0
+        my $two_expon = $class -> new($e_value);
+        $two_expon -> bneg() if $e_sign eq '-';
 
-  # Both arguments are now finite, non-zero numbers with the same sign.
+        # If there is a dot in the significand, remove it and adjust the
+        # exponent according to the number of digits in the fraction part of
+        # the significand. Since the digits in the significand are in base 8,
+        # but the exponent is only in base 2, multiply the exponent adjustment
+        # value by log(8) / log(2) = 3.
 
-  my $cmp;
+        my $idx = index($s_value, '.');
+        if ($idx >= 0) {
+            substr($s_value, $idx, 1) = '';
+            $two_expon -= $class -> new(CORE::length($s_value))
+                                 -> bsub($idx)
+                                 -> bmul("3");
+        }
 
-  # The next step is to compare the exponents, but since each mantissa is an
-  # integer of arbitrary value, the exponents must be normalized by the length
-  # of the mantissas before we can compare them.
+        $self -> {sign} = $s_sign;
+        $self -> {_m}   = $MBI -> _from_oct($s_value);
 
-  my $mxl = $MBI->_len($x->{_m});
-  my $myl = $MBI->_len($y->{_m});
+        if ($two_expon > 0) {
+            my $factor = $class -> new("2") -> bpow($two_expon);
+            $self -> bmul($factor);
+        } elsif ($two_expon < 0) {
+            my $factor = $class -> new("0.5") -> bpow(-$two_expon);
+            $self -> bmul($factor);
+        }
 
-  # If the mantissas have the same length, there is no point in normalizing the
-  # exponents by the length of the mantissas, so treat that as a special case.
+        return $self;
+    }
 
-  if ($mxl == $myl) {
+    return $self->bnan();
+}
 
-      # First handle the two cases where the exponents have different signs.
+sub from_bin {
+    my $self    = shift;
+    my $selfref = ref $self;
+    my $class   = $selfref || $self;
 
-      if ($x->{_es} eq '+' && $y->{_es} eq '-') {
-          $cmp = +1;
-      }
+    my $str = shift;
 
-      elsif ($x->{_es} eq '-' && $y->{_es} eq '+') {
-          $cmp = -1;
-      }
+    # If called as a class method, initialize a new object.
 
-      # Then handle the case where the exponents have the same sign.
+    $self = $class -> bzero() unless $selfref;
 
-      else {
-          $cmp = $MBI->_acmp($x->{_e}, $y->{_e});
-          $cmp = -$cmp if $x->{_es} eq '-';
-      }
+    if ($str =~ s/
+                     ^
 
-      # Adjust for the sign, which is the same for x and y, and bail out if
-      # we're done.
+                     # sign
+                     ( [+-]? )
 
-      $cmp = -$cmp if $x->{sign} eq '-';        # 124 > 123, but -124 < -123
-      return $cmp if $cmp;
+                     # optional "bin marker"
+                     (?: 0? b )?
+
+                     # significand using the binary digits 0 and 1
+                     (
+                         [01]+ (?: _ [01]+ )*
+                         (?:
+                             \.
+                             (?: [01]+ (?: _ [01]+ )* )?
+                         )?
+                     |
+                         \.
+                         [01]+ (?: _ [01]+ )*
+                     )
+
+                     # exponent (power of 2) using decimal digits
+                     (?:
+                         [Pp]
+                         ( [+-]? )
+                         ( \d+ (?: _ \d+ )* )
+                     )?
+
+                     $
+                 //x)
+    {
+        my $s_sign  = $1 || '+';
+        my $s_value = $2;
+        my $e_sign  = $3 || '+';
+        my $e_value = $4 || '0';
+        $s_value =~ tr/_//d;
+        $e_value =~ tr/_//d;
 
-  }
+        # The significand must be multiplied by 2 raised to this exponent.
 
-  # We must normalize each exponent by the length of the corresponding
-  # mantissa. Life is a lot easier if we first make both exponents
-  # non-negative. We do this by adding the same positive value to both
-  # exponent. This is safe, because when comparing the exponents, only the
-  # relative difference is important.
+        my $two_expon = $class -> new($e_value);
+        $two_expon -> bneg() if $e_sign eq '-';
 
-  my $ex;
-  my $ey;
+        # If there is a dot in the significand, remove it and adjust the
+        # exponent according to the number of digits in the fraction part of
+        # the significand.
 
-  if ($x->{_es} eq '+') {
+        my $idx = index($s_value, '.');
+        if ($idx >= 0) {
+            substr($s_value, $idx, 1) = '';
+            $two_expon -= $class -> new(CORE::length($s_value))
+                                 -> bsub($idx);
+        }
 
-      # If the exponent of x is >= 0 and the exponent of y is >= 0, there is no
-      # need to do anything special.
+        $self -> {sign} = $s_sign;
+        $self -> {_m}   = $MBI -> _from_bin('0b' . $s_value);
 
-      if ($y->{_es} eq '+') {
-          $ex = $MBI->_copy($x->{_e});
-          $ey = $MBI->_copy($y->{_e});
-      }
+        if ($two_expon > 0) {
+            my $factor = $class -> new("2") -> bpow($two_expon);
+            $self -> bmul($factor);
+        } elsif ($two_expon < 0) {
+            my $factor = $class -> new("0.5") -> bpow(-$two_expon);
+            $self -> bmul($factor);
+        }
 
-      # If the exponent of x is >= 0 and the exponent of y is < 0, add the
-      # absolute value of the exponent of y to both.
+        return $self;
+    }
 
-      else {
-          $ex = $MBI->_copy($x->{_e});
-          $ex = $MBI->_add($ex, $y->{_e});      # ex + |ey|
-          $ey = $MBI->_zero();                  # -ex + |ey| = 0
-      }
+    return $self->bnan();
+}
 
-  } else {
+sub bzero {
+    # create/assign '+0'
 
-      # If the exponent of x is < 0 and the exponent of y is >= 0, add the
-      # absolute value of the exponent of x to both.
+    if (@_ == 0) {
+        Carp::carp("Using bone() as a function is deprecated;",
+                   " use bone() as a method instead");
+        unshift @_, __PACKAGE__;
+    }
 
-      if ($y->{_es} eq '+') {
-          $ex = $MBI->_zero();                  # -ex + |ex| = 0
-          $ey = $MBI->_copy($y->{_e});
-          $ey = $MBI->_add($ey, $x->{_e});      # ey + |ex|
-      }
+    my $self    = shift;
+    my $selfref = ref $self;
+    my $class   = $selfref || $self;
 
-      # If the exponent of x is < 0 and the exponent of y is < 0, add the
-      # absolute values of both exponents to both exponents.
+    $self->import() if $IMPORT == 0;            # make require work
+    return if $self->modify('bzero');
 
-      else {
-          $ex = $MBI->_copy($y->{_e});          # -ex + |ey| + |ex| = |ey|
-          $ey = $MBI->_copy($x->{_e});          # -ey + |ex| + |ey| = |ex|
-      }
+    $self = bless {}, $class unless $selfref;
 
-  }
+    $self -> {sign} = '+';
+    $self -> {_m}   = $MBI -> _zero();
+    $self -> {_es}  = '+';
+    $self -> {_e}   = $MBI -> _zero();
 
-  # Now we can normalize the exponents by adding lengths of the mantissas.
+    if (@_ > 0) {
+        if (@_ > 3) {
+            # call like: $x->bzero($a, $p, $r, $y);
+            ($self, $self->{_a}, $self->{_p}) = $self->_find_round_parameters(@_);
+        } else {
+            # call like: $x->bzero($a, $p, $r);
+            $self->{_a} = $_[0]
+              if !defined $self->{_a} || (defined $_[0] && $_[0] > $self->{_a});
+            $self->{_p} = $_[1]
+              if !defined $self->{_p} || (defined $_[1] && $_[1] > $self->{_p});
+        }
+    }
 
-  $MBI->_add($ex, $MBI->_new($mxl));
-  $MBI->_add($ey, $MBI->_new($myl));
+    return $self;
+}
 
-  # We're done if the exponents are different.
+sub bone {
+    # Create or assign '+1' (or -1 if given sign '-').
 
-  $cmp = $MBI->_acmp($ex, $ey);
-  $cmp = -$cmp if $x->{sign} eq '-';            # 124 > 123, but -124 < -123
-  return $cmp if $cmp;
+    if (@_ == 0 || (defined($_[0]) && ($_[0] eq '+' || $_[0] eq '-'))) {
+        Carp::carp("Using bone() as a function is deprecated;",
+                   " use bone() as a method instead");
+        unshift @_, __PACKAGE__;
+    }
 
-  # Compare the mantissas, but first normalize them by padding the shorter
-  # mantissa with zeros (shift left) until it has the same length as the longer
-  # mantissa.
+    my $self    = shift;
+    my $selfref = ref $self;
+    my $class   = $selfref || $self;
 
-  my $mx = $x->{_m};
-  my $my = $y->{_m};
+    $self->import() if $IMPORT == 0;            # make require work
+    return if $self->modify('bone');
 
-  if ($mxl > $myl) {
-      $my = $MBI->_lsft($MBI->_copy($my), $MBI->_new($mxl - $myl), 10);
-  } elsif ($mxl < $myl) {
-      $mx = $MBI->_lsft($MBI->_copy($mx), $MBI->_new($myl - $mxl), 10);
-  }
+    my $sign = shift;
+    $sign = defined $sign && $sign =~ /^\s*-/ ? "-" : "+";
 
-  $cmp = $MBI->_acmp($mx, $my);
-  $cmp = -$cmp if $x->{sign} eq '-';            # 124 > 123, but -124 < -123
-  return $cmp;
+    $self = bless {}, $class unless $selfref;
 
-  }
+    $self -> {sign} = $sign;
+    $self -> {_m}   = $MBI -> _one();
+    $self -> {_es}  = '+';
+    $self -> {_e}   = $MBI -> _zero();
 
-sub bacmp 
-  {
-  # Compares 2 values, ignoring their signs. 
-  # Returns one of undef, <0, =0, >0. (suitable for sort)
-  
-  # set up parameters
-  my ($self,$x,$y) = (ref($_[0]),@_);
-  # objectify is costly, so avoid it
-  if ((!ref($_[0])) || (ref($_[0]) ne ref($_[1])))
-    {
-    ($self,$x,$y) = objectify(2,@_);
+    if (@_ > 0) {
+        if (@_ > 3) {
+            # call like: $x->bone($sign, $a, $p, $r, $y, ...);
+            ($self, $self->{_a}, $self->{_p}) = $self->_find_round_parameters(@_);
+        } else {
+            # call like: $x->bone($sign, $a, $p, $r);
+            $self->{_a} = $_[0]
+              if ((!defined $self->{_a}) || (defined $_[0] && $_[0] > $self->{_a}));
+            $self->{_p} = $_[1]
+              if ((!defined $self->{_p}) || (defined $_[1] && $_[1] > $self->{_p}));
+        }
     }
 
-  return $upgrade->bacmp($x,$y) if defined $upgrade &&
-    ((!$x->isa($self)) || (!$y->isa($self)));
+    return $self;
+}
+
+sub binf {
+    # create/assign a '+inf' or '-inf'
 
-  # handle +-inf and NaN's
-  if ($x->{sign} !~ /^[+-]$/ || $y->{sign} !~ /^[+-]$/)
-    {
-    return undef if (($x->{sign} eq $nan) || ($y->{sign} eq $nan));
-    return 0 if ($x->is_inf() && $y->is_inf());
-    return 1 if ($x->is_inf() && !$y->is_inf());
-    return -1;
-    }
-
-  # shortcut 
-  my $xz = $x->is_zero();
-  my $yz = $y->is_zero();
-  return 0 if $xz && $yz;				# 0 <=> 0
-  return -1 if $xz && !$yz;				# 0 <=> +y
-  return 1 if $yz && !$xz;				# +x <=> 0
-
-  # adjust so that exponents are equal
-  my $lxm = $MBI->_len($x->{_m});
-  my $lym = $MBI->_len($y->{_m});
-  my ($xes,$yes) = (1,1);
-  $xes = -1 if $x->{_es} ne '+';
-  $yes = -1 if $y->{_es} ne '+';
-  # the numify somewhat limits our length, but makes it much faster
-  my $lx = $lxm + $xes * $MBI->_num($x->{_e});
-  my $ly = $lym + $yes * $MBI->_num($y->{_e});
-  my $l = $lx - $ly;
-  return $l <=> 0 if $l != 0;
-  
-  # lengths (corrected by exponent) are equal
-  # so make mantissa equal-length by padding with zero (shift left)
-  my $diff = $lxm - $lym;
-  my $xm = $x->{_m};		# not yet copy it
-  my $ym = $y->{_m};
-  if ($diff > 0)
+    if (@_ == 0 || (defined($_[0]) && !ref($_[0]) &&
+                    $_[0] =~ /^\s*[+-](inf(inity)?)?\s*$/))
     {
-    $ym = $MBI->_copy($y->{_m});
-    $ym = $MBI->_lsft($ym, $MBI->_new($diff), 10);
+        Carp::carp("Using binf() as a function is deprecated;",
+                   " use binf() as a method instead");
+        unshift @_, __PACKAGE__;
     }
-  elsif ($diff < 0)
+
+    my $self    = shift;
+    my $selfref = ref $self;
+    my $class   = $selfref || $self;
+
     {
-    $xm = $MBI->_copy($x->{_m});
-    $xm = $MBI->_lsft($xm, $MBI->_new(-$diff), 10);
+        no strict 'refs';
+        if (${"${class}::_trap_inf"}) {
+            Carp::croak("Tried to create +-inf in $class->binf()");
+        }
     }
-  $MBI->_acmp($xm,$ym);
-  }
 
-sub badd 
-  {
-  # add second arg (BFLOAT or string) to first (BFLOAT) (modifies first)
-  # return result as BFLOAT
+    $self->import() if $IMPORT == 0;            # make require work
+    return if $self->modify('binf');
 
-  # set up parameters
-  my ($self,$x,$y,@r) = (ref($_[0]),@_);
-  # objectify is costly, so avoid it
-  if ((!ref($_[0])) || (ref($_[0]) ne ref($_[1])))
-    {
-    ($self,$x,$y,@r) = objectify(2,@_);
+    my $sign = shift;
+    $sign = defined $sign && $sign =~ /^\s*-/ ? "-" : "+";
+
+    $self = bless {}, $class unless $selfref;
+
+    $self -> {sign} = $sign . 'inf';
+    $self -> {_m}   = $MBI -> _zero();
+    $self -> {_es}  = '+';
+    $self -> {_e}   = $MBI -> _zero();
+
+    return $self;
+}
+
+sub bnan {
+    # create/assign a 'NaN'
+
+    if (@_ == 0) {
+        Carp::carp("Using bnan() as a function is deprecated;",
+                   " use bnan() as a method instead");
+        unshift @_, __PACKAGE__;
     }
- 
-  return $x if $x->modify('badd');
 
-  # inf and NaN handling
-  if (($x->{sign} !~ /^[+-]$/) || ($y->{sign} !~ /^[+-]$/))
+    my $self    = shift;
+    my $selfref = ref $self;
+    my $class   = $selfref || $self;
+
     {
-    # NaN first
-    return $x->bnan() if (($x->{sign} eq $nan) || ($y->{sign} eq $nan));
-    # inf handling
-    if (($x->{sign} =~ /^[+-]inf$/) && ($y->{sign} =~ /^[+-]inf$/))
-      {
-      # +inf++inf or -inf+-inf => same, rest is NaN
-      return $x if $x->{sign} eq $y->{sign};
-      return $x->bnan();
-      }
-    # +-inf + something => +inf; something +-inf => +-inf
-    $x->{sign} = $y->{sign}, return $x if $y->{sign} =~ /^[+-]inf$/;
-    return $x;
+        no strict 'refs';
+        if (${"${class}::_trap_nan"}) {
+            Carp::croak("Tried to create NaN in $class->bnan()");
+        }
     }
 
-  return $upgrade->badd($x,$y,@r) if defined $upgrade &&
-   ((!$x->isa($self)) || (!$y->isa($self)));
+    $self->import() if $IMPORT == 0;            # make require work
+    return if $self->modify('bnan');
 
-  $r[3] = $y;						# no push!
+    $self = bless {}, $class unless $selfref;
 
-  # speed: no add for 0+y or x+0
-  return $x->bround(@r) if $y->is_zero();		# x+0
-  if ($x->is_zero())					# 0+y
-    {
-    # make copy, clobbering up x (modify in place!)
-    $x->{_e} = $MBI->_copy($y->{_e});
-    $x->{_es} = $y->{_es};
-    $x->{_m} = $MBI->_copy($y->{_m});
-    $x->{sign} = $y->{sign} || $nan;
-    return $x->round(@r);
-    }
- 
-  # take lower of the two e's and adapt m1 to it to match m2
-  my $e = $y->{_e};
-  $e = $MBI->_zero() if !defined $e;		# if no BFLOAT?
-  $e = $MBI->_copy($e);				# make copy (didn't do it yet)
+    $self -> {sign} = $nan;
+    $self -> {_m}   = $MBI -> _zero();
+    $self -> {_es}  = '+';
+    $self -> {_e}   = $MBI -> _zero();
 
-  my $es;
+    return $self;
+}
 
-  ($e,$es) = _e_sub($e, $x->{_e}, $y->{_es} || '+', $x->{_es});
+sub bpi {
+
+    # Called as                 Argument list
+    # ---------                 -------------
+    # Math::BigFloat->bpi()     ("Math::BigFloat")
+    # Math::BigFloat->bpi(10)   ("Math::BigFloat", 10)
+    # $x->bpi()                 ($x)
+    # $x->bpi(10)               ($x, 10)
+    # Math::BigFloat::bpi()     ()
+    # Math::BigFloat::bpi(10)   (10)
+    #
+    # In ambiguous cases, we favour the OO-style, so the following case
+    #
+    #   $n = Math::BigFloat->new("10");
+    #   $x = Math::BigFloat->bpi($n);
+    #
+    # which gives an argument list with the single element $n, is resolved as
+    #
+    #   $n->bpi();
 
-  my $add = $MBI->_copy($y->{_m});
+    my $self    = shift;
+    my $selfref = ref $self;
+    my $class   = $selfref || $self;
 
-  if ($es eq '-')				# < 0
-    {
-    $MBI->_lsft( $x->{_m}, $e, 10);
-    ($x->{_e},$x->{_es}) = _e_add($x->{_e}, $e, $x->{_es}, $es);
-    }
-  elsif (!$MBI->_is_zero($e))			# > 0
+    my $accu;                      # accuracy (number of digits)
+    my $prec;                      # precision
+    my $rndm;                      # round mode
+
+    # If bpi() is called as a function ...
+    #
+    # This cludge is necessary because we still support bpi() as a function. If
+    # bpi() is called with either no argument or one argument, and that one
+    # argument is either undefined or a scalar that looks like a number, then
+    # we assume bpi() is called as a function.
+
+    if (@_ == 0 &&
+        (defined($self) && !ref($self) && $self =~ /^\s*[+-]?\d/i)
+          ||
+        !defined($self))
     {
-    $MBI->_lsft($add, $e, 10);
+        $accu = $self;
+        $class = __PACKAGE__;
+        $self = $class -> bzero();      # initialize
     }
-  # else: both e are the same, so just leave them
 
-  if ($x->{sign} eq $y->{sign})
-    {
-    # add
-    $x->{_m} = $MBI->_add($x->{_m}, $add);
+    # ... or if bpi() is called as a method ...
+
+    else {
+        if ($selfref) {                 # bpi() called as instance method
+            return $self if $self -> modify('bpi');
+        } else {                        # bpi() called as class method
+            $self = $class -> bzero();  # initialize
+        }
+        $accu = shift;
+        $prec = shift;
+        $rndm = shift;
     }
-  else
-    {
-    ($x->{_m}, $x->{sign}) = 
-     _e_add($x->{_m}, $add, $x->{sign}, $y->{sign});
+
+    my @r = ($accu, $prec, $rndm);
+
+    # We need to limit the accuracy to protect against overflow.
+    my $fallback = 0;
+    my ($scale, @params);
+    ($self, @params) = $self -> _find_round_parameters(@r);
+
+    # Error in _find_round_parameters?
+    #
+    # We can't return here, because that will fail if $self was a NaN when
+    # bpi() was invoked, and we want to assign pi to $x. It is probably not a
+    # good idea that _find_round_parameters() signals invalid round parameters
+    # by silently returning a NaN. Fixme!
+    #return $self if $self && $self->is_nan();
+
+    # No rounding at all, so must use fallback.
+    if (scalar @params == 0) {
+        # Simulate old behaviour
+        $params[0] = $self -> div_scale();  # and round to it as accuracy
+        $params[1] = undef;                 # disable P
+        $params[2] = $r[2];                 # round mode by caller or undef
+        $fallback = 1;                      # to clear a/p afterwards
     }
 
-  # delete trailing zeros, then round
-  $x->bnorm()->round(@r);
-  }
+    # The accuracy, i.e., the number of digits. Pi has one digit before the
+    # dot, so a precision of 4 digits is equivalent to an accuracy of 5 digits.
 
-# sub bsub is inherited from Math::BigInt!
+    my $n = $params[0] || 1 - $params[1];
 
-sub binc
-  {
-  # increment arg by one
-  my ($self,$x,@r) = ref($_[0]) ? (ref($_[0]),@_) : objectify(1,@_);
+    if ($n < 1000) {
 
-  return $x if $x->modify('binc');
+        # after 黃見利 (Hwang Chien-Lih) (1997)
+        # pi/4 = 183 * atan(1/239) + 32 * atan(1/1023) – 68 * atan(1/5832)
+        #        + 12 * atan(1/110443) - 12 * atan(1/4841182) - 100 * atan(1/6826318)
 
-  if ($x->{_es} eq '-')
-    {
-    return $x->badd($self->bone(),@r);	#  digits after dot
-    }
+        # Use a few more digits in the intermediate computations.
 
-  if (!$MBI->_is_zero($x->{_e}))		# _e == 0 for NaN, inf, -inf
-    {
-    # 1e2 => 100, so after the shift below _m has a '0' as last digit
-    $x->{_m} = $MBI->_lsft($x->{_m}, $x->{_e},10);	# 1e2 => 100
-    $x->{_e} = $MBI->_zero();				# normalize
-    $x->{_es} = '+';
-    # we know that the last digit of $x will be '1' or '9', depending on the
-    # sign
-    }
-  # now $x->{_e} == 0
-  if ($x->{sign} eq '+')
-    {
-    $MBI->_inc($x->{_m});
-    return $x->bnorm()->bround(@r);
+        my $nextra = $n < 800 ? 4 : 5;
+        $n += $nextra;
+
+        my ($a, $b) = $class->_atan_inv($MBI->_new(239), $n);
+        my ($c, $d) = $class->_atan_inv($MBI->_new(1023), $n);
+        my ($e, $f) = $class->_atan_inv($MBI->_new(5832), $n);
+        my ($g, $h) = $class->_atan_inv($MBI->_new(110443), $n);
+        my ($i, $j) = $class->_atan_inv($MBI->_new(4841182), $n);
+        my ($k, $l) = $class->_atan_inv($MBI->_new(6826318), $n);
+
+        $MBI->_mul($a, $MBI->_new(732));
+        $MBI->_mul($c, $MBI->_new(128));
+        $MBI->_mul($e, $MBI->_new(272));
+        $MBI->_mul($g, $MBI->_new(48));
+        $MBI->_mul($i, $MBI->_new(48));
+        $MBI->_mul($k, $MBI->_new(400));
+
+        my $x = $class->bone(); $x->{_m} = $a; my $x_d = $class->bone(); $x_d->{_m} = $b;
+        my $y = $class->bone(); $y->{_m} = $c; my $y_d = $class->bone(); $y_d->{_m} = $d;
+        my $z = $class->bone(); $z->{_m} = $e; my $z_d = $class->bone(); $z_d->{_m} = $f;
+        my $u = $class->bone(); $u->{_m} = $g; my $u_d = $class->bone(); $u_d->{_m} = $h;
+        my $v = $class->bone(); $v->{_m} = $i; my $v_d = $class->bone(); $v_d->{_m} = $j;
+        my $w = $class->bone(); $w->{_m} = $k; my $w_d = $class->bone(); $w_d->{_m} = $l;
+        $x->bdiv($x_d, $n);
+        $y->bdiv($y_d, $n);
+        $z->bdiv($z_d, $n);
+        $u->bdiv($u_d, $n);
+        $v->bdiv($v_d, $n);
+        $w->bdiv($w_d, $n);
+
+        delete $x->{_a}; delete $y->{_a}; delete $z->{_a};
+        delete $u->{_a}; delete $v->{_a}; delete $w->{_a};
+        $x->badd($y)->bsub($z)->badd($u)->bsub($v)->bsub($w);
+
+        for my $key (qw/ sign _m _es _e _a _p /) {
+            $self -> {$key} = $x -> {$key} if exists $x -> {$key};
+        }
+
+    } else {
+
+        # For large accuracy, the arctan formulas become very inefficient with
+        # Math::BigFloat. Switch to Brent-Salamin (aka AGM or Gauss-Legendre).
+
+        # Use a few more digits in the intermediate computations.
+        my $nextra = 8;
+
+        $HALF = $class -> new($HALF) unless ref($HALF);
+        my ($an, $bn, $tn, $pn) = ($class -> bone, $HALF -> copy() -> bsqrt($n),
+                                   $HALF -> copy() -> bmul($HALF), $class -> bone);
+        while ($pn < $n) {
+            my $prev_an = $an -> copy();
+            $an -> badd($bn) -> bmul($HALF, $n);
+            $bn -> bmul($prev_an) -> bsqrt($n);
+            $prev_an -> bsub($an);
+            $tn -> bsub($pn * $prev_an * $prev_an);
+            $pn -> badd($pn);
+        }
+        $an -> badd($bn);
+        $an -> bmul($an, $n) -> bdiv(4 * $tn, $n);
+
+        for my $key (qw/ sign _m _es _e _a _p /) {
+            $self -> {$key} = $an -> {$key} if exists $an -> {$key};;
+        }
     }
-  elsif ($x->{sign} eq '-')
-    {
-    $MBI->_dec($x->{_m});
-    $x->{sign} = '+' if $MBI->_is_zero($x->{_m}); # -1 +1 => -0 => +0
-    return $x->bnorm()->bround(@r);
+
+    $self -> round(@params);
+
+    if ($fallback) {
+        delete $self->{_a};
+        delete $self->{_p};
     }
-  # inf, nan handling etc
-  $x->badd($self->bone(),@r);			# badd() does round 
-  }
 
-sub bdec
-  {
-  # decrement arg by one
-  my ($self,$x,@r) = ref($_[0]) ? (ref($_[0]),@_) : objectify(1,@_);
+    return $self;
+}
 
-  return $x if $x->modify('bdec');
+sub copy {
+    my $self    = shift;
+    my $selfref = ref $self;
+    my $class   = $selfref || $self;
 
-  if ($x->{_es} eq '-')
-    {
-    return $x->badd($self->bone('-'),@r);	#  digits after dot
-    }
+    # If called as a class method, the object to copy is the next argument.
 
-  if (!$MBI->_is_zero($x->{_e}))
-    {
-    $x->{_m} = $MBI->_lsft($x->{_m}, $x->{_e},10);	# 1e2 => 100
-    $x->{_e} = $MBI->_zero();				# normalize
-    $x->{_es} = '+';
+    $self = shift() unless $selfref;
+
+    my $copy = bless {}, $class;
+
+    $copy->{sign} = $self->{sign};
+    $copy->{_es}  = $self->{_es};
+    $copy->{_m}   = $MBI->_copy($self->{_m});
+    $copy->{_e}   = $MBI->_copy($self->{_e});
+    $copy->{_a}   = $self->{_a} if exists $self->{_a};
+    $copy->{_p}   = $self->{_p} if exists $self->{_p};
+
+    return $copy;
+}
+
+sub as_number {
+    # return copy as a bigint representation of this Math::BigFloat number
+    my ($class, $x) = ref($_[0]) ? (ref($_[0]), $_[0]) : objectify(1, @_);
+
+    return $x if $x->modify('as_number');
+
+    if (!$x->isa('Math::BigFloat')) {
+        # if the object can as_number(), use it
+        return $x->as_number() if $x->can('as_number');
+        # otherwise, get us a float and then a number
+        $x = $x->can('as_float') ? $x->as_float() : $class->new(0+"$x");
     }
-  # now $x->{_e} == 0
-  my $zero = $x->is_zero();
-  # <= 0
-  if (($x->{sign} eq '-') || $zero)
-    {
-    $MBI->_inc($x->{_m});
-    $x->{sign} = '-' if $zero;				# 0 => 1 => -1
-    $x->{sign} = '+' if $MBI->_is_zero($x->{_m});	# -1 +1 => -0 => +0
-    return $x->bnorm()->round(@r);
+
+    return Math::BigInt->binf($x->sign()) if $x->is_inf();
+    return Math::BigInt->bnan()           if $x->is_nan();
+
+    my $z = $MBI->_copy($x->{_m});
+    if ($x->{_es} eq '-') {                     # < 0
+        $MBI->_rsft($z, $x->{_e}, 10);
+    } elsif (! $MBI->_is_zero($x->{_e})) {      # > 0
+        $MBI->_lsft($z, $x->{_e}, 10);
     }
-  # > 0
-  elsif ($x->{sign} eq '+')
-    {
-    $MBI->_dec($x->{_m});
-    return $x->bnorm()->round(@r);
+    $z = Math::BigInt->new($x->{sign} . $MBI->_str($z));
+    $z;
+}
+
+###############################################################################
+# Boolean methods
+###############################################################################
+
+sub is_zero {
+    # return true if arg (BFLOAT or num_str) is zero
+    my ($class, $x) = ref($_[0]) ? (undef, $_[0]) : objectify(1, @_);
+
+    ($x->{sign} eq '+' && $MBI->_is_zero($x->{_m})) ? 1 : 0;
+}
+
+sub is_one {
+    # return true if arg (BFLOAT or num_str) is +1 or -1 if signis given
+    my ($class, $x, $sign) = ref($_[0]) ? (undef, @_) : objectify(1, @_);
+
+    $sign = '+' if !defined $sign || $sign ne '-';
+
+    ($x->{sign} eq $sign &&
+     $MBI->_is_zero($x->{_e}) &&
+     $MBI->_is_one($x->{_m})) ? 1 : 0;
+}
+
+sub is_odd {
+    # return true if arg (BFLOAT or num_str) is odd or false if even
+    my ($class, $x) = ref($_[0]) ? (undef, $_[0]) : objectify(1, @_);
+
+    (($x->{sign} =~ /^[+-]$/) && # NaN & +-inf aren't
+     ($MBI->_is_zero($x->{_e})) &&
+     ($MBI->_is_odd($x->{_m}))) ? 1 : 0;
+}
+
+sub is_even {
+    # return true if arg (BINT or num_str) is even or false if odd
+    my ($class, $x) = ref($_[0]) ? (undef, $_[0]) : objectify(1, @_);
+
+    (($x->{sign} =~ /^[+-]$/) &&        # NaN & +-inf aren't
+     ($x->{_es} eq '+') &&              # 123.45 isn't
+     ($MBI->_is_even($x->{_m}))) ? 1 : 0; # but 1200 is
+}
+
+sub is_int {
+    # return true if arg (BFLOAT or num_str) is an integer
+    my ($class, $x) = ref($_[0]) ? (undef, $_[0]) : objectify(1, @_);
+
+    (($x->{sign} =~ /^[+-]$/) && # NaN and +-inf aren't
+     ($x->{_es} eq '+')) ? 1 : 0; # 1e-1 => no integer
+}
+
+###############################################################################
+# Comparison methods
+###############################################################################
+
+sub bcmp {
+    # Compares 2 values.  Returns one of undef, <0, =0, >0. (suitable for sort)
+
+    # set up parameters
+    my ($class, $x, $y) = (ref($_[0]), @_);
+
+    # objectify is costly, so avoid it
+    if ((!ref($_[0])) || (ref($_[0]) ne ref($_[1]))) {
+        ($class, $x, $y) = objectify(2, @_);
     }
-  # inf, nan handling etc
-  $x->badd($self->bone('-'),@r);		# does round
-  } 
 
-sub DEBUG () { 0; }
+    return $upgrade->bcmp($x, $y) if defined $upgrade &&
+      ((!$x->isa($class)) || (!$y->isa($class)));
 
-sub blog
-  {
-  my ($self,$x,$base,$a,$p,$r) = ref($_[0]) ? (ref($_[0]),@_) : objectify(1,@_);
+    # Handle all 'nan' cases.
 
-  # If called as $x -> blog() or $x -> blog(undef), don't objectify the
-  # undefined base, since undef signals that the base is Euler's number.
-  #unless (ref($x) && !defined($base)) {
-  #    # objectify is costly, so avoid it
-  #    if ((!ref($_[0])) || (ref($_[0]) ne ref($_[1]))) {
-  #        ($self,$x,$base,$a,$p,$r) = objectify(2,@_);
-  #    }
-  #}
+    return undef if ($x->{sign} eq $nan) || ($y->{sign} eq $nan);
 
-  return $x if $x->modify('blog');
+    # Handle all '+inf' and '-inf' cases.
 
-  return $x -> bnan() if $x -> is_nan();
+    return  0 if ($x->{sign} eq '+inf' && $y->{sign} eq '+inf' ||
+                  $x->{sign} eq '-inf' && $y->{sign} eq '-inf');
+    return +1 if $x->{sign} eq '+inf'; # x = +inf and y < +inf
+    return -1 if $x->{sign} eq '-inf'; # x = -inf and y > -inf
+    return -1 if $y->{sign} eq '+inf'; # x < +inf and y = +inf
+    return +1 if $y->{sign} eq '-inf'; # x > -inf and y = -inf
 
-  # we need to limit the accuracy to protect against overflow
-  my $fallback = 0;
-  my ($scale,@params);
-  ($x,@params) = $x->_find_round_parameters($a,$p,$r);
+    # Handle all cases with opposite signs.
 
-  # no rounding at all, so must use fallback
-  if (scalar @params == 0)
-    {
-    # simulate old behaviour
-    $params[0] = $self->div_scale();	# and round to it as accuracy
-    $params[1] = undef;			# P = undef
-    $scale = $params[0]+4; 		# at least four more for proper round
-    $params[2] = $r;			# round mode by caller or undef
-    $fallback = 1;			# to clear a/p afterwards
-    }
-  else
-    {
-    # the 4 below is empirical, and there might be cases where it is not
-    # enough...
-    $scale = abs($params[0] || $params[1]) + 4;	# take whatever is defined
-    }
-
-  my $done = 0;
-  if (defined $base) {
-      $base = $self -> new($base) unless ref $base;
-      if ($base -> is_nan() || $base -> is_one()) {
-          $x -> bnan();
-          $done = 1;
-      } elsif ($base -> is_inf() || $base -> is_zero()) {
-          if ($x -> is_inf() || $x -> is_zero()) {
-              $x -> bnan();
-          } else {
-              $x -> bzero(@params);
-          }
-          $done = 1;
-      } elsif ($base -> is_negative()) {        # -inf < base < 0
-          if ($x -> is_one()) {                 #     x = 1
-              $x -> bzero(@params);
-          } elsif ($x == $base) {
-              $x -> bone('+', @params);         #     x = base
-          } else {
-              $x -> bnan();                     #     otherwise
-          }
-          $done = 1;
-      } elsif ($x == $base) {
-          $x -> bone('+', @params);             # 0 < base && 0 < x < inf
-          $done = 1;
-      }
-  }
-
-  # We now know that the base is either undefined or positive and finite.
-
-  unless ($done) {
-      if ($x -> is_inf()) {             #   x = +/-inf
-          my $sign = defined $base && $base < 1 ? '-' : '+';
-          $x -> binf($sign);
-          $done = 1;
-      } elsif ($x -> is_neg()) {        #   -inf < x < 0
-          $x -> bnan();
-          $done = 1;
-      } elsif ($x -> is_one()) {        #   x = 1
-          $x -> bzero(@params);
-          $done = 1;
-      } elsif ($x -> is_zero()) {       #   x = 0
-          my $sign = defined $base && $base < 1 ? '+' : '-';
-          $x -> binf($sign);
-          $done = 1;
-      }
-  }
-
-  if ($done) {
-      if ($fallback) {
-        # clear a/p after round, since user did not request it
-          delete $x->{_a};
-          delete $x->{_p};
+    return +1 if $x->{sign} eq '+' && $y->{sign} eq '-'; # also does 0 <=> -y
+    return -1 if $x->{sign} eq '-' && $y->{sign} eq '+'; # also does -x <=> 0
+
+    # Handle all remaining zero cases.
+
+    my $xz = $x->is_zero();
+    my $yz = $y->is_zero();
+    return  0 if $xz && $yz;             # 0 <=> 0
+    return -1 if $xz && $y->{sign} eq '+'; # 0 <=> +y
+    return +1 if $yz && $x->{sign} eq '+'; # +x <=> 0
+
+    # Both arguments are now finite, non-zero numbers with the same sign.
+
+    my $cmp;
+
+    # The next step is to compare the exponents, but since each mantissa is an
+    # integer of arbitrary value, the exponents must be normalized by the length
+    # of the mantissas before we can compare them.
+
+    my $mxl = $MBI->_len($x->{_m});
+    my $myl = $MBI->_len($y->{_m});
+
+    # If the mantissas have the same length, there is no point in normalizing the
+    # exponents by the length of the mantissas, so treat that as a special case.
+
+    if ($mxl == $myl) {
+
+        # First handle the two cases where the exponents have different signs.
+
+        if ($x->{_es} eq '+' && $y->{_es} eq '-') {
+            $cmp = +1;
+        } elsif ($x->{_es} eq '-' && $y->{_es} eq '+') {
+            $cmp = -1;
         }
-      return $x;
-      }
-
-  # when user set globals, they would interfere with our calculation, so
-  # disable them and later re-enable them
-  no strict 'refs';
-  my $abr = "$self\::accuracy"; my $ab = $$abr; $$abr = undef;
-  my $pbr = "$self\::precision"; my $pb = $$pbr; $$pbr = undef;
-  # we also need to disable any set A or P on $x (_find_round_parameters took
-  # them already into account), since these would interfere, too
-  delete $x->{_a}; delete $x->{_p};
-  # need to disable $upgrade in BigInt, to avoid deep recursion
-  local $Math::BigInt::upgrade = undef;
-  local $Math::BigFloat::downgrade = undef;
-
-  # upgrade $x if $x is not a BigFloat (handle BigInt input)
-  # XXX TODO: rebless!
-  if (!$x->isa('Math::BigFloat'))
-    {
-    $x = Math::BigFloat->new($x);
-    $self = ref($x);
-    }
-  
-  $done = 0;
 
-  # If the base is defined and an integer, try to calculate integer result
-  # first. This is very fast, and in case the real result was found, we can
-  # stop right here.
-  if (defined $base && $base->is_int() && $x->is_int())
-    {
-    my $i = $MBI->_copy( $x->{_m} );
-    $MBI->_lsft( $i, $x->{_e}, 10 ) unless $MBI->_is_zero($x->{_e});
-    my $int = Math::BigInt->bzero();
-    $int->{value} = $i;
-    $int->blog($base->as_number());
-    # if ($exact)
-    if ($base->as_number()->bpow($int) == $x)
-      {
-      # found result, return it
-      $x->{_m} = $int->{value};
-      $x->{_e} = $MBI->_zero();
-      $x->{_es} = '+';
-      $x->bnorm();
-      $done = 1;
-      }
-    }
-
-  if ($done == 0)
-    {
-    # base is undef, so base should be e (Euler's number), so first calculate the
-    # log to base e (using reduction by 10 (and probably 2)):
-    $self->_log_10($x,$scale);
-
-    # and if a different base was requested, convert it
-    if (defined $base)
-      {
-      $base = Math::BigFloat->new($base) unless $base->isa('Math::BigFloat');
-      # not ln, but some other base (don't modify $base)
-      $x->bdiv( $base->copy()->blog(undef,$scale), $scale );
-      }
-    }
- 
-  # shortcut to not run through _find_round_parameters again
-  if (defined $params[0])
-    {
-    $x->bround($params[0],$params[2]);		# then round accordingly
-    }
-  else
-    {
-    $x->bfround($params[1],$params[2]);		# then round accordingly
+        # Then handle the case where the exponents have the same sign.
+
+        else {
+            $cmp = $MBI->_acmp($x->{_e}, $y->{_e});
+            $cmp = -$cmp if $x->{_es} eq '-';
+        }
+
+        # Adjust for the sign, which is the same for x and y, and bail out if
+        # we're done.
+
+        $cmp = -$cmp if $x->{sign} eq '-'; # 124 > 123, but -124 < -123
+        return $cmp if $cmp;
+
     }
-  if ($fallback)
-    {
-    # clear a/p after round, since user did not request it
-    delete $x->{_a}; delete $x->{_p};
+
+    # We must normalize each exponent by the length of the corresponding
+    # mantissa. Life is a lot easier if we first make both exponents
+    # non-negative. We do this by adding the same positive value to both
+    # exponent. This is safe, because when comparing the exponents, only the
+    # relative difference is important.
+
+    my $ex;
+    my $ey;
+
+    if ($x->{_es} eq '+') {
+
+        # If the exponent of x is >= 0 and the exponent of y is >= 0, there is no
+        # need to do anything special.
+
+        if ($y->{_es} eq '+') {
+            $ex = $MBI->_copy($x->{_e});
+            $ey = $MBI->_copy($y->{_e});
+        }
+
+        # If the exponent of x is >= 0 and the exponent of y is < 0, add the
+        # absolute value of the exponent of y to both.
+
+        else {
+            $ex = $MBI->_copy($x->{_e});
+            $ex = $MBI->_add($ex, $y->{_e}); # ex + |ey|
+            $ey = $MBI->_zero();             # -ex + |ey| = 0
+        }
+
+    } else {
+
+        # If the exponent of x is < 0 and the exponent of y is >= 0, add the
+        # absolute value of the exponent of x to both.
+
+        if ($y->{_es} eq '+') {
+            $ex = $MBI->_zero(); # -ex + |ex| = 0
+            $ey = $MBI->_copy($y->{_e});
+            $ey = $MBI->_add($ey, $x->{_e}); # ey + |ex|
+        }
+
+        # If the exponent of x is < 0 and the exponent of y is < 0, add the
+        # absolute values of both exponents to both exponents.
+
+        else {
+            $ex = $MBI->_copy($y->{_e}); # -ex + |ey| + |ex| = |ey|
+            $ey = $MBI->_copy($x->{_e}); # -ey + |ex| + |ey| = |ex|
+        }
+
     }
-  # restore globals
-  $$abr = $ab; $$pbr = $pb;
 
-  $x;
-  }
+    # Now we can normalize the exponents by adding lengths of the mantissas.
 
-sub _len_to_steps
-  {
-  # Given D (digits in decimal), compute N so that N! (N factorial) is
-  # at least D digits long. D should be at least 50.
-  my $d = shift;
+    $MBI->_add($ex, $MBI->_new($mxl));
+    $MBI->_add($ey, $MBI->_new($myl));
 
-  # two constants for the Ramanujan estimate of ln(N!)
-  my $lg2 = log(2 * 3.14159265) / 2;
-  my $lg10 = log(10);
+    # We're done if the exponents are different.
 
-  # D = 50 => N => 42, so L = 40 and R = 50
-  my $l = 40; my $r = $d;
+    $cmp = $MBI->_acmp($ex, $ey);
+    $cmp = -$cmp if $x->{sign} eq '-'; # 124 > 123, but -124 < -123
+    return $cmp if $cmp;
 
-  # Otherwise this does not work under -Mbignum and we do not yet have "no bignum;" :(
-  $l = $l->numify if ref($l);
-  $r = $r->numify if ref($r);
-  $lg2 = $lg2->numify if ref($lg2);
-  $lg10 = $lg10->numify if ref($lg10);
+    # Compare the mantissas, but first normalize them by padding the shorter
+    # mantissa with zeros (shift left) until it has the same length as the longer
+    # mantissa.
 
-  # binary search for the right value (could this be written as the reverse of lg(n!)?)
-  while ($r - $l > 1)
-    {
-    my $n = int(($r - $l) / 2) + $l;
-    my $ramanujan = 
-      int(($n * log($n) - $n + log( $n * (1 + 4*$n*(1+2*$n)) ) / 6 + $lg2) / $lg10);
-    $ramanujan > $d ? $r = $n : $l = $n;
-    }
-  $l;
-  }
-
-sub bnok
-  {
-  # Calculate n over k (binomial coefficient or "choose" function) as integer.
-  # set up parameters
-  my ($self,$x,$y,@r) = (ref($_[0]),@_);
-
-  # objectify is costly, so avoid it
-  if ((!ref($_[0])) || (ref($_[0]) ne ref($_[1])))
-    {
-    ($self,$x,$y,@r) = objectify(2,@_);
+    my $mx = $x->{_m};
+    my $my = $y->{_m};
+
+    if ($mxl > $myl) {
+        $my = $MBI->_lsft($MBI->_copy($my), $MBI->_new($mxl - $myl), 10);
+    } elsif ($mxl < $myl) {
+        $mx = $MBI->_lsft($MBI->_copy($mx), $MBI->_new($myl - $mxl), 10);
     }
 
-  return $x if $x->modify('bnok');
+    $cmp = $MBI->_acmp($mx, $my);
+    $cmp = -$cmp if $x->{sign} eq '-'; # 124 > 123, but -124 < -123
+    return $cmp;
 
-  return $x->bnan() if $x->is_nan() || $y->is_nan();
-  return $x->binf() if $x->is_inf();
+}
 
-  my $u = $x->as_int();
-  $u->bnok($y->as_int());
+sub bacmp {
+    # Compares 2 values, ignoring their signs.
+    # Returns one of undef, <0, =0, >0. (suitable for sort)
 
-  $x->{_m} = $u->{value};
-  $x->{_e} = $MBI->_zero();
-  $x->{_es} = '+';
-  $x->{sign} = '+';
-  $x->bnorm(@r);
-  }
+    # set up parameters
+    my ($class, $x, $y) = (ref($_[0]), @_);
+    # objectify is costly, so avoid it
+    if ((!ref($_[0])) || (ref($_[0]) ne ref($_[1]))) {
+        ($class, $x, $y) = objectify(2, @_);
+    }
+
+    return $upgrade->bacmp($x, $y) if defined $upgrade &&
+      ((!$x->isa($class)) || (!$y->isa($class)));
+
+    # handle +-inf and NaN's
+    if ($x->{sign} !~ /^[+-]$/ || $y->{sign} !~ /^[+-]$/) {
+        return undef if (($x->{sign} eq $nan) || ($y->{sign} eq $nan));
+        return 0 if ($x->is_inf() && $y->is_inf());
+        return 1 if ($x->is_inf() && !$y->is_inf());
+        return -1;
+    }
+
+    # shortcut
+    my $xz = $x->is_zero();
+    my $yz = $y->is_zero();
+    return 0 if $xz && $yz;     # 0 <=> 0
+    return -1 if $xz && !$yz;   # 0 <=> +y
+    return 1 if $yz && !$xz;    # +x <=> 0
+
+    # adjust so that exponents are equal
+    my $lxm = $MBI->_len($x->{_m});
+    my $lym = $MBI->_len($y->{_m});
+    my ($xes, $yes) = (1, 1);
+    $xes = -1 if $x->{_es} ne '+';
+    $yes = -1 if $y->{_es} ne '+';
+    # the numify somewhat limits our length, but makes it much faster
+    my $lx = $lxm + $xes * $MBI->_num($x->{_e});
+    my $ly = $lym + $yes * $MBI->_num($y->{_e});
+    my $l = $lx - $ly;
+    return $l <=> 0 if $l != 0;
+
+    # lengths (corrected by exponent) are equal
+    # so make mantissa equal-length by padding with zero (shift left)
+    my $diff = $lxm - $lym;
+    my $xm = $x->{_m};          # not yet copy it
+    my $ym = $y->{_m};
+    if ($diff > 0) {
+        $ym = $MBI->_copy($y->{_m});
+        $ym = $MBI->_lsft($ym, $MBI->_new($diff), 10);
+    } elsif ($diff < 0) {
+        $xm = $MBI->_copy($x->{_m});
+        $xm = $MBI->_lsft($xm, $MBI->_new(-$diff), 10);
+    }
+    $MBI->_acmp($xm, $ym);
+}
 
-sub bexp
-  {
-  # Calculate e ** X (Euler's number to the power of X)
-  my ($self,$x,$a,$p,$r) = ref($_[0]) ? (ref($_[0]),@_) : objectify(1,@_);
+###############################################################################
+# Arithmetic methods
+###############################################################################
 
-  return $x if $x->modify('bexp');
+sub bneg {
+    # (BINT or num_str) return BINT
+    # negate number or make a negated number from string
+    my ($class, $x) = ref($_[0]) ? (undef, $_[0]) : objectify(1, @_);
 
-  return $x->binf() if $x->{sign} eq '+inf';
-  return $x->bzero() if $x->{sign} eq '-inf';
+    return $x if $x->modify('bneg');
 
-  # we need to limit the accuracy to protect against overflow
-  my $fallback = 0;
-  my ($scale,@params);
-  ($x,@params) = $x->_find_round_parameters($a,$p,$r);
+    # for +0 do not negate (to have always normalized +0). Does nothing for 'NaN'
+    $x->{sign} =~ tr/+-/-+/ unless ($x->{sign} eq '+' && $MBI->_is_zero($x->{_m}));
+    $x;
+}
 
-  # also takes care of the "error in _find_round_parameters?" case
-  return $x if $x->{sign} eq 'NaN';
+sub bnorm {
+    # adjust m and e so that m is smallest possible
+    my ($class, $x) = ref($_[0]) ? (undef, $_[0]) : objectify(1, @_);
 
-  # no rounding at all, so must use fallback
-  if (scalar @params == 0)
-    {
-    # simulate old behaviour
-    $params[0] = $self->div_scale();	# and round to it as accuracy
-    $params[1] = undef;			# P = undef
-    $scale = $params[0]+4; 		# at least four more for proper round
-    $params[2] = $r;			# round mode by caller or undef
-    $fallback = 1;			# to clear a/p afterwards
-    }
-  else
-    {
-    # the 4 below is empirical, and there might be cases where it's not enough...
-    $scale = abs($params[0] || $params[1]) + 4;	# take whatever is defined
+    return $x if $x->{sign} !~ /^[+-]$/; # inf, nan etc
+
+    my $zeros = $MBI->_zeros($x->{_m}); # correct for trailing zeros
+    if ($zeros != 0) {
+        my $z = $MBI->_new($zeros);
+        $x->{_m} = $MBI->_rsft($x->{_m}, $z, 10);
+        if ($x->{_es} eq '-') {
+            if ($MBI->_acmp($x->{_e}, $z) >= 0) {
+                $x->{_e} = $MBI->_sub($x->{_e}, $z);
+                $x->{_es} = '+' if $MBI->_is_zero($x->{_e});
+            } else {
+                $x->{_e} = $MBI->_sub($MBI->_copy($z), $x->{_e});
+                $x->{_es} = '+';
+            }
+        } else {
+            $x->{_e} = $MBI->_add($x->{_e}, $z);
+        }
+    } else {
+        # $x can only be 0Ey if there are no trailing zeros ('0' has 0 trailing
+        # zeros). So, for something like 0Ey, set y to 1, and -0 => +0
+        $x->{sign} = '+', $x->{_es} = '+', $x->{_e} = $MBI->_one()
+          if $MBI->_is_zero($x->{_m});
     }
 
-  return $x->bone(@params) if $x->is_zero();
+    $x;
+}
 
-  if (!$x->isa('Math::BigFloat'))
-    {
-    $x = Math::BigFloat->new($x);
-    $self = ref($x);
-    }
-  
-  # when user set globals, they would interfere with our calculation, so
-  # disable them and later re-enable them
-  no strict 'refs';
-  my $abr = "$self\::accuracy"; my $ab = $$abr; $$abr = undef;
-  my $pbr = "$self\::precision"; my $pb = $$pbr; $$pbr = undef;
-  # we also need to disable any set A or P on $x (_find_round_parameters took
-  # them already into account), since these would interfere, too
-  delete $x->{_a}; delete $x->{_p};
-  # need to disable $upgrade in BigInt, to avoid deep recursion
-  local $Math::BigInt::upgrade = undef;
-  local $Math::BigFloat::downgrade = undef;
-
-  my $x_org = $x->copy();
-
-  # We use the following Taylor series:
-
-  #           x    x^2   x^3   x^4
-  #  e = 1 + --- + --- + --- + --- ...
-  #           1!    2!    3!    4!
-
-  # The difference for each term is X and N, which would result in:
-  # 2 copy, 2 mul, 2 add, 1 inc, 1 div operations per term
-
-  # But it is faster to compute exp(1) and then raising it to the
-  # given power, esp. if $x is really big and an integer because:
-
-  #  * The numerator is always 1, making the computation faster
-  #  * the series converges faster in the case of x == 1
-  #  * We can also easily check when we have reached our limit: when the
-  #    term to be added is smaller than "1E$scale", we can stop - f.i.
-  #    scale == 5, and we have 1/40320, then we stop since 1/40320 < 1E-5.
-  #  * we can compute the *exact* result by simulating bigrat math:
-
-  #  1   1    gcd(3,4) = 1    1*24 + 1*6    5
-  #  - + -                  = ---------- =  --                 
-  #  6   24                      6*24       24
-
-  # We do not compute the gcd() here, but simple do:
-  #  1   1    1*24 + 1*6   30
-  #  - + -  = --------- =  --                 
-  #  6   24       6*24     144
-
-  # In general:
-  #  a   c    a*d + c*b 	and note that c is always 1 and d = (b*f)
-  #  - + -  = ---------
-  #  b   d       b*d
-
-  # This leads to:         which can be reduced by b to:
-  #  a   1     a*b*f + b    a*f + 1
-  #  - + -   = --------- =  -------
-  #  b   b*f     b*b*f        b*f
-
-  # The first terms in the series are:
-
-  # 1     1    1    1    1    1     1     1     13700
-  # -- + -- + -- + -- + -- + --- + --- + ---- = -----
-  # 1     1    2    6   24   120   720   5040   5040
-
-  # Note that we cannot simple reduce 13700/5040 to 685/252, but must keep A and B!
-
-  if ($scale <= 75)
-    {
-    # set $x directly from a cached string form
-    $x->{_m} = $MBI->_new(
-    "27182818284590452353602874713526624977572470936999595749669676277240766303535476");
-    $x->{sign} = '+';
-    $x->{_es} = '-';
-    $x->{_e} = $MBI->_new(79);
+sub binc {
+    # increment arg by one
+    my ($class, $x, @r) = ref($_[0]) ? (ref($_[0]), @_) : objectify(1, @_);
+
+    return $x if $x->modify('binc');
+
+    if ($x->{_es} eq '-') {
+        return $x->badd($class->bone(), @r); #  digits after dot
     }
-  else
+
+    if (!$MBI->_is_zero($x->{_e})) # _e == 0 for NaN, inf, -inf
     {
-    # compute A and B so that e = A / B.
- 
-    # After some terms we end up with this, so we use it as a starting point:
-    my $A = $MBI->_new("90933395208605785401971970164779391644753259799242");
-    my $F = $MBI->_new(42); my $step = 42;
-
-    # Compute how many steps we need to take to get $A and $B sufficiently big
-    my $steps = _len_to_steps($scale - 4);
-#    print STDERR "# Doing $steps steps for ", $scale-4, " digits\n";
-    while ($step++ <= $steps)
-      {
-      # calculate $a * $f + 1
-      $A = $MBI->_mul($A, $F);
-      $A = $MBI->_inc($A);
-      # increment f
-      $F = $MBI->_inc($F);
-      }
-    # compute $B as factorial of $steps (this is faster than doing it manually)
-    my $B = $MBI->_fac($MBI->_new($steps));
-    
-#  print "A ", $MBI->_str($A), "\nB ", $MBI->_str($B), "\n";
-
-    # compute A/B with $scale digits in the result (truncate, not round)
-    $A = $MBI->_lsft( $A, $MBI->_new($scale), 10);
-    $A = $MBI->_div( $A, $B );
-
-    $x->{_m} = $A;
-    $x->{sign} = '+';
-    $x->{_es} = '-';
-    $x->{_e} = $MBI->_new($scale);
+        # 1e2 => 100, so after the shift below _m has a '0' as last digit
+        $x->{_m} = $MBI->_lsft($x->{_m}, $x->{_e}, 10); # 1e2 => 100
+        $x->{_e} = $MBI->_zero();                      # normalize
+        $x->{_es} = '+';
+        # we know that the last digit of $x will be '1' or '9', depending on the
+        # sign
     }
+    # now $x->{_e} == 0
+    if ($x->{sign} eq '+') {
+        $MBI->_inc($x->{_m});
+        return $x->bnorm()->bround(@r);
+    } elsif ($x->{sign} eq '-') {
+        $MBI->_dec($x->{_m});
+        $x->{sign} = '+' if $MBI->_is_zero($x->{_m}); # -1 +1 => -0 => +0
+        return $x->bnorm()->bround(@r);
+    }
+    # inf, nan handling etc
+    $x->badd($class->bone(), @r); # badd() does round
+}
 
-  # $x contains now an estimate of e, with some surplus digits, so we can round
-  if (!$x_org->is_one())
-    {
-    # Reduce size of fractional part, followup with integer power of two.
-    my $lshift = 0;
-    while ($lshift < 30 && $x_org->bacmp(2 << $lshift) > 0)
-      {
-        $lshift++;
-      }
-    # Raise $x to the wanted power and round it.
-    if ($lshift == 0)
-      {
-        $x->bpow($x_org, @params);
-      }
-    else
-      {
-        my($mul, $rescale) = (1 << $lshift, $scale+1+$lshift);
-        $x->bpow(scalar $x_org->bdiv($mul,$rescale),$rescale)->bpow($mul, @params);
-      }
-    }
-  else
-    {
-    # else just round the already computed result
-    delete $x->{_a}; delete $x->{_p};
-    # shortcut to not run through _find_round_parameters again
-    if (defined $params[0])
-      {
-      $x->bround($params[0],$params[2]);		# then round accordingly
-      }
-    else
-      {
-      $x->bfround($params[1],$params[2]);		# then round accordingly
-      }
-    }
-  if ($fallback)
-    {
-    # clear a/p after round, since user did not request it
-    delete $x->{_a}; delete $x->{_p};
+sub bdec {
+    # decrement arg by one
+    my ($class, $x, @r) = ref($_[0]) ? (ref($_[0]), @_) : objectify(1, @_);
+
+    return $x if $x->modify('bdec');
+
+    if ($x->{_es} eq '-') {
+        return $x->badd($class->bone('-'), @r); #  digits after dot
     }
-  # restore globals
-  $$abr = $ab; $$pbr = $pb;
-
-  $x;						# return modified $x
-  }
-
-sub _log
-  {
-  # internal log function to calculate ln() based on Taylor series.
-  # Modifies $x in place.
-  my ($self,$x,$scale) = @_;
-
-  # in case of $x == 1, result is 0
-  return $x->bzero() if $x->is_one();
-
-  # XXX TODO: rewrite this in a similar manner to bexp()
-
-  # http://www.efunda.com/math/taylor_series/logarithmic.cfm?search_string=log
-
-  # u = x-1, v = x+1
-  #              _                               _
-  # Taylor:     |    u    1   u^3   1   u^5       |
-  # ln (x)  = 2 |   --- + - * --- + - * --- + ... |  x > 0
-  #             |_   v    3   v^3   5   v^5      _|
-
-  # This takes much more steps to calculate the result and is thus not used
-  # u = x-1
-  #              _                               _
-  # Taylor:     |    u    1   u^2   1   u^3       |
-  # ln (x)  = 2 |   --- + - * --- + - * --- + ... |  x > 1/2
-  #             |_   x    2   x^2   3   x^3      _|
-
-  my ($limit,$v,$u,$below,$factor,$two,$next,$over,$f);
-
-  $v = $x->copy(); $v->binc();		# v = x+1
-  $x->bdec(); $u = $x->copy();		# u = x-1; x = x-1
-  $x->bdiv($v,$scale);			# first term: u/v
-  $below = $v->copy();
-  $over = $u->copy();
-  $u *= $u; $v *= $v;				# u^2, v^2
-  $below->bmul($v);				# u^3, v^3
-  $over->bmul($u);
-  $factor = $self->new(3); $f = $self->new(2);
-
-  my $steps = 0;
-  $limit = $self->new("1E-". ($scale-1));
-  while (3 < 5)
-    {
-    # we calculate the next term, and add it to the last
-    # when the next term is below our limit, it won't affect the outcome
-    # anymore, so we stop
-
-    # calculating the next term simple from over/below will result in quite
-    # a time hog if the input has many digits, since over and below will
-    # accumulate more and more digits, and the result will also have many
-    # digits, but in the end it is rounded to $scale digits anyway. So if we
-    # round $over and $below first, we save a lot of time for the division
-    # (not with log(1.2345), but try log (123**123) to see what I mean. This
-    # can introduce a rounding error if the division result would be f.i.
-    # 0.1234500000001 and we round it to 5 digits it would become 0.12346, but
-    # if we truncated $over and $below we might get 0.12345. Does this matter
-    # for the end result? So we give $over and $below 4 more digits to be
-    # on the safe side (unscientific error handling as usual... :+D
-
-    $next = $over->copy->bround($scale+4)->bdiv(
-      $below->copy->bmul($factor)->bround($scale+4), 
-      $scale);
-
-## old version:    
-##    $next = $over->copy()->bdiv($below->copy()->bmul($factor),$scale);
-
-    last if $next->bacmp($limit) <= 0;
-
-    delete $next->{_a}; delete $next->{_p};
-    $x->badd($next);
-    # calculate things for the next term
-    $over *= $u; $below *= $v; $factor->badd($f);
-    if (DEBUG)
-      {
-      $steps++; print "step $steps = $x\n" if $steps % 10 == 0;
-      }
-    }
-  print "took $steps steps\n" if DEBUG;
-  $x->bmul($f);					# $x *= 2
-  }
-
-sub _log_10
-  {
-  # Internal log function based on reducing input to the range of 0.1 .. 9.99
-  # and then "correcting" the result to the proper one. Modifies $x in place.
-  my ($self,$x,$scale) = @_;
-
-  # Taking blog() from numbers greater than 10 takes a *very long* time, so we
-  # break the computation down into parts based on the observation that:
-  #  blog(X*Y) = blog(X) + blog(Y)
-  # We set Y here to multiples of 10 so that $x becomes below 1 - the smaller
-  # $x is the faster it gets. Since 2*$x takes about 10 times as
-  # long, we make it faster by about a factor of 100 by dividing $x by 10.
-
-  # The same observation is valid for numbers smaller than 0.1, e.g. computing
-  # log(1) is fastest, and the further away we get from 1, the longer it takes.
-  # So we also 'break' this down by multiplying $x with 10 and subtract the
-  # log(10) afterwards to get the correct result.
-
-  # To get $x even closer to 1, we also divide by 2 and then use log(2) to
-  # correct for this. For instance if $x is 2.4, we use the formula:
-  #  blog(2.4 * 2) == blog (1.2) + blog(2)
-  # and thus calculate only blog(1.2) and blog(2), which is faster in total
-  # than calculating blog(2.4).
-
-  # In addition, the values for blog(2) and blog(10) are cached.
-
-  # Calculate nr of digits before dot:
-  my $dbd = $MBI->_num($x->{_e});
-  $dbd = -$dbd if $x->{_es} eq '-';
-  $dbd += $MBI->_len($x->{_m});
-
-  # more than one digit (e.g. at least 10), but *not* exactly 10 to avoid
-  # infinite recursion
-
-  my $calc = 1;					# do some calculation?
-
-  # disable the shortcut for 10, since we need log(10) and this would recurse
-  # infinitely deep
-  if ($x->{_es} eq '+' && $MBI->_is_one($x->{_e}) && $MBI->_is_one($x->{_m}))
-    {
-    $dbd = 0;					# disable shortcut
-    # we can use the cached value in these cases
-    if ($scale <= $LOG_10_A)
-      {
-      $x->bzero(); $x->badd($LOG_10);		# modify $x in place
-      $calc = 0; 				# no need to calc, but round
-      }
-    # if we can't use the shortcut, we continue normally
-    }
-  else
-    {
-    # disable the shortcut for 2, since we maybe have it cached
-    if (($MBI->_is_zero($x->{_e}) && $MBI->_is_two($x->{_m})))
-      {
-      $dbd = 0;					# disable shortcut
-      # we can use the cached value in these cases
-      if ($scale <= $LOG_2_A)
-        {
-        $x->bzero(); $x->badd($LOG_2);		# modify $x in place
-        $calc = 0; 				# no need to calc, but round
+
+    if (!$MBI->_is_zero($x->{_e})) {
+        $x->{_m} = $MBI->_lsft($x->{_m}, $x->{_e}, 10); # 1e2 => 100
+        $x->{_e} = $MBI->_zero();                      # normalize
+        $x->{_es} = '+';
+    }
+    # now $x->{_e} == 0
+    my $zero = $x->is_zero();
+    # <= 0
+    if (($x->{sign} eq '-') || $zero) {
+        $MBI->_inc($x->{_m});
+        $x->{sign} = '-' if $zero;                # 0 => 1 => -1
+        $x->{sign} = '+' if $MBI->_is_zero($x->{_m}); # -1 +1 => -0 => +0
+        return $x->bnorm()->round(@r);
+    }
+    # > 0
+    elsif ($x->{sign} eq '+') {
+        $MBI->_dec($x->{_m});
+        return $x->bnorm()->round(@r);
+    }
+    # inf, nan handling etc
+    $x->badd($class->bone('-'), @r); # does round
+}
+
+sub badd {
+    # add second arg (BFLOAT or string) to first (BFLOAT) (modifies first)
+    # return result as BFLOAT
+
+    # set up parameters
+    my ($class, $x, $y, @r) = (ref($_[0]), @_);
+    # objectify is costly, so avoid it
+    if ((!ref($_[0])) || (ref($_[0]) ne ref($_[1]))) {
+        ($class, $x, $y, @r) = objectify(2, @_);
+    }
+
+    return $x if $x->modify('badd');
+
+    # inf and NaN handling
+    if (($x->{sign} !~ /^[+-]$/) || ($y->{sign} !~ /^[+-]$/)) {
+        # NaN first
+        return $x->bnan() if (($x->{sign} eq $nan) || ($y->{sign} eq $nan));
+        # inf handling
+        if (($x->{sign} =~ /^[+-]inf$/) && ($y->{sign} =~ /^[+-]inf$/)) {
+            # +inf++inf or -inf+-inf => same, rest is NaN
+            return $x if $x->{sign} eq $y->{sign};
+            return $x->bnan();
         }
-      # if we can't use the shortcut, we continue normally
-      }
+        # +-inf + something => +inf; something +-inf => +-inf
+        $x->{sign} = $y->{sign}, return $x if $y->{sign} =~ /^[+-]inf$/;
+        return $x;
     }
 
-  # if $x = 0.1, we know the result must be 0-log(10)
-  if ($calc != 0 && $x->{_es} eq '-' && $MBI->_is_one($x->{_e}) &&
-      $MBI->_is_one($x->{_m}))
+    return $upgrade->badd($x, $y, @r) if defined $upgrade &&
+      ((!$x->isa($class)) || (!$y->isa($class)));
+
+    $r[3] = $y;                 # no push!
+
+    # speed: no add for 0+y or x+0
+    return $x->bround(@r) if $y->is_zero(); # x+0
+    if ($x->is_zero())                      # 0+y
     {
-    $dbd = 0;					# disable shortcut
-    # we can use the cached value in these cases
-    if ($scale <= $LOG_10_A)
-      {
-      $x->bzero(); $x->bsub($LOG_10);
-      $calc = 0; 				# no need to calc, but round
-      }
+        # make copy, clobbering up x (modify in place!)
+        $x->{_e} = $MBI->_copy($y->{_e});
+        $x->{_es} = $y->{_es};
+        $x->{_m} = $MBI->_copy($y->{_m});
+        $x->{sign} = $y->{sign} || $nan;
+        return $x->round(@r);
     }
 
-  return if $calc == 0;				# already have the result
+    # take lower of the two e's and adapt m1 to it to match m2
+    my $e = $y->{_e};
+    $e = $MBI->_zero() if !defined $e; # if no BFLOAT?
+    $e = $MBI->_copy($e);              # make copy (didn't do it yet)
 
-  # default: these correction factors are undef and thus not used
-  my $l_10;				# value of ln(10) to A of $scale
-  my $l_2;				# value of ln(2) to A of $scale
+    my $es;
 
-  my $two = $self->new(2);
+    ($e, $es) = _e_sub($e, $x->{_e}, $y->{_es} || '+', $x->{_es});
 
-  # $x == 2 => 1, $x == 13 => 2, $x == 0.1 => 0, $x == 0.01 => -1
-  # so don't do this shortcut for 1 or 0
-  if (($dbd > 1) || ($dbd < 0))
-    {
-    # convert our cached value to an object if not already (avoid doing this
-    # at import() time, since not everybody needs this)
-    $LOG_10 = $self->new($LOG_10,undef,undef) unless ref $LOG_10;
-
-    #print "x = $x, dbd = $dbd, calc = $calc\n";
-    # got more than one digit before the dot, or more than one zero after the
-    # dot, so do:
-    #  log(123)    == log(1.23) + log(10) * 2
-    #  log(0.0123) == log(1.23) - log(10) * 2
-  
-    if ($scale <= $LOG_10_A)
-      {
-      # use cached value
-      $l_10 = $LOG_10->copy();		# copy for mul
-      }
-    else
-      {
-      # else: slower, compute and cache result
-      # also disable downgrade for this code path
-      local $Math::BigFloat::downgrade = undef;
-
-      # shorten the time to calculate log(10) based on the following:
-      # log(1.25 * 8) = log(1.25) + log(8)
-      #               = log(1.25) + log(2) + log(2) + log(2)
-
-      # first get $l_2 (and possible compute and cache log(2))
-      $LOG_2 = $self->new($LOG_2,undef,undef) unless ref $LOG_2;
-      if ($scale <= $LOG_2_A)
-        {
-        # use cached value
-        $l_2 = $LOG_2->copy();			# copy() for the mul below
-        }
-      else
-        {
-        # else: slower, compute and cache result
-        $l_2 = $two->copy(); $self->_log($l_2, $scale); # scale+4, actually
-        $LOG_2 = $l_2->copy();			# cache the result for later
-						# the copy() is for mul below
-        $LOG_2_A = $scale;
-        }
+    my $add = $MBI->_copy($y->{_m});
 
-      # now calculate log(1.25):
-      $l_10 = $self->new('1.25'); $self->_log($l_10, $scale); # scale+4, actually
-
-      # log(1.25) + log(2) + log(2) + log(2):
-      $l_10->badd($l_2);
-      $l_10->badd($l_2);
-      $l_10->badd($l_2);
-      $LOG_10 = $l_10->copy();		# cache the result for later
-					# the copy() is for mul below
-      $LOG_10_A = $scale;
-      }
-    $dbd-- if ($dbd > 1); 		# 20 => dbd=2, so make it dbd=1	
-    $l_10->bmul( $self->new($dbd));	# log(10) * (digits_before_dot-1)
-    my $dbd_sign = '+';
-    if ($dbd < 0)
-      {
-      $dbd = -$dbd;
-      $dbd_sign = '-';
-      }
-    ($x->{_e}, $x->{_es}) = 
-	_e_sub( $x->{_e}, $MBI->_new($dbd), $x->{_es}, $dbd_sign); # 123 => 1.23
- 
-    }
-
-  # Now: 0.1 <= $x < 10 (and possible correction in l_10)
-
-  ### Since $x in the range 0.5 .. 1.5 is MUCH faster, we do a repeated div
-  ### or mul by 2 (maximum times 3, since x < 10 and x > 0.1)
-
-  $HALF = $self->new($HALF) unless ref($HALF);
-
-  my $twos = 0;				# default: none (0 times)	
-  while ($x->bacmp($HALF) <= 0)		# X <= 0.5
+    if ($es eq '-')             # < 0
     {
-    $twos--; $x->bmul($two);
-    }
-  while ($x->bacmp($two) >= 0)		# X >= 2
+        $MBI->_lsft($x->{_m}, $e, 10);
+        ($x->{_e}, $x->{_es}) = _e_add($x->{_e}, $e, $x->{_es}, $es);
+    } elsif (!$MBI->_is_zero($e)) # > 0
     {
-    $twos++; $x->bdiv($two,$scale+4);		# keep all digits
+        $MBI->_lsft($add, $e, 10);
     }
-  $x->bround($scale+4);
-  # $twos > 0 => did mul 2, < 0 => did div 2 (but we never did both)
-  # So calculate correction factor based on ln(2):
-  if ($twos != 0)
-    {
-    $LOG_2 = $self->new($LOG_2,undef,undef) unless ref $LOG_2;
-    if ($scale <= $LOG_2_A)
-      {
-      # use cached value
-      $l_2 = $LOG_2->copy();			# copy() for the mul below
-      }
-    else
-      {
-      # else: slower, compute and cache result
-      # also disable downgrade for this code path
-      local $Math::BigFloat::downgrade = undef;
-      $l_2 = $two->copy(); $self->_log($l_2, $scale); # scale+4, actually
-      $LOG_2 = $l_2->copy();			# cache the result for later
-						# the copy() is for mul below
-      $LOG_2_A = $scale;
-      }
-    $l_2->bmul($twos);		# * -2 => subtract, * 2 => add
-    }
-  else
-    {
-      undef $l_2;
-    }
-  
-  $self->_log($x,$scale);			# need to do the "normal" way
-  $x->badd($l_10) if defined $l_10; 		# correct it by ln(10)
-  $x->badd($l_2) if defined $l_2;		# and maybe by ln(2)
-
-  # all done, $x contains now the result
-  $x;
-  }
-
-sub blcm 
-  { 
-  # (BFLOAT or num_str, BFLOAT or num_str) return BFLOAT
-  # does not modify arguments, but returns new object
-  # Lowest Common Multiplicator
-
-  my ($self,@arg) = objectify(0,@_);
-  my $x = $self->new(shift @arg);
-  while (@arg) { $x = Math::BigInt::__lcm($x,shift @arg); } 
-  $x;
-  }
-
-sub bgcd
-  {
-  # (BINT or num_str, BINT or num_str) return BINT
-  # does not modify arguments, but returns new object
-
-  my $y = shift;
-  $y = __PACKAGE__->new($y) if !ref($y);
-  my $self = ref($y);
-  my $x = $y->copy()->babs();			# keep arguments
-
-  return $x->bnan() if $x->{sign} !~ /^[+-]$/	# x NaN?
-	|| !$x->is_int();			# only for integers now
-
-  while (@_)
-    {
-    my $t = shift; $t = $self->new($t) if !ref($t);
-    $y = $t->copy()->babs();
-    
-    return $x->bnan() if $y->{sign} !~ /^[+-]$/	# y NaN?
-     	|| !$y->is_int();			# only for integers now
+    # else: both e are the same, so just leave them
 
-    # greatest common divisor
-    while (! $y->is_zero())
-      {
-      ($x,$y) = ($y->copy(), $x->copy()->bmod($y));
-      }
-
-    last if $x->is_one();
+    if ($x->{sign} eq $y->{sign}) {
+        # add
+        $x->{_m} = $MBI->_add($x->{_m}, $add);
+    } else {
+        ($x->{_m}, $x->{sign}) =
+          _e_add($x->{_m}, $add, $x->{sign}, $y->{sign});
     }
-  $x;
-  }
 
-##############################################################################
+    # delete trailing zeros, then round
+    $x->bnorm()->round(@r);
+}
 
-sub _e_add {
-    # Internal helper sub to take two positive integers and their signs and
-    # then add them. Input ($CALC, $CALC, ('+'|'-'), ('+'|'-')), output
-    # ($CALC, ('+'|'-')).
+sub bsub {
+    # (BINT or num_str, BINT or num_str) return BINT
+    # subtract second arg from first, modify first
 
-    my ($x, $y, $xs, $ys) = @_;
+    # set up parameters
+    my ($class, $x, $y, @r) = (ref($_[0]), @_);
 
-    # if the signs are equal we can add them (-5 + -3 => -(5 + 3) => -8)
-    if ($xs eq $ys) {
-        $x = $MBI->_add($x, $y);                # +a + +b or -a + -b
-    } else {
-        my $a = $MBI->_acmp($x, $y);
-        if ($a == 0) {
-            # This does NOT modify $x in-place. TODO: Fix this?
-            $x = $MBI->_zero();                 # result is 0
-            $xs = '+';
-            return ($x, $xs);
-        }
-        if ($a > 0) {
-            $x = $MBI->_sub($x, $y);            # abs sub
-        } else {                                # a < 0
-            $x = $MBI->_sub ( $y, $x, 1 );      # abs sub
-            $xs = $ys;
-        }
+    # objectify is costly, so avoid it
+    if ((!ref($_[0])) || (ref($_[0]) ne ref($_[1]))) {
+        ($class, $x, $y, @r) = objectify(2, @_);
     }
 
-    $xs = '+' if $xs eq '-' && $MBI->_is_zero($x);      # no "-0"
+    return $x if $x -> modify('bsub');
 
-    return ($x, $xs);
+    return $upgrade -> new($x) -> bsub($upgrade -> new($y), @r)
+      if defined $upgrade && (!$x -> isa($class) || !$y -> isa($class));
+
+    return $x -> round(@r) if $y -> is_zero();
+
+    # To correctly handle the lone special case $x -> bsub($x), we note the
+    # sign of $x, then flip the sign from $y, and if the sign of $x did change,
+    # too, then we caught the special case:
+
+    my $xsign = $x -> {sign};
+    $y -> {sign} =~ tr/+-/-+/;  # does nothing for NaN
+    if ($xsign ne $x -> {sign}) {
+        # special case of $x -> bsub($x) results in 0
+        return $x -> bzero(@r) if $xsign =~ /^[+-]$/;
+        return $x -> bnan();    # NaN, -inf, +inf
+    }
+    $x -> badd($y, @r);         # badd does not leave internal zeros
+    $y -> {sign} =~ tr/+-/-+/;  # refix $y (does nothing for NaN)
+    $x;                         # already rounded by badd() or no rounding
 }
 
-sub _e_sub {
-  # Internal helper sub to take two positive integers and their signs and
-  # then subtract them. Input ($CALC,$CALC,('+'|'-'),('+'|'-')), 
-  # output ($CALC,('+'|'-'))
-  my ($x,$y,$xs,$ys) = @_;
+sub bmul {
+    # multiply two numbers
 
-  # flip sign
-    $ys = $ys eq '+' ? '-' : '+';       # swap sign of second operand ...
-    _e_add($x, $y, $xs, $ys);           # ... and let _e_add() do the job
-  }
+    # set up parameters
+    my ($class, $x, $y, @r) = (ref($_[0]), @_);
+    # objectify is costly, so avoid it
+    if ((!ref($_[0])) || (ref($_[0]) ne ref($_[1]))) {
+        ($class, $x, $y, @r) = objectify(2, @_);
+    }
 
-###############################################################################
-# is_foo methods (is_negative, is_positive are inherited from BigInt)
-
-sub is_int
-  {
-  # return true if arg (BFLOAT or num_str) is an integer
-  my ($self,$x) = ref($_[0]) ? (undef,$_[0]) : objectify(1,@_);
-
-  (($x->{sign} =~ /^[+-]$/) &&			# NaN and +-inf aren't
-   ($x->{_es} eq '+')) ? 1 : 0;			# 1e-1 => no integer
-  }
-
-sub is_zero
-  {
-  # return true if arg (BFLOAT or num_str) is zero
-  my ($self,$x) = ref($_[0]) ? (undef,$_[0]) : objectify(1,@_);
-
-  ($x->{sign} eq '+' && $MBI->_is_zero($x->{_m})) ? 1 : 0;
-  }
-
-sub is_one
-  {
-  # return true if arg (BFLOAT or num_str) is +1 or -1 if signis given
-  my ($self,$x,$sign) = ref($_[0]) ? (undef,@_) : objectify(1,@_);
-
-  $sign = '+' if !defined $sign || $sign ne '-';
-
-  ($x->{sign} eq $sign && 
-   $MBI->_is_zero($x->{_e}) &&
-   $MBI->_is_one($x->{_m}) ) ? 1 : 0; 
-  }
-
-sub is_odd
-  {
-  # return true if arg (BFLOAT or num_str) is odd or false if even
-  my ($self,$x) = ref($_[0]) ? (undef,$_[0]) : objectify(1,@_);
-  
-  (($x->{sign} =~ /^[+-]$/) &&		# NaN & +-inf aren't
-   ($MBI->_is_zero($x->{_e})) &&
-   ($MBI->_is_odd($x->{_m}))) ? 1 : 0; 
-  }
-
-sub is_even
-  {
-  # return true if arg (BINT or num_str) is even or false if odd
-  my ($self,$x) = ref($_[0]) ? (undef,$_[0]) : objectify(1,@_);
-
-  (($x->{sign} =~ /^[+-]$/) &&			# NaN & +-inf aren't
-   ($x->{_es} eq '+') &&	 		# 123.45 isn't
-   ($MBI->_is_even($x->{_m}))) ? 1 : 0;		# but 1200 is
-  }
-
-sub bmul
-  { 
-  # multiply two numbers
-  
-  # set up parameters
-  my ($self,$x,$y,@r) = (ref($_[0]),@_);
-  # objectify is costly, so avoid it
-  if ((!ref($_[0])) || (ref($_[0]) ne ref($_[1])))
-    {
-    ($self,$x,$y,@r) = objectify(2,@_);
+    return $x if $x->modify('bmul');
+
+    return $x->bnan() if (($x->{sign} eq $nan) || ($y->{sign} eq $nan));
+
+    # inf handling
+    if (($x->{sign} =~ /^[+-]inf$/) || ($y->{sign} =~ /^[+-]inf$/)) {
+        return $x->bnan() if $x->is_zero() || $y->is_zero();
+        # result will always be +-inf:
+        # +inf * +/+inf => +inf, -inf * -/-inf => +inf
+        # +inf * -/-inf => -inf, -inf * +/+inf => -inf
+        return $x->binf() if ($x->{sign} =~ /^\+/ && $y->{sign} =~ /^\+/);
+        return $x->binf() if ($x->{sign} =~ /^-/ && $y->{sign} =~ /^-/);
+        return $x->binf('-');
     }
 
-  return $x if $x->modify('bmul');
+    return $upgrade->bmul($x, $y, @r) if defined $upgrade &&
+      ((!$x->isa($class)) || (!$y->isa($class)));
 
-  return $x->bnan() if (($x->{sign} eq $nan) || ($y->{sign} eq $nan));
+    # aEb * cEd = (a*c)E(b+d)
+    $MBI->_mul($x->{_m}, $y->{_m});
+    ($x->{_e}, $x->{_es}) = _e_add($x->{_e}, $y->{_e}, $x->{_es}, $y->{_es});
 
-  # inf handling
-  if (($x->{sign} =~ /^[+-]inf$/) || ($y->{sign} =~ /^[+-]inf$/))
-    {
-    return $x->bnan() if $x->is_zero() || $y->is_zero(); 
-    # result will always be +-inf:
-    # +inf * +/+inf => +inf, -inf * -/-inf => +inf
-    # +inf * -/-inf => -inf, -inf * +/+inf => -inf
-    return $x->binf() if ($x->{sign} =~ /^\+/ && $y->{sign} =~ /^\+/);
-    return $x->binf() if ($x->{sign} =~ /^-/ && $y->{sign} =~ /^-/);
-    return $x->binf('-');
-    }
-  
-  return $upgrade->bmul($x,$y,@r) if defined $upgrade &&
-   ((!$x->isa($self)) || (!$y->isa($self)));
-
-  # aEb * cEd = (a*c)E(b+d)
-  $MBI->_mul($x->{_m},$y->{_m});
-  ($x->{_e}, $x->{_es}) = _e_add($x->{_e}, $y->{_e}, $x->{_es}, $y->{_es});
-
-  $r[3] = $y;				# no push!
-
-  # adjust sign:
-  $x->{sign} = $x->{sign} ne $y->{sign} ? '-' : '+';
-  $x->bnorm->round(@r);
-  }
-
-sub bmuladd
-  { 
-  # multiply two numbers and add the third to the result
-  
-  # set up parameters
-  my ($self,$x,$y,$z,@r) = objectify(3,@_);
-
-  return $x if $x->modify('bmuladd');
-
-  return $x->bnan() if (($x->{sign} eq $nan) ||
-			($y->{sign} eq $nan) ||
-			($z->{sign} eq $nan));
-
-  # inf handling
-  if (($x->{sign} =~ /^[+-]inf$/) || ($y->{sign} =~ /^[+-]inf$/))
-    {
-    return $x->bnan() if $x->is_zero() || $y->is_zero(); 
-    # result will always be +-inf:
-    # +inf * +/+inf => +inf, -inf * -/-inf => +inf
-    # +inf * -/-inf => -inf, -inf * +/+inf => -inf
-    return $x->binf() if ($x->{sign} =~ /^\+/ && $y->{sign} =~ /^\+/);
-    return $x->binf() if ($x->{sign} =~ /^-/ && $y->{sign} =~ /^-/);
-    return $x->binf('-');
+    $r[3] = $y;                 # no push!
+
+    # adjust sign:
+    $x->{sign} = $x->{sign} ne $y->{sign} ? '-' : '+';
+    $x->bnorm->round(@r);
+}
+
+sub bmuladd {
+    # multiply two numbers and add the third to the result
+
+    # set up parameters
+    my ($class, $x, $y, $z, @r) = objectify(3, @_);
+
+    return $x if $x->modify('bmuladd');
+
+    return $x->bnan() if (($x->{sign} eq $nan) ||
+                          ($y->{sign} eq $nan) ||
+                          ($z->{sign} eq $nan));
+
+    # inf handling
+    if (($x->{sign} =~ /^[+-]inf$/) || ($y->{sign} =~ /^[+-]inf$/)) {
+        return $x->bnan() if $x->is_zero() || $y->is_zero();
+        # result will always be +-inf:
+        # +inf * +/+inf => +inf, -inf * -/-inf => +inf
+        # +inf * -/-inf => -inf, -inf * +/+inf => -inf
+        return $x->binf() if ($x->{sign} =~ /^\+/ && $y->{sign} =~ /^\+/);
+        return $x->binf() if ($x->{sign} =~ /^-/ && $y->{sign} =~ /^-/);
+        return $x->binf('-');
     }
 
-  return $upgrade->bmul($x,$y,@r) if defined $upgrade &&
-   ((!$x->isa($self)) || (!$y->isa($self)));
+    return $upgrade->bmul($x, $y, @r) if defined $upgrade &&
+      ((!$x->isa($class)) || (!$y->isa($class)));
 
-  # aEb * cEd = (a*c)E(b+d)
-  $MBI->_mul($x->{_m},$y->{_m});
-  ($x->{_e}, $x->{_es}) = _e_add($x->{_e}, $y->{_e}, $x->{_es}, $y->{_es});
+    # aEb * cEd = (a*c)E(b+d)
+    $MBI->_mul($x->{_m}, $y->{_m});
+    ($x->{_e}, $x->{_es}) = _e_add($x->{_e}, $y->{_e}, $x->{_es}, $y->{_es});
 
-  $r[3] = $y;				# no push!
+    $r[3] = $y;                 # no push!
 
-  # adjust sign:
-  $x->{sign} = $x->{sign} ne $y->{sign} ? '-' : '+';
+    # adjust sign:
+    $x->{sign} = $x->{sign} ne $y->{sign} ? '-' : '+';
 
-  # z=inf handling (z=NaN handled above)
-  $x->{sign} = $z->{sign}, return $x if $z->{sign} =~ /^[+-]inf$/;
+    # z=inf handling (z=NaN handled above)
+    $x->{sign} = $z->{sign}, return $x if $z->{sign} =~ /^[+-]inf$/;
 
-  # take lower of the two e's and adapt m1 to it to match m2
-  my $e = $z->{_e};
-  $e = $MBI->_zero() if !defined $e;		# if no BFLOAT?
-  $e = $MBI->_copy($e);				# make copy (didn't do it yet)
+    # take lower of the two e's and adapt m1 to it to match m2
+    my $e = $z->{_e};
+    $e = $MBI->_zero() if !defined $e; # if no BFLOAT?
+    $e = $MBI->_copy($e);              # make copy (didn't do it yet)
 
-  my $es;
+    my $es;
 
-  ($e,$es) = _e_sub($e, $x->{_e}, $z->{_es} || '+', $x->{_es});
+    ($e, $es) = _e_sub($e, $x->{_e}, $z->{_es} || '+', $x->{_es});
 
-  my $add = $MBI->_copy($z->{_m});
+    my $add = $MBI->_copy($z->{_m});
 
-  if ($es eq '-')				# < 0
+    if ($es eq '-')             # < 0
     {
-    $MBI->_lsft( $x->{_m}, $e, 10);
-    ($x->{_e},$x->{_es}) = _e_add($x->{_e}, $e, $x->{_es}, $es);
-    }
-  elsif (!$MBI->_is_zero($e))			# > 0
+        $MBI->_lsft($x->{_m}, $e, 10);
+        ($x->{_e}, $x->{_es}) = _e_add($x->{_e}, $e, $x->{_es}, $es);
+    } elsif (!$MBI->_is_zero($e)) # > 0
     {
-    $MBI->_lsft($add, $e, 10);
+        $MBI->_lsft($add, $e, 10);
     }
-  # else: both e are the same, so just leave them
+    # else: both e are the same, so just leave them
 
-  if ($x->{sign} eq $z->{sign})
-    {
-    # add
-    $x->{_m} = $MBI->_add($x->{_m}, $add);
-    }
-  else
-    {
-    ($x->{_m}, $x->{sign}) = 
-     _e_add($x->{_m}, $add, $x->{sign}, $z->{sign});
+    if ($x->{sign} eq $z->{sign}) {
+        # add
+        $x->{_m} = $MBI->_add($x->{_m}, $add);
+    } else {
+        ($x->{_m}, $x->{sign}) =
+          _e_add($x->{_m}, $add, $x->{sign}, $z->{sign});
     }
 
-  # delete trailing zeros, then round
-  $x->bnorm()->round(@r);
-  }
+    # delete trailing zeros, then round
+    $x->bnorm()->round(@r);
+}
 
-sub bdiv 
-  {
-  # (dividend: BFLOAT or num_str, divisor: BFLOAT or num_str) return 
+sub bdiv {
+    # (dividend: BFLOAT or num_str, divisor: BFLOAT or num_str) return
     # (BFLOAT, BFLOAT) (quo, rem) or BFLOAT (only quo)
 
-  # set up parameters
-  my ($self,$x,$y,$a,$p,$r) = (ref($_[0]),@_);
-  # objectify is costly, so avoid it
-  if ((!ref($_[0])) || (ref($_[0]) ne ref($_[1])))
-    {
-    ($self,$x,$y,$a,$p,$r) = objectify(2,@_);
+    # set up parameters
+    my ($class, $x, $y, $a, $p, $r) = (ref($_[0]), @_);
+    # objectify is costly, so avoid it
+    if ((!ref($_[0])) || (ref($_[0]) ne ref($_[1]))) {
+        ($class, $x, $y, $a, $p, $r) = objectify(2, @_);
     }
 
-  return $x if $x->modify('bdiv');
+    return $x if $x->modify('bdiv');
 
-    my $wantarray = wantarray;          # call only once
+    my $wantarray = wantarray;  # call only once
 
     # At least one argument is NaN. This is handled the same way as in
     # Math::BigInt -> bdiv().
 
     if ($x -> is_nan() || $y -> is_nan()) {
-        return $wantarray ? ($x -> bnan(), $self -> bnan()) : $x -> bnan();
+        return $wantarray ? ($x -> bnan(), $class -> bnan()) : $x -> bnan();
     }
 
     # Divide by zero and modulo zero. This is handled the same way as in
@@ -1899,7 +1778,7 @@ sub bdiv
 
     if ($x -> is_inf()) {
         my ($quo, $rem);
-        $rem = $self -> bnan() if $wantarray;
+        $rem = $class -> bnan() if $wantarray;
         if ($y -> is_inf()) {
             $quo = $x -> bnan();
         } else {
@@ -1909,180 +1788,165 @@ sub bdiv
         return $wantarray ? ($quo, $rem) : $quo;
     }
 
-  # Denominator (divisor) is +/-inf. This is handled the same way as in
-  # Math::BigInt -> bdiv(), with one exception: In scalar context,
-  # Math::BigFloat does true division (although rounded), not floored division
-  # (F-division), so a finite number divided by +/-inf is always zero. See the
-  # comment in the code for Math::BigInt -> bdiv() for further details.
-
-  if ($y -> is_inf()) {
-      my ($quo, $rem);
-      if ($wantarray) {
-          if ($x -> is_zero() || $x -> bcmp(0) == $y -> bcmp(0)) {
-              $rem = $x -> copy();
-              $quo = $x -> bzero();
-          } else {
-              $rem = $self -> binf($y -> {sign});
-              $quo = $x -> bone('-');
-          }
-          return ($quo, $rem);
-      } else {
-        if ($y -> is_inf()) {
-            if ($x -> is_nan() || $x -> is_inf()) {
-                return $x -> bnan();
+    # Denominator (divisor) is +/-inf. This is handled the same way as in
+    # Math::BigInt -> bdiv(), with one exception: In scalar context,
+    # Math::BigFloat does true division (although rounded), not floored division
+    # (F-division), so a finite number divided by +/-inf is always zero. See the
+    # comment in the code for Math::BigInt -> bdiv() for further details.
+
+    if ($y -> is_inf()) {
+        my ($quo, $rem);
+        if ($wantarray) {
+            if ($x -> is_zero() || $x -> bcmp(0) == $y -> bcmp(0)) {
+                $rem = $x -> copy();
+                $quo = $x -> bzero();
             } else {
-                return $x -> bzero();
+                $rem = $class -> binf($y -> {sign});
+                $quo = $x -> bone('-');
+            }
+            return ($quo, $rem);
+        } else {
+            if ($y -> is_inf()) {
+                if ($x -> is_nan() || $x -> is_inf()) {
+                    return $x -> bnan();
+                } else {
+                    return $x -> bzero();
+                }
             }
         }
     }
-    }
 
-  # At this point, both the numerator and denominator are finite numbers, and
-  # the denominator (divisor) is non-zero.
+    # At this point, both the numerator and denominator are finite numbers, and
+    # the denominator (divisor) is non-zero.
 
-  # x == 0?
-  return wantarray ? ($x,$self->bzero()) : $x if $x->is_zero();
+    # x == 0?
+    return wantarray ? ($x, $class->bzero()) : $x if $x->is_zero();
 
-  # upgrade ?
-  return $upgrade->bdiv($upgrade->new($x),$y,$a,$p,$r) if defined $upgrade;
+    # upgrade ?
+    return $upgrade->bdiv($upgrade->new($x), $y, $a, $p, $r) if defined $upgrade;
 
-  # we need to limit the accuracy to protect against overflow
-  my $fallback = 0;
-  my (@params,$scale);
-  ($x,@params) = $x->_find_round_parameters($a,$p,$r,$y);
+    # we need to limit the accuracy to protect against overflow
+    my $fallback = 0;
+    my (@params, $scale);
+    ($x, @params) = $x->_find_round_parameters($a, $p, $r, $y);
 
-  return $x if $x->is_nan();		# error in _find_round_parameters?
+    return $x if $x->is_nan();  # error in _find_round_parameters?
 
-  # no rounding at all, so must use fallback
-    if (scalar @params == 0)
-    {
-    # simulate old behaviour
-    $params[0] = $self->div_scale();	# and round to it as accuracy
-    $scale = $params[0]+4; 		# at least four more for proper round
-    $params[2] = $r;			# round mode by caller or undef
-    $fallback = 1;			# to clear a/p afterwards
+    # no rounding at all, so must use fallback
+    if (scalar @params == 0) {
+        # simulate old behaviour
+        $params[0] = $class->div_scale(); # and round to it as accuracy
+        $scale = $params[0]+4;            # at least four more for proper round
+        $params[2] = $r;                  # round mode by caller or undef
+        $fallback = 1;                    # to clear a/p afterwards
     } else {
-    # the 4 below is empirical, and there might be cases where it is not
-    # enough...
-    $scale = abs($params[0] || $params[1]) + 4;	# take whatever is defined
+        # the 4 below is empirical, and there might be cases where it is not
+        # enough...
+        $scale = abs($params[0] || $params[1]) + 4; # take whatever is defined
     }
 
     my $rem;
-    $rem = $self -> bzero() if wantarray;
-
-  $y = $self->new($y) unless $y->isa('Math::BigFloat');
+    $rem = $class -> bzero() if wantarray;
 
-  my $lx = $MBI -> _len($x->{_m}); my $ly = $MBI -> _len($y->{_m});
-  $scale = $lx if $lx > $scale;
-  $scale = $ly if $ly > $scale;
-  my $diff = $ly - $lx;
-  $scale += $diff if $diff > 0;		# if lx << ly, but not if ly << lx!
+    $y = $class->new($y) unless $y->isa('Math::BigFloat');
 
-  # check that $y is not 1 nor -1 and cache the result:
-  my $y_not_one = !($MBI->_is_zero($y->{_e}) && $MBI->_is_one($y->{_m}));
+    my $lx = $MBI -> _len($x->{_m}); my $ly = $MBI -> _len($y->{_m});
+    $scale = $lx if $lx > $scale;
+    $scale = $ly if $ly > $scale;
+    my $diff = $ly - $lx;
+    $scale += $diff if $diff > 0; # if lx << ly, but not if ly << lx!
 
-  # flipping the sign of $y will also flip the sign of $x for the special
-  # case of $x->bsub($x); so we can catch it below:
-  my $xsign = $x->{sign};
-  $y->{sign} =~ tr/+-/-+/;
+    # check that $y is not 1 nor -1 and cache the result:
+    my $y_not_one = !($MBI->_is_zero($y->{_e}) && $MBI->_is_one($y->{_m}));
 
-  if ($xsign ne $x->{sign})
-    {
-    # special case of $x /= $x results in 1
-    $x->bone();			# "fixes" also sign of $y, since $x is $y
-    }
-  else
-    {
-    # correct $y's sign again
+    # flipping the sign of $y will also flip the sign of $x for the special
+    # case of $x->bsub($x); so we can catch it below:
+    my $xsign = $x->{sign};
     $y->{sign} =~ tr/+-/-+/;
-    # continue with normal div code:
-
-    # make copy of $x in case of list context for later remainder calculation
-    if (wantarray && $y_not_one)
-      {
-      $rem = $x->copy();
-      }
-
-    $x->{sign} = $x->{sign} ne $y->sign() ? '-' : '+'; 
-
-    # check for / +-1 ( +/- 1E0)
-    if ($y_not_one)
-      {
-      # promote BigInts and it's subclasses (except when already a BigFloat)
-      $y = $self->new($y) unless $y->isa('Math::BigFloat'); 
-
-      # calculate the result to $scale digits and then round it
-      # a * 10 ** b / c * 10 ** d => a/c * 10 ** (b-d)
-      $MBI->_lsft($x->{_m},$MBI->_new($scale),10);
-      $MBI->_div ($x->{_m},$y->{_m});	# a/c
-
-      # correct exponent of $x
-      ($x->{_e},$x->{_es}) = _e_sub($x->{_e}, $y->{_e}, $x->{_es}, $y->{_es});
-      # correct for 10**scale
-      ($x->{_e},$x->{_es}) = _e_sub($x->{_e}, $MBI->_new($scale), $x->{_es}, '+');
-      $x->bnorm();		# remove trailing 0's
-      }
-    } # end else $x != $y
-
-  # shortcut to not run through _find_round_parameters again
-  if (defined $params[0])
-    {
-    delete $x->{_a}; 				# clear before round
-    $x->bround($params[0],$params[2]);		# then round accordingly
+
+    if ($xsign ne $x->{sign}) {
+        # special case of $x /= $x results in 1
+        $x->bone();             # "fixes" also sign of $y, since $x is $y
+    } else {
+        # correct $y's sign again
+        $y->{sign} =~ tr/+-/-+/;
+        # continue with normal div code:
+
+        # make copy of $x in case of list context for later remainder calculation
+        if (wantarray && $y_not_one) {
+            $rem = $x->copy();
+        }
+
+        $x->{sign} = $x->{sign} ne $y->sign() ? '-' : '+';
+
+        # check for / +-1 (+/- 1E0)
+        if ($y_not_one) {
+            # promote BigInts and it's subclasses (except when already a Math::BigFloat)
+            $y = $class->new($y) unless $y->isa('Math::BigFloat');
+
+            # calculate the result to $scale digits and then round it
+            # a * 10 ** b / c * 10 ** d => a/c * 10 ** (b-d)
+            $MBI->_lsft($x->{_m}, $MBI->_new($scale), 10);
+            $MBI->_div($x->{_m}, $y->{_m}); # a/c
+
+            # correct exponent of $x
+            ($x->{_e}, $x->{_es}) = _e_sub($x->{_e}, $y->{_e}, $x->{_es}, $y->{_es});
+            # correct for 10**scale
+            ($x->{_e}, $x->{_es}) = _e_sub($x->{_e}, $MBI->_new($scale), $x->{_es}, '+');
+            $x->bnorm();        # remove trailing 0's
+        }
+    }                           # end else $x != $y
+
+    # shortcut to not run through _find_round_parameters again
+    if (defined $params[0]) {
+        delete $x->{_a};               # clear before round
+        $x->bround($params[0], $params[2]); # then round accordingly
+    } else {
+        delete $x->{_p};                # clear before round
+        $x->bfround($params[1], $params[2]); # then round accordingly
     }
-  else
-    {
-    delete $x->{_p}; 				# clear before round
-    $x->bfround($params[1],$params[2]);		# then round accordingly
+    if ($fallback) {
+        # clear a/p after round, since user did not request it
+        delete $x->{_a}; delete $x->{_p};
     }
-  if ($fallback)
-    {
-    # clear a/p after round, since user did not request it
-    delete $x->{_a}; delete $x->{_p};
+
+    if (wantarray) {
+        if ($y_not_one) {
+            $x -> bfloor();
+            $rem->bmod($y, @params); # copy already done
+        }
+        if ($fallback) {
+            # clear a/p after round, since user did not request it
+            delete $rem->{_a}; delete $rem->{_p};
+        }
+        return ($x, $rem);
     }
+    $x;
+}
 
-  if (wantarray)
-    {
-    if ($y_not_one)
-      {
-      $x -> bfloor();
-      $rem->bmod($y,@params);			# copy already done
-      }
-    if ($fallback)
-      {
-      # clear a/p after round, since user did not request it
-      delete $rem->{_a}; delete $rem->{_p};
-      }
-    return ($x,$rem);
-    }
-  $x;
-  }
-
-sub bmod 
-  {
-  # (dividend: BFLOAT or num_str, divisor: BFLOAT or num_str) return remainder
-
-  # set up parameters
-  my ($self,$x,$y,$a,$p,$r) = (ref($_[0]),@_);
-  # objectify is costly, so avoid it
-  if ((!ref($_[0])) || (ref($_[0]) ne ref($_[1])))
-    {
-    ($self,$x,$y,$a,$p,$r) = objectify(2,@_);
+sub bmod {
+    # (dividend: BFLOAT or num_str, divisor: BFLOAT or num_str) return remainder
+
+    # set up parameters
+    my ($class, $x, $y, $a, $p, $r) = (ref($_[0]), @_);
+    # objectify is costly, so avoid it
+    if ((!ref($_[0])) || (ref($_[0]) ne ref($_[1]))) {
+        ($class, $x, $y, $a, $p, $r) = objectify(2, @_);
     }
 
-  return $x if $x->modify('bmod');
+    return $x if $x->modify('bmod');
 
     # At least one argument is NaN. This is handled the same way as in
     # Math::BigInt -> bmod().
 
     if ($x -> is_nan() || $y -> is_nan()) {
         return $x -> bnan();
-    } 
+    }
 
     # Modulo zero. This is handled the same way as in Math::BigInt -> bmod().
 
     if ($y -> is_zero()) {
-    return $x;
+        return $x;
     }
 
     # Numerator (dividend) is +/-inf. This is handled the same way as in
@@ -2103,1210 +1967,705 @@ sub bmod
         }
     }
 
-  return $x->bzero() if $x->is_zero()
- || ($x->is_int() &&
-  # check that $y == +1 or $y == -1:
-    ($MBI->_is_zero($y->{_e}) && $MBI->_is_one($y->{_m})));
+    return $x->bzero() if $x->is_zero()
+      || ($x->is_int() &&
+          # check that $y == +1 or $y == -1:
+          ($MBI->_is_zero($y->{_e}) && $MBI->_is_one($y->{_m})));
 
-  my $cmp = $x->bacmp($y);			# equal or $x < $y?
-    if ($cmp == 0) {                            # $x == $y => result 0
+    my $cmp = $x->bacmp($y);    # equal or $x < $y?
+    if ($cmp == 0) {            # $x == $y => result 0
         return $x -> bzero($a, $p);
     }
 
-  # only $y of the operands negative? 
+    # only $y of the operands negative?
     my $neg = $x->{sign} ne $y->{sign} ? 1 : 0;
 
-  $x->{sign} = $y->{sign};				# calc sign first
-    if ($cmp < 0 && $neg == 0) {                # $x < $y => result $x
+    $x->{sign} = $y->{sign};     # calc sign first
+    if ($cmp < 0 && $neg == 0) { # $x < $y => result $x
         return $x -> round($a, $p, $r);
     }
-  
-  my $ym = $MBI->_copy($y->{_m});
-  
-  # 2e1 => 20
-  $MBI->_lsft( $ym, $y->{_e}, 10) 
-   if $y->{_es} eq '+' && !$MBI->_is_zero($y->{_e});
- 
-  # if $y has digits after dot
-  my $shifty = 0;			# correct _e of $x by this
-  if ($y->{_es} eq '-')			# has digits after dot
-    {
-    # 123 % 2.5 => 1230 % 25 => 5 => 0.5
-    $shifty = $MBI->_num($y->{_e}); 	# no more digits after dot
-    $MBI->_lsft($x->{_m}, $y->{_e}, 10);# 123 => 1230, $y->{_m} is already 25
-    }
-  # $ym is now mantissa of $y based on exponent 0
-
-  my $shiftx = 0;			# correct _e of $x by this
-  if ($x->{_es} eq '-')			# has digits after dot
-    {
-    # 123.4 % 20 => 1234 % 200
-    $shiftx = $MBI->_num($x->{_e});	# no more digits after dot
-    $MBI->_lsft($ym, $x->{_e}, 10);	# 123 => 1230
-    }
-  # 123e1 % 20 => 1230 % 20
-  if ($x->{_es} eq '+' && !$MBI->_is_zero($x->{_e}))
-    {
-    $MBI->_lsft( $x->{_m}, $x->{_e},10);	# es => '+' here
-    }
 
-  $x->{_e} = $MBI->_new($shiftx);
-  $x->{_es} = '+'; 
-  $x->{_es} = '-' if $shiftx != 0 || $shifty != 0;
-  $MBI->_add( $x->{_e}, $MBI->_new($shifty)) if $shifty != 0;
-  
-  # now mantissas are equalized, exponent of $x is adjusted, so calc result
+    my $ym = $MBI->_copy($y->{_m});
 
-  $x->{_m} = $MBI->_mod( $x->{_m}, $ym);
+    # 2e1 => 20
+    $MBI->_lsft($ym, $y->{_e}, 10)
+      if $y->{_es} eq '+' && !$MBI->_is_zero($y->{_e});
 
-  $x->{sign} = '+' if $MBI->_is_zero($x->{_m});		# fix sign for -0
-  $x->bnorm();
-
-    if ($neg != 0 && ! $x -> is_zero())   # one of them negative => correct in place
+    # if $y has digits after dot
+    my $shifty = 0;             # correct _e of $x by this
+    if ($y->{_es} eq '-')       # has digits after dot
     {
-    my $r = $y - $x;
-    $x->{_m} = $r->{_m};
-    $x->{_e} = $r->{_e};
-    $x->{_es} = $r->{_es};
-    $x->{sign} = '+' if $MBI->_is_zero($x->{_m});	# fix sign for -0
-    $x->bnorm();
+        # 123 % 2.5 => 1230 % 25 => 5 => 0.5
+        $shifty = $MBI->_num($y->{_e});  # no more digits after dot
+        $MBI->_lsft($x->{_m}, $y->{_e}, 10); # 123 => 1230, $y->{_m} is already 25
     }
+    # $ym is now mantissa of $y based on exponent 0
 
-  $x->round($a,$p,$r,$y);	# round and return
-  }
-
-sub broot
-  {
-  # calculate $y'th root of $x
-  
-  # set up parameters
-  my ($self,$x,$y,$a,$p,$r) = (ref($_[0]),@_);
-  # objectify is costly, so avoid it
-  if ((!ref($_[0])) || (ref($_[0]) ne ref($_[1])))
+    my $shiftx = 0;             # correct _e of $x by this
+    if ($x->{_es} eq '-')       # has digits after dot
     {
-    ($self,$x,$y,$a,$p,$r) = objectify(2,@_);
+        # 123.4 % 20 => 1234 % 200
+        $shiftx = $MBI->_num($x->{_e}); # no more digits after dot
+        $MBI->_lsft($ym, $x->{_e}, 10); # 123 => 1230
+    }
+    # 123e1 % 20 => 1230 % 20
+    if ($x->{_es} eq '+' && !$MBI->_is_zero($x->{_e})) {
+        $MBI->_lsft($x->{_m}, $x->{_e}, 10); # es => '+' here
     }
 
-  return $x if $x->modify('broot');
-
-  # NaN handling: $x ** 1/0, x or y NaN, or y inf/-inf or y == 0
-  return $x->bnan() if $x->{sign} !~ /^\+/ || $y->is_zero() ||
-         $y->{sign} !~ /^\+$/;
+    $x->{_e} = $MBI->_new($shiftx);
+    $x->{_es} = '+';
+    $x->{_es} = '-' if $shiftx != 0 || $shifty != 0;
+    $MBI->_add($x->{_e}, $MBI->_new($shifty)) if $shifty != 0;
 
-  return $x if $x->is_zero() || $x->is_one() || $x->is_inf() || $y->is_one();
-  
-  # we need to limit the accuracy to protect against overflow
-  my $fallback = 0;
-  my (@params,$scale);
-  ($x,@params) = $x->_find_round_parameters($a,$p,$r);
+    # now mantissas are equalized, exponent of $x is adjusted, so calc result
 
-  return $x if $x->is_nan();		# error in _find_round_parameters?
+    $x->{_m} = $MBI->_mod($x->{_m}, $ym);
 
-  # no rounding at all, so must use fallback
-  if (scalar @params == 0) 
-    {
-    # simulate old behaviour
-    $params[0] = $self->div_scale();	# and round to it as accuracy
-    $scale = $params[0]+4; 		# at least four more for proper round
-    $params[2] = $r;			# round mode by caller or undef
-    $fallback = 1;			# to clear a/p afterwards
-    }
-  else
-    {
-    # the 4 below is empirical, and there might be cases where it is not
-    # enough...
-    $scale = abs($params[0] || $params[1]) + 4; # take whatever is defined
-    }
-
-  # when user set globals, they would interfere with our calculation, so
-  # disable them and later re-enable them
-  no strict 'refs';
-  my $abr = "$self\::accuracy"; my $ab = $$abr; $$abr = undef;
-  my $pbr = "$self\::precision"; my $pb = $$pbr; $$pbr = undef;
-  # we also need to disable any set A or P on $x (_find_round_parameters took
-  # them already into account), since these would interfere, too
-  delete $x->{_a}; delete $x->{_p};
-  # need to disable $upgrade in BigInt, to avoid deep recursion
-  local $Math::BigInt::upgrade = undef;	# should be really parent class vs MBI
-
-  # remember sign and make $x positive, since -4 ** (1/2) => -2
-  my $sign = 0; $sign = 1 if $x->{sign} eq '-'; $x->{sign} = '+';
-
-  my $is_two = 0;
-  if ($y->isa('Math::BigFloat'))
-    {
-    $is_two = ($y->{sign} eq '+' && $MBI->_is_two($y->{_m}) && $MBI->_is_zero($y->{_e}));
-    }
-  else
-    {
-    $is_two = ($y == 2);
-    }
+    $x->{sign} = '+' if $MBI->_is_zero($x->{_m}); # fix sign for -0
+    $x->bnorm();
 
-  # normal square root if $y == 2:
-  if ($is_two)
-    {
-    $x->bsqrt($scale+4);
-    }
-  elsif ($y->is_one('-'))
+    if ($neg != 0 && ! $x -> is_zero()) # one of them negative => correct in place
     {
-    # $x ** -1 => 1/$x
-    my $u = $self->bone()->bdiv($x,$scale);
-    # copy private parts over
-    $x->{_m} = $u->{_m};
-    $x->{_e} = $u->{_e};
-    $x->{_es} = $u->{_es};
-    }
-  else
-    {
-    # calculate the broot() as integer result first, and if it fits, return
-    # it rightaway (but only if $x and $y are integer):
-
-    my $done = 0;				# not yet
-    if ($y->is_int() && $x->is_int())
-      {
-      my $i = $MBI->_copy( $x->{_m} );
-      $MBI->_lsft( $i, $x->{_e}, 10 ) unless $MBI->_is_zero($x->{_e});
-      my $int = Math::BigInt->bzero();
-      $int->{value} = $i;
-      $int->broot($y->as_number());
-      # if ($exact)
-      if ($int->copy()->bpow($y) == $x)
-        {
-        # found result, return it
-        $x->{_m} = $int->{value};
-        $x->{_e} = $MBI->_zero();
-        $x->{_es} = '+';
+        my $r = $y - $x;
+        $x->{_m} = $r->{_m};
+        $x->{_e} = $r->{_e};
+        $x->{_es} = $r->{_es};
+        $x->{sign} = '+' if $MBI->_is_zero($x->{_m}); # fix sign for -0
         $x->bnorm();
-        $done = 1;
-        }
-      }
-    if ($done == 0)
-      {
-      my $u = $self->bone()->bdiv($y,$scale+4);
-      delete $u->{_a}; delete $u->{_p};         # otherwise it conflicts
-      $x->bpow($u,$scale+4);                    # el cheapo
-      }
-    }
-  $x->bneg() if $sign == 1;
-  
-  # shortcut to not run through _find_round_parameters again
-  if (defined $params[0])
-    {
-    $x->bround($params[0],$params[2]);		# then round accordingly
-    }
-  else
-    {
-    $x->bfround($params[1],$params[2]);		# then round accordingly
     }
-  if ($fallback)
-    {
-    # clear a/p after round, since user did not request it
-    delete $x->{_a}; delete $x->{_p};
-    }
-  # restore globals
-  $$abr = $ab; $$pbr = $pb;
-  $x;
-  }
-
-sub bsqrt
-  { 
-  # calculate square root
-  my ($self,$x,$a,$p,$r) = ref($_[0]) ? (ref($_[0]),@_) : objectify(1,@_);
-
-  return $x if $x->modify('bsqrt');
 
-  return $x->bnan() if $x->{sign} !~ /^[+]/;	# NaN, -inf or < 0
-  return $x if $x->{sign} eq '+inf';		# sqrt(inf) == inf
-  return $x->round($a,$p,$r) if $x->is_zero() || $x->is_one();
+    $x->round($a, $p, $r, $y);     # round and return
+}
 
-  # we need to limit the accuracy to protect against overflow
-  my $fallback = 0;
-  my (@params,$scale);
-  ($x,@params) = $x->_find_round_parameters($a,$p,$r);
+sub bmodpow {
+    # takes a very large number to a very large exponent in a given very
+    # large modulus, quickly, thanks to binary exponentiation. Supports
+    # negative exponents.
+    my ($class, $num, $exp, $mod, @r) = objectify(3, @_);
 
-  return $x if $x->is_nan();		# error in _find_round_parameters?
+    return $num if $num->modify('bmodpow');
 
-  # no rounding at all, so must use fallback
-  if (scalar @params == 0) 
-    {
-    # simulate old behaviour
-    $params[0] = $self->div_scale();	# and round to it as accuracy
-    $scale = $params[0]+4; 		# at least four more for proper round
-    $params[2] = $r;			# round mode by caller or undef
-    $fallback = 1;			# to clear a/p afterwards
-    }
-  else
-    {
-    # the 4 below is empirical, and there might be cases where it is not
-    # enough...
-    $scale = abs($params[0] || $params[1]) + 4; # take whatever is defined
-    }
-
-  # when user set globals, they would interfere with our calculation, so
-  # disable them and later re-enable them
-  no strict 'refs';
-  my $abr = "$self\::accuracy"; my $ab = $$abr; $$abr = undef;
-  my $pbr = "$self\::precision"; my $pb = $$pbr; $$pbr = undef;
-  # we also need to disable any set A or P on $x (_find_round_parameters took
-  # them already into account), since these would interfere, too
-  delete $x->{_a}; delete $x->{_p};
-  # need to disable $upgrade in BigInt, to avoid deep recursion
-  local $Math::BigInt::upgrade = undef;	# should be really parent class vs MBI
-
-  my $i = $MBI->_copy( $x->{_m} );
-  $MBI->_lsft( $i, $x->{_e}, 10 ) unless $MBI->_is_zero($x->{_e});
-  my $xas = Math::BigInt->bzero();
-  $xas->{value} = $i;
-
-  my $gs = $xas->copy()->bsqrt();	# some guess
-
-  if (($x->{_es} ne '-')		# guess can't be accurate if there are
-					# digits after the dot
-   && ($xas->bacmp($gs * $gs) == 0))	# guess hit the nail on the head?
-    {
-    # exact result, copy result over to keep $x
-    $x->{_m} = $gs->{value}; $x->{_e} = $MBI->_zero(); $x->{_es} = '+';
-    $x->bnorm();
-    # shortcut to not run through _find_round_parameters again
-    if (defined $params[0])
-      {
-      $x->bround($params[0],$params[2]);	# then round accordingly
-      }
-    else
-      {
-      $x->bfround($params[1],$params[2]);	# then round accordingly
-      }
-    if ($fallback)
-      {
-      # clear a/p after round, since user did not request it
-      delete $x->{_a}; delete $x->{_p};
-      }
-    # re-enable A and P, upgrade is taken care of by "local"
-    ${"$self\::accuracy"} = $ab; ${"$self\::precision"} = $pb;
-    return $x;
-    }
- 
-  # sqrt(2) = 1.4 because sqrt(2*100) = 1.4*10; so we can increase the accuracy
-  # of the result by multiplying the input by 100 and then divide the integer
-  # result of sqrt(input) by 10. Rounding afterwards returns the real result.
-
-  # The following steps will transform 123.456 (in $x) into 123456 (in $y1)
-  my $y1 = $MBI->_copy($x->{_m});
-
-  my $length = $MBI->_len($y1);
-  
-  # Now calculate how many digits the result of sqrt(y1) would have
-  my $digits = int($length / 2);
-
-  # But we need at least $scale digits, so calculate how many are missing
-  my $shift = $scale - $digits;
-
-  # This happens if the input had enough digits
-  # (we take care of integer guesses above)
-  $shift = 0 if $shift < 0; 
-
-  # Multiply in steps of 100, by shifting left two times the "missing" digits
-  my $s2 = $shift * 2;
-
-  # We now make sure that $y1 has the same odd or even number of digits than
-  # $x had. So when _e of $x is odd, we must shift $y1 by one digit left,
-  # because we always must multiply by steps of 100 (sqrt(100) is 10) and not
-  # steps of 10. The length of $x does not count, since an even or odd number
-  # of digits before the dot is not changed by adding an even number of digits
-  # after the dot (the result is still odd or even digits long).
-  $s2++ if $MBI->_is_odd($x->{_e});
-
-  $MBI->_lsft( $y1, $MBI->_new($s2), 10);
-
-  # now take the square root and truncate to integer
-  $y1 = $MBI->_sqrt($y1);
-
-  # By "shifting" $y1 right (by creating a negative _e) we calculate the final
-  # result, which is than later rounded to the desired scale.
-
-  # calculate how many zeros $x had after the '.' (or before it, depending
-  # on sign of $dat, the result should have half as many:
-  my $dat = $MBI->_num($x->{_e});
-  $dat = -$dat if $x->{_es} eq '-';
-  $dat += $length;
-
-  if ($dat > 0)
-    {
-    # no zeros after the dot (e.g. 1.23, 0.49 etc)
-    # preserve half as many digits before the dot than the input had 
-    # (but round this "up")
-    $dat = int(($dat+1)/2);
-    }
-  else
-    {
-    $dat = int(($dat)/2);
-    }
-  $dat -= $MBI->_len($y1);
-  if ($dat < 0)
-    {
-    $dat = abs($dat);
-    $x->{_e} = $MBI->_new( $dat );
-    $x->{_es} = '-';
-    }
-  else
-    {    
-    $x->{_e} = $MBI->_new( $dat );
-    $x->{_es} = '+';
-    }
-  $x->{_m} = $y1;
-  $x->bnorm();
+    # check modulus for valid values
+    return $num->bnan() if ($mod->{sign} ne '+' # NaN, -, -inf, +inf
+                            || $mod->is_zero());
 
-  # shortcut to not run through _find_round_parameters again
-  if (defined $params[0])
-    {
-    $x->bround($params[0],$params[2]);		# then round accordingly
-    }
-  else
-    {
-    $x->bfround($params[1],$params[2]);		# then round accordingly
-    }
-  if ($fallback)
-    {
-    # clear a/p after round, since user did not request it
-    delete $x->{_a}; delete $x->{_p};
+    # check exponent for valid values
+    if ($exp->{sign} =~ /\w/) {
+        # i.e., if it's NaN, +inf, or -inf...
+        return $num->bnan();
     }
-  # restore globals
-  $$abr = $ab; $$pbr = $pb;
-  $x;
-  }
 
-sub bfac
-  {
-  # (BFLOAT or num_str, BFLOAT or num_str) return BFLOAT
-  # compute factorial number, modifies first argument
+    $num->bmodinv ($mod) if ($exp->{sign} eq '-');
 
-  # set up parameters
-  my ($self,$x,@r) = (ref($_[0]),@_);
-  # objectify is costly, so avoid it
-  ($self,$x,@r) = objectify(1,@_) if !ref($x);
+    # check num for valid values (also NaN if there was no inverse but $exp < 0)
+    return $num->bnan() if $num->{sign} !~ /^[+-]$/;
 
-  # inf => inf
-  return $x if $x->modify('bfac') || $x->{sign} eq '+inf';	
+    # $mod is positive, sign on $exp is ignored, result also positive
 
-  return $x->bnan() 
-    if (($x->{sign} ne '+') ||		# inf, NaN, <0 etc => NaN
-     ($x->{_es} ne '+'));		# digits after dot?
-
-  # use BigInt's bfac() for faster calc
-  if (! $MBI->_is_zero($x->{_e}))
-    {
-    $MBI->_lsft($x->{_m}, $x->{_e},10);	# change 12e1 to 120e0
-    $x->{_e} = $MBI->_zero();		# normalize
-    $x->{_es} = '+';
-    }
-  $MBI->_fac($x->{_m});			# calculate factorial
-  $x->bnorm()->round(@r); 		# norm again and round result
-  }
-
-sub _pow
-  {
-  # Calculate a power where $y is a non-integer, like 2 ** 0.3
-  my ($x,$y,@r) = @_;
-  my $self = ref($x);
-
-  # if $y == 0.5, it is sqrt($x)
-  $HALF = $self->new($HALF) unless ref($HALF);
-  return $x->bsqrt(@r,$y) if $y->bcmp($HALF) == 0;
-
-  # Using:
-  # a ** x == e ** (x * ln a)
-
-  # u = y * ln x
-  #                _                         _
-  # Taylor:       |   u    u^2    u^3         |
-  # x ** y  = 1 + |  --- + --- + ----- + ...  |
-  #               |_  1    1*2   1*2*3       _|
-
-  # we need to limit the accuracy to protect against overflow
-  my $fallback = 0;
-  my ($scale,@params);
-  ($x,@params) = $x->_find_round_parameters(@r);
-    
-  return $x if $x->is_nan();		# error in _find_round_parameters?
-
-  # no rounding at all, so must use fallback
-  if (scalar @params == 0)
-    {
-    # simulate old behaviour
-    $params[0] = $self->div_scale();	# and round to it as accuracy
-    $params[1] = undef;			# disable P
-    $scale = $params[0]+4; 		# at least four more for proper round
-    $params[2] = $r[2];			# round mode by caller or undef
-    $fallback = 1;			# to clear a/p afterwards
-    }
-  else
-    {
-    # the 4 below is empirical, and there might be cases where it is not
-    # enough...
-    $scale = abs($params[0] || $params[1]) + 4; # take whatever is defined
-    }
-
-  # when user set globals, they would interfere with our calculation, so
-  # disable them and later re-enable them
-  no strict 'refs';
-  my $abr = "$self\::accuracy"; my $ab = $$abr; $$abr = undef;
-  my $pbr = "$self\::precision"; my $pb = $$pbr; $$pbr = undef;
-  # we also need to disable any set A or P on $x (_find_round_parameters took
-  # them already into account), since these would interfere, too
-  delete $x->{_a}; delete $x->{_p};
-  # need to disable $upgrade in BigInt, to avoid deep recursion
-  local $Math::BigInt::upgrade = undef;
- 
-  my ($limit,$v,$u,$below,$factor,$next,$over);
-
-  $u = $x->copy()->blog(undef,$scale)->bmul($y);
-  my $do_invert = ($u->{sign} eq '-');
-  $u->bneg()  if $do_invert;
-  $v = $self->bone();				# 1
-  $factor = $self->new(2);			# 2
-  $x->bone();					# first term: 1
-
-  $below = $v->copy();
-  $over = $u->copy();
-
-  $limit = $self->new("1E-". ($scale-1));
-  #my $steps = 0;
-  while (3 < 5)
-    {
-    # we calculate the next term, and add it to the last
-    # when the next term is below our limit, it won't affect the outcome
-    # anymore, so we stop:
-    $next = $over->copy()->bdiv($below,$scale);
-    last if $next->bacmp($limit) <= 0;
-    $x->badd($next);
-    # calculate things for the next term
-    $over *= $u; $below *= $factor; $factor->binc();
+    # XXX TODO: speed it up when all three numbers are integers
+    $num->bpow($exp)->bmod($mod);
+}
 
-    last if $x->{sign} !~ /^[-+]$/;
+sub bpow {
+    # (BFLOAT or num_str, BFLOAT or num_str) return BFLOAT
+    # compute power of two numbers, second arg is used as integer
+    # modifies first argument
 
-    #$steps++;
+    # set up parameters
+    my ($class, $x, $y, $a, $p, $r) = (ref($_[0]), @_);
+    # objectify is costly, so avoid it
+    if ((!ref($_[0])) || (ref($_[0]) ne ref($_[1]))) {
+        ($class, $x, $y, $a, $p, $r) = objectify(2, @_);
     }
 
-  if ($do_invert)
-    {
-    my $x_copy = $x->copy;
-    $x->bone->bdiv($x_copy, $scale);
-    }
-  
-  # shortcut to not run through _find_round_parameters again
-  if (defined $params[0])
-    {
-    $x->bround($params[0],$params[2]);		# then round accordingly
-    }
-  else
-    {
-    $x->bfround($params[1],$params[2]);		# then round accordingly
-    }
-  if ($fallback)
-    {
-    # clear a/p after round, since user did not request it
-    delete $x->{_a}; delete $x->{_p};
-    }
-  # restore globals
-  $$abr = $ab; $$pbr = $pb;
-  $x;
-  }
-
-sub bpow 
-  {
-  # (BFLOAT or num_str, BFLOAT or num_str) return BFLOAT
-  # compute power of two numbers, second arg is used as integer
-  # modifies first argument
-
-  # set up parameters
-  my ($self,$x,$y,$a,$p,$r) = (ref($_[0]),@_);
-  # objectify is costly, so avoid it
-  if ((!ref($_[0])) || (ref($_[0]) ne ref($_[1])))
-    {
-    ($self,$x,$y,$a,$p,$r) = objectify(2,@_);
-    }
+    return $x if $x->modify('bpow');
 
-  return $x if $x->modify('bpow');
+    return $x->bnan() if $x->{sign} eq $nan || $y->{sign} eq $nan;
+    return $x if $x->{sign} =~ /^[+-]inf$/;
 
-  return $x->bnan() if $x->{sign} eq $nan || $y->{sign} eq $nan;
-  return $x if $x->{sign} =~ /^[+-]inf$/;
-  
-  # cache the result of is_zero
-  my $y_is_zero = $y->is_zero();
-  return $x->bone() if $y_is_zero;
-  return $x         if $x->is_one() || $y->is_one();
+    # cache the result of is_zero
+    my $y_is_zero = $y->is_zero();
+    return $x->bone() if $y_is_zero;
+    return $x         if $x->is_one() || $y->is_one();
 
-  my $x_is_zero = $x->is_zero();
-  return $x->_pow($y,$a,$p,$r) if !$x_is_zero && !$y->is_int();		# non-integer power
+    my $x_is_zero = $x->is_zero();
+    return $x->_pow($y, $a, $p, $r) if !$x_is_zero && !$y->is_int(); # non-integer power
 
-  my $y1 = $y->as_number()->{value};			# make MBI part
+    my $y1 = $y->as_number()->{value}; # make MBI part
 
-  # if ($x == -1)
-  if ($x->{sign} eq '-' && $MBI->_is_one($x->{_m}) && $MBI->_is_zero($x->{_e}))
-    {
-    # if $x == -1 and odd/even y => +1/-1  because +-1 ^ (+-1) => +-1
-    return $MBI->_is_odd($y1) ? $x : $x->babs(1);
+    # if ($x == -1)
+    if ($x->{sign} eq '-' && $MBI->_is_one($x->{_m}) && $MBI->_is_zero($x->{_e})) {
+        # if $x == -1 and odd/even y => +1/-1  because +-1 ^ (+-1) => +-1
+        return $MBI->_is_odd($y1) ? $x : $x->babs(1);
     }
-  if ($x_is_zero)
-    {
-    return $x if $y->{sign} eq '+'; 	# 0**y => 0 (if not y <= 0)
-    # 0 ** -y => 1 / (0 ** y) => 1 / 0! (1 / 0 => +inf)
-    return $x->binf();
+    if ($x_is_zero) {
+        return $x if $y->{sign} eq '+'; # 0**y => 0 (if not y <= 0)
+        # 0 ** -y => 1 / (0 ** y) => 1 / 0! (1 / 0 => +inf)
+        return $x->binf();
     }
 
-  my $new_sign = '+';
-  $new_sign = $MBI->_is_odd($y1) ? '-' : '+' if $x->{sign} ne '+';
+    my $new_sign = '+';
+    $new_sign = $MBI->_is_odd($y1) ? '-' : '+' if $x->{sign} ne '+';
 
-  # calculate $x->{_m} ** $y and $x->{_e} * $y separately (faster)
-  $x->{_m} = $MBI->_pow( $x->{_m}, $y1);
-  $x->{_e} = $MBI->_mul ($x->{_e}, $y1);
+    # calculate $x->{_m} ** $y and $x->{_e} * $y separately (faster)
+    $x->{_m} = $MBI->_pow($x->{_m}, $y1);
+    $x->{_e} = $MBI->_mul ($x->{_e}, $y1);
 
-  $x->{sign} = $new_sign;
-  $x->bnorm();
-  if ($y->{sign} eq '-')
-    {
-    # modify $x in place!
-    my $z = $x->copy(); $x->bone();
-    return scalar $x->bdiv($z,$a,$p,$r);	# round in one go (might ignore y's A!)
+    $x->{sign} = $new_sign;
+    $x->bnorm();
+    if ($y->{sign} eq '-') {
+        # modify $x in place!
+        my $z = $x->copy(); $x->bone();
+        return scalar $x->bdiv($z, $a, $p, $r); # round in one go (might ignore y's A!)
     }
-  $x->round($a,$p,$r,$y);
-  }
+    $x->round($a, $p, $r, $y);
+}
 
-sub bmodpow
-  {
-  # takes a very large number to a very large exponent in a given very
-  # large modulus, quickly, thanks to binary exponentiation. Supports
-  # negative exponents.
-  my ($self,$num,$exp,$mod,@r) = objectify(3,@_);
+sub blog {
+    my ($class, $x, $base, $a, $p, $r) = ref($_[0]) ? (ref($_[0]), @_) : objectify(1, @_);
 
-  return $num if $num->modify('bmodpow');
+    # If called as $x -> blog() or $x -> blog(undef), don't objectify the
+    # undefined base, since undef signals that the base is Euler's number.
+    #unless (ref($x) && !defined($base)) {
+    #    # objectify is costly, so avoid it
+    #    if ((!ref($_[0])) || (ref($_[0]) ne ref($_[1]))) {
+    #        ($class, $x, $base, $a, $p, $r) = objectify(2, @_);
+    #    }
+    #}
 
-  # check modulus for valid values
-  return $num->bnan() if ($mod->{sign} ne '+'           # NaN, - , -inf, +inf
-                       || $mod->is_zero());
+    return $x if $x->modify('blog');
 
-  # check exponent for valid values
-  if ($exp->{sign} =~ /\w/)
-    {
-    # i.e., if it's NaN, +inf, or -inf...
-    return $num->bnan();
-    }
+    return $x -> bnan() if $x -> is_nan();
+
+    # we need to limit the accuracy to protect against overflow
+    my $fallback = 0;
+    my ($scale, @params);
+    ($x, @params) = $x->_find_round_parameters($a, $p, $r);
 
-  $num->bmodinv ($mod) if ($exp->{sign} eq '-');
+    # no rounding at all, so must use fallback
+    if (scalar @params == 0) {
+        # simulate old behaviour
+        $params[0] = $class->div_scale(); # and round to it as accuracy
+        $params[1] = undef;               # P = undef
+        $scale = $params[0]+4;            # at least four more for proper round
+        $params[2] = $r;                  # round mode by caller or undef
+        $fallback = 1;                    # to clear a/p afterwards
+    } else {
+        # the 4 below is empirical, and there might be cases where it is not
+        # enough...
+        $scale = abs($params[0] || $params[1]) + 4; # take whatever is defined
+    }
 
-  # check num for valid values (also NaN if there was no inverse but $exp < 0)
-  return $num->bnan() if $num->{sign} !~ /^[+-]$/;
+    my $done = 0;
+    if (defined $base) {
+        $base = $class -> new($base) unless ref $base;
+        if ($base -> is_nan() || $base -> is_one()) {
+            $x -> bnan();
+            $done = 1;
+        } elsif ($base -> is_inf() || $base -> is_zero()) {
+            if ($x -> is_inf() || $x -> is_zero()) {
+                $x -> bnan();
+            } else {
+                $x -> bzero(@params);
+            }
+            $done = 1;
+        } elsif ($base -> is_negative()) { # -inf < base < 0
+            if ($x -> is_one()) {          #     x = 1
+                $x -> bzero(@params);
+            } elsif ($x == $base) {
+                $x -> bone('+', @params); #     x = base
+            } else {
+                $x -> bnan();   #     otherwise
+            }
+            $done = 1;
+        } elsif ($x == $base) {
+            $x -> bone('+', @params); # 0 < base && 0 < x < inf
+            $done = 1;
+        }
+    }
 
-  # $mod is positive, sign on $exp is ignored, result also positive
+    # We now know that the base is either undefined or positive and finite.
+
+    unless ($done) {
+        if ($x -> is_inf()) {   #   x = +/-inf
+            my $sign = defined $base && $base < 1 ? '-' : '+';
+            $x -> binf($sign);
+            $done = 1;
+        } elsif ($x -> is_neg()) { #   -inf < x < 0
+            $x -> bnan();
+            $done = 1;
+        } elsif ($x -> is_one()) { #   x = 1
+            $x -> bzero(@params);
+            $done = 1;
+        } elsif ($x -> is_zero()) { #   x = 0
+            my $sign = defined $base && $base < 1 ? '+' : '-';
+            $x -> binf($sign);
+            $done = 1;
+        }
+    }
 
-  # XXX TODO: speed it up when all three numbers are integers
-  $num->bpow($exp)->bmod($mod);
-  }
+    if ($done) {
+        if ($fallback) {
+            # clear a/p after round, since user did not request it
+            delete $x->{_a};
+            delete $x->{_p};
+        }
+        return $x;
+    }
 
-###############################################################################
-# trigonometric functions
+    # when user set globals, they would interfere with our calculation, so
+    # disable them and later re-enable them
+    no strict 'refs';
+    my $abr = "$class\::accuracy"; my $ab = $$abr; $$abr = undef;
+    my $pbr = "$class\::precision"; my $pb = $$pbr; $$pbr = undef;
+    # we also need to disable any set A or P on $x (_find_round_parameters took
+    # them already into account), since these would interfere, too
+    delete $x->{_a}; delete $x->{_p};
+    # need to disable $upgrade in BigInt, to avoid deep recursion
+    local $Math::BigInt::upgrade = undef;
+    local $Math::BigFloat::downgrade = undef;
+
+    # upgrade $x if $x is not a Math::BigFloat (handle BigInt input)
+    # XXX TODO: rebless!
+    if (!$x->isa('Math::BigFloat')) {
+        $x = Math::BigFloat->new($x);
+        $class = ref($x);
+    }
+
+    $done = 0;
+
+    # If the base is defined and an integer, try to calculate integer result
+    # first. This is very fast, and in case the real result was found, we can
+    # stop right here.
+    if (defined $base && $base->is_int() && $x->is_int()) {
+        my $i = $MBI->_copy($x->{_m});
+        $MBI->_lsft($i, $x->{_e}, 10) unless $MBI->_is_zero($x->{_e});
+        my $int = Math::BigInt->bzero();
+        $int->{value} = $i;
+        $int->blog($base->as_number());
+        # if ($exact)
+        if ($base->as_number()->bpow($int) == $x) {
+            # found result, return it
+            $x->{_m} = $int->{value};
+            $x->{_e} = $MBI->_zero();
+            $x->{_es} = '+';
+            $x->bnorm();
+            $done = 1;
+        }
+    }
 
-# helper function for bpi() and batan2(), calculates arcus tanges (1/x)
+    if ($done == 0) {
+        # base is undef, so base should be e (Euler's number), so first calculate the
+        # log to base e (using reduction by 10 (and probably 2)):
+        $class->_log_10($x, $scale);
 
-sub _atan_inv
-  {
-  # return a/b so that a/b approximates atan(1/x) to at least limit digits
-  my ($self, $x, $limit) = @_;
-
-  # Taylor:       x^3   x^5   x^7   x^9
-  #    atan = x - --- + --- - --- + --- - ...
-  #                3     5     7     9 
-
-  #               1      1         1        1
-  #    atan 1/x = - - ------- + ------- - ------- + ...
-  #               x   x^3 * 3   x^5 * 5   x^7 * 7 
-
-  #               1      1         1            1
-  #    atan 1/x = - - --------- + ---------- - ----------- + ... 
-  #               5    3 * 125     5 * 3125     7 * 78125
-
-  # Subtraction/addition of a rational:
-
-  #  5    7    5*3 +- 7*4
-  #  - +- -  = ----------
-  #  4    3       4*3
-
-  # Term:  N        N+1
-  #
-  #        a             1                  a * d * c +- b
-  #        ----- +- ------------------  =  ----------------
-  #        b           d * c                b * d * c
-
-  #  since b1 = b0 * (d-2) * c
-
-  #        a             1                  a * d +- b / c
-  #        ----- +- ------------------  =  ----------------
-  #        b           d * c                b * d 
-
-  # and  d = d + 2
-  # and  c = c * x * x
-
-  #        u = d * c
-  #        stop if length($u) > limit 
-  #        a = a * u +- b
-  #        b = b * u
-  #        d = d + 2
-  #        c = c * x * x
-  #        sign = 1 - sign
-
-  my $a = $MBI->_one();
-  my $b = $MBI->_copy($x);
- 
-  my $x2  = $MBI->_mul( $MBI->_copy($x), $b);		# x2 = x * x
-  my $d   = $MBI->_new( 3 );				# d = 3
-  my $c   = $MBI->_mul( $MBI->_copy($x), $x2);		# c = x ^ 3
-  my $two = $MBI->_new( 2 );
-
-  # run the first step unconditionally
-  my $u = $MBI->_mul( $MBI->_copy($d), $c);
-  $a = $MBI->_mul($a, $u);
-  $a = $MBI->_sub($a, $b);
-  $b = $MBI->_mul($b, $u);
-  $d = $MBI->_add($d, $two);
-  $c = $MBI->_mul($c, $x2);
-
-  # a is now a * (d-3) * c
-  # b is now b * (d-2) * c
-
-  # run the second step unconditionally
-  $u = $MBI->_mul( $MBI->_copy($d), $c);
-  $a = $MBI->_mul($a, $u);
-  $a = $MBI->_add($a, $b);
-  $b = $MBI->_mul($b, $u);
-  $d = $MBI->_add($d, $two);
-  $c = $MBI->_mul($c, $x2);
-
-  # a is now a * (d-3) * (d-5) * c * c  
-  # b is now b * (d-2) * (d-4) * c * c
-
-  # so we can remove c * c from both a and b to shorten the numbers involved:
-  $a = $MBI->_div($a, $x2);
-  $b = $MBI->_div($b, $x2);
-  $a = $MBI->_div($a, $x2);
-  $b = $MBI->_div($b, $x2);
-
-#  my $step = 0; 
-  my $sign = 0;						# 0 => -, 1 => +
-  while (3 < 5)
-    {
-#    $step++;
-#    if (($i++ % 100) == 0)
-#      {
-#    print "a=",$MBI->_str($a),"\n";
-#    print "b=",$MBI->_str($b),"\n";
-#      }
-#    print "d=",$MBI->_str($d),"\n";
-#    print "x2=",$MBI->_str($x2),"\n";
-#    print "c=",$MBI->_str($c),"\n";
-
-    my $u = $MBI->_mul( $MBI->_copy($d), $c);
-    # use _alen() for libs like GMP where _len() would be O(N^2)
-    last if $MBI->_alen($u) > $limit;
-    my ($bc,$r) = $MBI->_div( $MBI->_copy($b), $c);
-    if ($MBI->_is_zero($r))
-      {
-      # b / c is an integer, so we can remove c from all terms
-      # this happens almost every time:
-      $a = $MBI->_mul($a, $d);
-      $a = $MBI->_sub($a, $bc) if $sign == 0;
-      $a = $MBI->_add($a, $bc) if $sign == 1;
-      $b = $MBI->_mul($b, $d);
-      }
-    else
-      {
-      # b / c is not an integer, so we keep c in the terms
-      # this happens very rarely, for instance for x = 5, this happens only
-      # at the following steps:
-      # 1, 5, 14, 32, 72, 157, 340, ...
-      $a = $MBI->_mul($a, $u);
-      $a = $MBI->_sub($a, $b) if $sign == 0;
-      $a = $MBI->_add($a, $b) if $sign == 1;
-      $b = $MBI->_mul($b, $u);
-      }
-    $d = $MBI->_add($d, $two);
-    $c = $MBI->_mul($c, $x2);
-    $sign = 1 - $sign;
+        # and if a different base was requested, convert it
+        if (defined $base) {
+            $base = Math::BigFloat->new($base) unless $base->isa('Math::BigFloat');
+            # not ln, but some other base (don't modify $base)
+            $x->bdiv($base->copy()->blog(undef, $scale), $scale);
+        }
+    }
 
+    # shortcut to not run through _find_round_parameters again
+    if (defined $params[0]) {
+        $x->bround($params[0], $params[2]); # then round accordingly
+    } else {
+        $x->bfround($params[1], $params[2]); # then round accordingly
     }
+    if ($fallback) {
+        # clear a/p after round, since user did not request it
+        delete $x->{_a};
+        delete $x->{_p};
+    }
+    # restore globals
+    $$abr = $ab;
+    $$pbr = $pb;
 
-#  print "Took $step steps for ", $MBI->_str($x),"\n";
-#  print "a=",$MBI->_str($a),"\n"; print "b=",$MBI->_str($b),"\n";
-  # return a/b so that a/b approximates atan(1/x)
-  ($a,$b);
-  }
+    $x;
+}
 
-sub bpi {
+sub bexp {
+    # Calculate e ** X (Euler's number to the power of X)
+    my ($class, $x, $a, $p, $r) = ref($_[0]) ? (ref($_[0]), @_) : objectify(1, @_);
 
-    # Called as                 Argument list
-    # ---------                 -------------
-    # Math::BigFloat->bpi()     ("Math::BigFloat")
-    # Math::BigFloat->bpi(10)   ("Math::BigFloat", 10)
-    # $x->bpi()                 ($x)
-    # $x->bpi(10)               ($x, 10)
-    # Math::BigFloat::bpi()     ()
-    # Math::BigFloat::bpi(10)   (10)
-    #
-    # In ambiguous cases, we favour the OO-style, so the following case
-    #
-    #   $n = Math::BigFloat->new("10");
-    #   $x = Math::BigFloat->bpi($n);
-    #
-    # which gives an argument list with the single element $n, is resolved as
-    #
-    #   $n->bpi();
+    return $x if $x->modify('bexp');
 
-    my $self    = shift;
-    my $selfref = ref $self;
-    my $class   = $selfref || $self;
+    return $x->binf() if $x->{sign} eq '+inf';
+    return $x->bzero() if $x->{sign} eq '-inf';
 
-    my $accu;                      # accuracy (number of digits)
-    my $prec;                      # precision
-    my $rndm;                      # round mode
+    # we need to limit the accuracy to protect against overflow
+    my $fallback = 0;
+    my ($scale, @params);
+    ($x, @params) = $x->_find_round_parameters($a, $p, $r);
 
-    # If bpi() is called as a function ...
-    #
-    # This cludge is necessary because we still support bpi() as a function. If
-    # bpi() is called with either no argument or one argument, and that one
-    # argument is either undefined or a scalar that looks like a number, then
-    # we assume bpi() is called as a function.
+    # also takes care of the "error in _find_round_parameters?" case
+    return $x if $x->{sign} eq 'NaN';
 
-    if (@_ == 0 &&
-        (defined($self) && !ref($self) && $self =~ /^\s*[+-]?\d/i)
-          ||
-        !defined($self))
-    {
-        $accu = $self;
-        $class = __PACKAGE__;
-        $self = $class -> bzero();      # initialize
+    # no rounding at all, so must use fallback
+    if (scalar @params == 0) {
+        # simulate old behaviour
+        $params[0] = $class->div_scale(); # and round to it as accuracy
+        $params[1] = undef;               # P = undef
+        $scale = $params[0]+4;            # at least four more for proper round
+        $params[2] = $r;                  # round mode by caller or undef
+        $fallback = 1;                    # to clear a/p afterwards
+    } else {
+        # the 4 below is empirical, and there might be cases where it's not enough...
+        $scale = abs($params[0] || $params[1]) + 4; # take whatever is defined
     }
 
-    # ... or if bpi() is called as a method ...
+    return $x->bone(@params) if $x->is_zero();
 
-    else {
-        if ($selfref) {                 # bpi() called as instance method
-            return $self if $self -> modify('bpi');
-        } else {                        # bpi() called as class method
-            $self = $class -> bzero();  # initialize
-        }
-        $accu = shift;
-        $prec = shift;
-        $rndm = shift;
+    if (!$x->isa('Math::BigFloat')) {
+        $x = Math::BigFloat->new($x);
+        $class = ref($x);
     }
 
-    my @r = ($accu, $prec, $rndm);
+    # when user set globals, they would interfere with our calculation, so
+    # disable them and later re-enable them
+    no strict 'refs';
+    my $abr = "$class\::accuracy"; my $ab = $$abr; $$abr = undef;
+    my $pbr = "$class\::precision"; my $pb = $$pbr; $$pbr = undef;
+    # we also need to disable any set A or P on $x (_find_round_parameters took
+    # them already into account), since these would interfere, too
+    delete $x->{_a};
+    delete $x->{_p};
+    # need to disable $upgrade in BigInt, to avoid deep recursion
+    local $Math::BigInt::upgrade = undef;
+    local $Math::BigFloat::downgrade = undef;
 
-    # We need to limit the accuracy to protect against overflow.
-    my $fallback = 0;
-    my ($scale, @params);
-    ($self, @params) = $self -> _find_round_parameters(@r);
+    my $x_org = $x->copy();
 
-    # Error in _find_round_parameters?
-    #
-    # We can't return here, because that will fail if $self was a NaN when
-    # bpi() was invoked, and we want to assign pi to $x. It is probably not a
-    # good idea that _find_round_parameters() signals invalid round parameters
-    # by silently returning a NaN. Fixme!
-    #return $self if $self && $self->is_nan();
+    # We use the following Taylor series:
 
-    # No rounding at all, so must use fallback.
-    if (scalar @params == 0) {
-        # Simulate old behaviour
-        $params[0] = $self -> div_scale();  # and round to it as accuracy
-        $params[1] = undef;                 # disable P
-        $params[2] = $r[2];                 # round mode by caller or undef
-        $fallback = 1;                      # to clear a/p afterwards
-    }
+    #           x    x^2   x^3   x^4
+    #  e = 1 + --- + --- + --- + --- ...
+    #           1!    2!    3!    4!
 
-    # The accuracy, i.e., the number of digits. Pi has one digit before the
-    # dot, so a precision of 4 digits is equivalent to an accuracy of 5 digits.
+    # The difference for each term is X and N, which would result in:
+    # 2 copy, 2 mul, 2 add, 1 inc, 1 div operations per term
 
-    my $n = $params[0] || 1 - $params[1];
+    # But it is faster to compute exp(1) and then raising it to the
+    # given power, esp. if $x is really big and an integer because:
 
-    if ($n < 1000) {
+    #  * The numerator is always 1, making the computation faster
+    #  * the series converges faster in the case of x == 1
+    #  * We can also easily check when we have reached our limit: when the
+    #    term to be added is smaller than "1E$scale", we can stop - f.i.
+    #    scale == 5, and we have 1/40320, then we stop since 1/40320 < 1E-5.
+    #  * we can compute the *exact* result by simulating bigrat math:
 
-        # after 黃見利 (Hwang Chien-Lih) (1997)
-        # pi/4 = 183 * atan(1/239) + 32 * atan(1/1023) – 68 * atan(1/5832)
-        #        + 12 * atan(1/110443) - 12 * atan(1/4841182) - 100 * atan(1/6826318)
+    #  1   1    gcd(3, 4) = 1    1*24 + 1*6    5
+    #  - + -                  = ---------- =  --
+    #  6   24                      6*24       24
 
-        # Use a few more digits in the intermediate computations.
+    # We do not compute the gcd() here, but simple do:
+    #  1   1    1*24 + 1*6   30
+    #  - + -  = --------- =  --
+    #  6   24       6*24     144
 
-        my $nextra = $n < 800 ? 4 : 5;
-        $n += $nextra;
+    # In general:
+    #  a   c    a*d + c*b         and note that c is always 1 and d = (b*f)
+    #  - + -  = ---------
+    #  b   d       b*d
 
-        my ($a, $b) = $class->_atan_inv($MBI->_new(239), $n);
-        my ($c, $d) = $class->_atan_inv($MBI->_new(1023), $n);
-        my ($e, $f) = $class->_atan_inv($MBI->_new(5832), $n);
-        my ($g, $h) = $class->_atan_inv($MBI->_new(110443), $n);
-        my ($i, $j) = $class->_atan_inv($MBI->_new(4841182), $n);
-        my ($k, $l) = $class->_atan_inv($MBI->_new(6826318), $n);
+    # This leads to:         which can be reduced by b to:
+    #  a   1     a*b*f + b    a*f + 1
+    #  - + -   = --------- =  -------
+    #  b   b*f     b*b*f        b*f
 
-        $MBI->_mul($a, $MBI->_new(732));
-        $MBI->_mul($c, $MBI->_new(128));
-        $MBI->_mul($e, $MBI->_new(272));
-        $MBI->_mul($g, $MBI->_new(48));
-        $MBI->_mul($i, $MBI->_new(48));
-        $MBI->_mul($k, $MBI->_new(400));
+    # The first terms in the series are:
 
-        my $x = $class->bone(); $x->{_m} = $a; my $x_d = $class->bone(); $x_d->{_m} = $b;
-        my $y = $class->bone(); $y->{_m} = $c; my $y_d = $class->bone(); $y_d->{_m} = $d;
-        my $z = $class->bone(); $z->{_m} = $e; my $z_d = $class->bone(); $z_d->{_m} = $f;
-        my $u = $class->bone(); $u->{_m} = $g; my $u_d = $class->bone(); $u_d->{_m} = $h;
-        my $v = $class->bone(); $v->{_m} = $i; my $v_d = $class->bone(); $v_d->{_m} = $j;
-        my $w = $class->bone(); $w->{_m} = $k; my $w_d = $class->bone(); $w_d->{_m} = $l;
-        $x->bdiv($x_d, $n);
-        $y->bdiv($y_d, $n);
-        $z->bdiv($z_d, $n);
-        $u->bdiv($u_d, $n);
-        $v->bdiv($v_d, $n);
-        $w->bdiv($w_d, $n);
+    # 1     1    1    1    1    1     1     1     13700
+    # -- + -- + -- + -- + -- + --- + --- + ---- = -----
+    # 1     1    2    6   24   120   720   5040   5040
 
-        delete $x->{_a}; delete $y->{_a}; delete $z->{_a};
-        delete $u->{_a}; delete $v->{_a}; delete $w->{_a};
-        $x->badd($y)->bsub($z)->badd($u)->bsub($v)->bsub($w);
+    # Note that we cannot simple reduce 13700/5040 to 685/252, but must keep A and B!
 
-        for my $key (qw/ sign _m _es _e _a _p /) {
-            $self -> {$key} = $x -> {$key} if exists $x -> {$key};
+    if ($scale <= 75) {
+        # set $x directly from a cached string form
+        $x->{_m} = $MBI->_new(
+                              "27182818284590452353602874713526624977572470936999595749669676277240766303535476");
+        $x->{sign} = '+';
+        $x->{_es} = '-';
+        $x->{_e} = $MBI->_new(79);
+    } else {
+        # compute A and B so that e = A / B.
+
+        # After some terms we end up with this, so we use it as a starting point:
+        my $A = $MBI->_new("90933395208605785401971970164779391644753259799242");
+        my $F = $MBI->_new(42);
+        my $step = 42;
+
+        # Compute how many steps we need to take to get $A and $B sufficiently big
+        my $steps = _len_to_steps($scale - 4);
+        #    print STDERR "# Doing $steps steps for ", $scale-4, " digits\n";
+        while ($step++ <= $steps) {
+            # calculate $a * $f + 1
+            $A = $MBI->_mul($A, $F);
+            $A = $MBI->_inc($A);
+            # increment f
+            $F = $MBI->_inc($F);
         }
+        # compute $B as factorial of $steps (this is faster than doing it manually)
+        my $B = $MBI->_fac($MBI->_new($steps));
 
-    } else {
+        #  print "A ", $MBI->_str($A), "\nB ", $MBI->_str($B), "\n";
 
-        # For large accuracy, the arctan formulas become very inefficient with
-        # Math::BigFloat. Switch to Brent-Salamin (aka AGM or Gauss-Legendre).
+        # compute A/B with $scale digits in the result (truncate, not round)
+        $A = $MBI->_lsft($A, $MBI->_new($scale), 10);
+        $A = $MBI->_div($A, $B);
 
-        # Use a few more digits in the intermediate computations.
-        my $nextra = 8;
+        $x->{_m} = $A;
+        $x->{sign} = '+';
+        $x->{_es} = '-';
+        $x->{_e} = $MBI->_new($scale);
+    }
 
-        $HALF = $class -> new($HALF) unless ref($HALF);
-        my ($an, $bn, $tn, $pn) = ($class -> bone, $HALF -> copy -> bsqrt($n),
-                                   $HALF -> copy -> bmul($HALF), $class -> bone);
-        while ($pn < $n) {
-            my $prev_an = $an -> copy;
-            $an -> badd($bn) -> bmul($HALF, $n);
-            $bn -> bmul($prev_an) -> bsqrt($n);
-            $prev_an -> bsub($an);
-            $tn -> bsub($pn * $prev_an * $prev_an);
-            $pn -> badd($pn);
+    # $x contains now an estimate of e, with some surplus digits, so we can round
+    if (!$x_org->is_one()) {
+        # Reduce size of fractional part, followup with integer power of two.
+        my $lshift = 0;
+        while ($lshift < 30 && $x_org->bacmp(2 << $lshift) > 0) {
+            $lshift++;
         }
-        $an -> badd($bn);
-        $an -> bmul($an, $n) -> bdiv(4 * $tn, $n);
-
-        for my $key (qw/ sign _m _es _e _a _p /) {
-            $self -> {$key} = $an -> {$key} if exists $an -> {$key};;
+        # Raise $x to the wanted power and round it.
+        if ($lshift == 0) {
+            $x->bpow($x_org, @params);
+        } else {
+            my($mul, $rescale) = (1 << $lshift, $scale+1+$lshift);
+            $x->bpow(scalar $x_org->bdiv($mul, $rescale), $rescale)->bpow($mul, @params);
+        }
+    } else {
+        # else just round the already computed result
+        delete $x->{_a};
+        delete $x->{_p};
+        # shortcut to not run through _find_round_parameters again
+        if (defined $params[0]) {
+            $x->bround($params[0], $params[2]); # then round accordingly
+        } else {
+            $x->bfround($params[1], $params[2]); # then round accordingly
         }
     }
-
-    $self -> round(@params);
-
     if ($fallback) {
-        delete $self->{_a};
-        delete $self->{_p};
+        # clear a/p after round, since user did not request it
+        delete $x->{_a};
+        delete $x->{_p};
     }
+    # restore globals
+    $$abr = $ab;
+    $$pbr = $pb;
 
-    return $self;
+    $x;                         # return modified $x
 }
 
-sub bcos
-  {
-  # Calculate a cosinus of x.
-  my ($self,$x,@r) = ref($_[0]) ? (ref($_[0]),@_) : objectify(1,@_);
+sub bnok {
+    # Calculate n over k (binomial coefficient or "choose" function) as integer.
+    # set up parameters
+    my ($class, $x, $y, @r) = (ref($_[0]), @_);
 
-  # Taylor:      x^2   x^4   x^6   x^8
-  #    cos = 1 - --- + --- - --- + --- ...
-  #               2!    4!    6!    8!
+    # objectify is costly, so avoid it
+    if ((!ref($_[0])) || (ref($_[0]) ne ref($_[1]))) {
+        ($class, $x, $y, @r) = objectify(2, @_);
+    }
 
-  # we need to limit the accuracy to protect against overflow
-  my $fallback = 0;
-  my ($scale,@params);
-  ($x,@params) = $x->_find_round_parameters(@r);
-    
-  #         constant object       or error in _find_round_parameters?
-  return $x if $x->modify('bcos') || $x->is_nan();
+    return $x if $x->modify('bnok');
 
-  return $x->bone(@r) if $x->is_zero();
+    return $x->bnan() if $x->is_nan() || $y->is_nan();
+    return $x->binf() if $x->is_inf();
 
-  # no rounding at all, so must use fallback
-  if (scalar @params == 0)
-    {
-    # simulate old behaviour
-    $params[0] = $self->div_scale();	# and round to it as accuracy
-    $params[1] = undef;			# disable P
-    $scale = $params[0]+4; 		# at least four more for proper round
-    $params[2] = $r[2];			# round mode by caller or undef
-    $fallback = 1;			# to clear a/p afterwards
-    }
-  else
-    {
-    # the 4 below is empirical, and there might be cases where it is not
-    # enough...
-    $scale = abs($params[0] || $params[1]) + 4; # take whatever is defined
-    }
-
-  # when user set globals, they would interfere with our calculation, so
-  # disable them and later re-enable them
-  no strict 'refs';
-  my $abr = "$self\::accuracy"; my $ab = $$abr; $$abr = undef;
-  my $pbr = "$self\::precision"; my $pb = $$pbr; $$pbr = undef;
-  # we also need to disable any set A or P on $x (_find_round_parameters took
-  # them already into account), since these would interfere, too
-  delete $x->{_a}; delete $x->{_p};
-  # need to disable $upgrade in BigInt, to avoid deep recursion
-  local $Math::BigInt::upgrade = undef;
- 
-  my $last = 0;
-  my $over = $x * $x;                   # X ^ 2
-  my $x2 = $over->copy();               # X ^ 2; difference between terms
-  my $sign = 1;                         # start with -=
-  my $below = $self->new(2); my $factorial = $self->new(3);
-  $x->bone(); delete $x->{_a}; delete $x->{_p};
-
-  my $limit = $self->new("1E-". ($scale-1));
-  #my $steps = 0;
-  while (3 < 5)
-    {
-    # we calculate the next term, and add it to the last
-    # when the next term is below our limit, it won't affect the outcome
-    # anymore, so we stop:
-    my $next = $over->copy()->bdiv($below,$scale);
-    last if $next->bacmp($limit) <= 0;
-
-    if ($sign == 0)
-      {
-      $x->badd($next);
-      }
-    else
-      {
-      $x->bsub($next);
-      }
-    $sign = 1-$sign;					# alternate
-    # calculate things for the next term
-    $over->bmul($x2);					# $x*$x
-    $below->bmul($factorial); $factorial->binc();	# n*(n+1)
-    $below->bmul($factorial); $factorial->binc();	# n*(n+1)
-    }
-
-  # shortcut to not run through _find_round_parameters again
-  if (defined $params[0])
-    {
-    $x->bround($params[0],$params[2]);		# then round accordingly
-    }
-  else
-    {
-    $x->bfround($params[1],$params[2]);		# then round accordingly
-    }
-  if ($fallback)
-    {
-    # clear a/p after round, since user did not request it
-    delete $x->{_a}; delete $x->{_p};
-    }
-  # restore globals
-  $$abr = $ab; $$pbr = $pb;
-  $x;
-  }
+    my $u = $x->as_int();
+    $u->bnok($y->as_int());
 
-sub bsin
-  {
-  # Calculate a sinus of x.
-  my ($self,$x,@r) = ref($_[0]) ? (ref($_[0]),@_) : objectify(1,@_);
+    $x->{_m} = $u->{value};
+    $x->{_e} = $MBI->_zero();
+    $x->{_es} = '+';
+    $x->{sign} = '+';
+    $x->bnorm(@r);
+}
 
-  # taylor:      x^3   x^5   x^7   x^9
-  #    sin = x - --- + --- - --- + --- ...
-  #               3!    5!    7!    9!
+sub bsin {
+    # Calculate a sinus of x.
+    my ($class, $x, @r) = ref($_[0]) ? (ref($_[0]), @_) : objectify(1, @_);
 
-  # we need to limit the accuracy to protect against overflow
-  my $fallback = 0;
-  my ($scale,@params);
-  ($x,@params) = $x->_find_round_parameters(@r);
-    
-  #         constant object       or error in _find_round_parameters?
-  return $x if $x->modify('bsin') || $x->is_nan();
+    # taylor:      x^3   x^5   x^7   x^9
+    #    sin = x - --- + --- - --- + --- ...
+    #               3!    5!    7!    9!
 
-  return $x->bzero(@r) if $x->is_zero();
+    # we need to limit the accuracy to protect against overflow
+    my $fallback = 0;
+    my ($scale, @params);
+    ($x, @params) = $x->_find_round_parameters(@r);
 
-  # no rounding at all, so must use fallback
-  if (scalar @params == 0)
-    {
-    # simulate old behaviour
-    $params[0] = $self->div_scale();	# and round to it as accuracy
-    $params[1] = undef;			# disable P
-    $scale = $params[0]+4; 		# at least four more for proper round
-    $params[2] = $r[2];			# round mode by caller or undef
-    $fallback = 1;			# to clear a/p afterwards
-    }
-  else
-    {
-    # the 4 below is empirical, and there might be cases where it is not
-    # enough...
-    $scale = abs($params[0] || $params[1]) + 4; # take whatever is defined
-    }
-
-  # when user set globals, they would interfere with our calculation, so
-  # disable them and later re-enable them
-  no strict 'refs';
-  my $abr = "$self\::accuracy"; my $ab = $$abr; $$abr = undef;
-  my $pbr = "$self\::precision"; my $pb = $$pbr; $$pbr = undef;
-  # we also need to disable any set A or P on $x (_find_round_parameters took
-  # them already into account), since these would interfere, too
-  delete $x->{_a}; delete $x->{_p};
-  # need to disable $upgrade in BigInt, to avoid deep recursion
-  local $Math::BigInt::upgrade = undef;
- 
-  my $last = 0;
-  my $over = $x * $x;			# X ^ 2
-  my $x2 = $over->copy();		# X ^ 2; difference between terms
-  $over->bmul($x);			# X ^ 3 as starting value
-  my $sign = 1;				# start with -=
-  my $below = $self->new(6); my $factorial = $self->new(4);
-  delete $x->{_a}; delete $x->{_p};
-
-  my $limit = $self->new("1E-". ($scale-1));
-  #my $steps = 0;
-  while (3 < 5)
-    {
-    # we calculate the next term, and add it to the last
-    # when the next term is below our limit, it won't affect the outcome
-    # anymore, so we stop:
-    my $next = $over->copy()->bdiv($below,$scale);
-    last if $next->bacmp($limit) <= 0;
-
-    if ($sign == 0)
-      {
-      $x->badd($next);
-      }
-    else
-      {
-      $x->bsub($next);
-      }
-    $sign = 1-$sign;					# alternate
-    # calculate things for the next term
-    $over->bmul($x2);					# $x*$x
-    $below->bmul($factorial); $factorial->binc();	# n*(n+1)
-    $below->bmul($factorial); $factorial->binc();	# n*(n+1)
-    }
-
-  # shortcut to not run through _find_round_parameters again
-  if (defined $params[0])
-    {
-    $x->bround($params[0],$params[2]);		# then round accordingly
-    }
-  else
-    {
-    $x->bfround($params[1],$params[2]);		# then round accordingly
-    }
-  if ($fallback)
-    {
-    # clear a/p after round, since user did not request it
-    delete $x->{_a}; delete $x->{_p};
+    #         constant object       or error in _find_round_parameters?
+    return $x if $x->modify('bsin') || $x->is_nan();
+
+    return $x->bzero(@r) if $x->is_zero();
+
+    # no rounding at all, so must use fallback
+    if (scalar @params == 0) {
+        # simulate old behaviour
+        $params[0] = $class->div_scale(); # and round to it as accuracy
+        $params[1] = undef;               # disable P
+        $scale = $params[0]+4;            # at least four more for proper round
+        $params[2] = $r[2];               # round mode by caller or undef
+        $fallback = 1;                    # to clear a/p afterwards
+    } else {
+        # the 4 below is empirical, and there might be cases where it is not
+        # enough...
+        $scale = abs($params[0] || $params[1]) + 4; # take whatever is defined
     }
-  # restore globals
-  $$abr = $ab; $$pbr = $pb;
-  $x;
-  }
 
-sub batan2 {
-    # $y -> batan2($x) returns the arcus tangens of $y / $x.
+    # when user set globals, they would interfere with our calculation, so
+    # disable them and later re-enable them
+    no strict 'refs';
+    my $abr = "$class\::accuracy"; my $ab = $$abr; $$abr = undef;
+    my $pbr = "$class\::precision"; my $pb = $$pbr; $$pbr = undef;
+    # we also need to disable any set A or P on $x (_find_round_parameters took
+    # them already into account), since these would interfere, too
+    delete $x->{_a};
+    delete $x->{_p};
+    # need to disable $upgrade in BigInt, to avoid deep recursion
+    local $Math::BigInt::upgrade = undef;
 
-    # Set up parameters.
-    my ($self, $y, $x, @r) = (ref($_[0]), @_);
+    my $last = 0;
+    my $over = $x * $x;         # X ^ 2
+    my $x2 = $over->copy();     # X ^ 2; difference between terms
+    $over->bmul($x);            # X ^ 3 as starting value
+    my $sign = 1;               # start with -=
+    my $below = $class->new(6); my $factorial = $class->new(4);
+    delete $x->{_a};
+    delete $x->{_p};
 
-    # Objectify is costly, so avoid it if we can.
-    if ((!ref($_[0])) || (ref($_[0]) ne ref($_[1]))) {
-        ($self, $y, $x, @r) = objectify(2, @_);
+    my $limit = $class->new("1E-". ($scale-1));
+    #my $steps = 0;
+    while (3 < 5) {
+        # we calculate the next term, and add it to the last
+        # when the next term is below our limit, it won't affect the outcome
+        # anymore, so we stop:
+        my $next = $over->copy()->bdiv($below, $scale);
+        last if $next->bacmp($limit) <= 0;
+
+        if ($sign == 0) {
+            $x->badd($next);
+        } else {
+            $x->bsub($next);
+        }
+        $sign = 1-$sign;        # alternate
+        # calculate things for the next term
+        $over->bmul($x2);                         # $x*$x
+        $below->bmul($factorial); $factorial->binc(); # n*(n+1)
+        $below->bmul($factorial); $factorial->binc(); # n*(n+1)
     }
 
-    # Quick exit if $y is read-only.
-    return $y if $y -> modify('batan2');
+    # shortcut to not run through _find_round_parameters again
+    if (defined $params[0]) {
+        $x->bround($params[0], $params[2]); # then round accordingly
+    } else {
+        $x->bfround($params[1], $params[2]); # then round accordingly
+    }
+    if ($fallback) {
+        # clear a/p after round, since user did not request it
+        delete $x->{_a};
+        delete $x->{_p};
+    }
+    # restore globals
+    $$abr = $ab;
+    $$pbr = $pb;
+    $x;
+}
 
-    # Handle all NaN cases.
-    return $y -> bnan() if $x->{sign} eq $nan || $y->{sign} eq $nan;
+sub bcos {
+    # Calculate a cosinus of x.
+    my ($class, $x, @r) = ref($_[0]) ? (ref($_[0]), @_) : objectify(1, @_);
 
-    # We need to limit the accuracy to protect against overflow.
+    # Taylor:      x^2   x^4   x^6   x^8
+    #    cos = 1 - --- + --- - --- + --- ...
+    #               2!    4!    6!    8!
+
+    # we need to limit the accuracy to protect against overflow
     my $fallback = 0;
     my ($scale, @params);
-    ($y, @params) = $y -> _find_round_parameters(@r);
+    ($x, @params) = $x->_find_round_parameters(@r);
 
-    # Error in _find_round_parameters?
-    return $y if $y->is_nan();
+    #         constant object       or error in _find_round_parameters?
+    return $x if $x->modify('bcos') || $x->is_nan();
 
-    # No rounding at all, so must use fallback.
+    return $x->bone(@r) if $x->is_zero();
+
+    # no rounding at all, so must use fallback
     if (scalar @params == 0) {
-        # Simulate old behaviour
-        $params[0] = $self -> div_scale();  # and round to it as accuracy
-        $params[1] = undef;                 # disable P
-        $scale = $params[0] + 4;            # at least four more for proper round
-        $params[2] = $r[2];                 # round mode by caller or undef
-        $fallback = 1;                      # to clear a/p afterwards
+        # simulate old behaviour
+        $params[0] = $class->div_scale(); # and round to it as accuracy
+        $params[1] = undef;               # disable P
+        $scale = $params[0]+4;            # at least four more for proper round
+        $params[2] = $r[2];               # round mode by caller or undef
+        $fallback = 1;                    # to clear a/p afterwards
     } else {
-        # The 4 below is empirical, and there might be cases where it is not
-        # enough ...
+        # the 4 below is empirical, and there might be cases where it is not
+        # enough...
         $scale = abs($params[0] || $params[1]) + 4; # take whatever is defined
     }
 
-    if ($x -> is_inf("+")) {                            # x = inf
-        if ($y -> is_inf("+")) {                        #    y = inf
-            $y -> bpi($scale) -> bmul("0.25");          #       pi/4
-        } elsif ($y -> is_inf("-")) {                   #    y = -inf
-            $y -> bpi($scale) -> bmul("-0.25");         #       -pi/4
-        } else {                                        #    -inf < y < inf
-            return $y -> bzero(@r);                     #       0
-        }
-    }
+    # when user set globals, they would interfere with our calculation, so
+    # disable them and later re-enable them
+    no strict 'refs';
+    my $abr = "$class\::accuracy"; my $ab = $$abr; $$abr = undef;
+    my $pbr = "$class\::precision"; my $pb = $$pbr; $$pbr = undef;
+    # we also need to disable any set A or P on $x (_find_round_parameters took
+    # them already into account), since these would interfere, too
+    delete $x->{_a}; delete $x->{_p};
+    # need to disable $upgrade in BigInt, to avoid deep recursion
+    local $Math::BigInt::upgrade = undef;
 
-    elsif ($x -> is_inf("-")) {                         # x = -inf
-        if ($y -> is_inf("+")) {                        #    y = inf
-            $y -> bpi($scale) -> bmul("0.75");          #       3/4 pi
-        } elsif ($y -> is_inf("-")) {                   #    y = -inf
-            $y -> bpi($scale) -> bmul("-0.75");         #       -3/4 pi
-        } elsif ($y >= 0) {                             #    y >= 0
-            $y -> bpi($scale);                          #       pi
-        } else {                                        #    y < 0
-            $y -> bpi($scale) -> bneg();                #       -pi
-        }
-    }
+    my $last = 0;
+    my $over = $x * $x;         # X ^ 2
+    my $x2 = $over->copy();     # X ^ 2; difference between terms
+    my $sign = 1;               # start with -=
+    my $below = $class->new(2);
+    my $factorial = $class->new(3);
+    $x->bone();
+    delete $x->{_a};
+    delete $x->{_p};
 
-    elsif ($x > 0) {                                    # 0 < x < inf
-        if ($y -> is_inf("+")) {                        #    y = inf
-            $y -> bpi($scale) -> bmul("0.5");           #       pi/2
-        } elsif ($y -> is_inf("-")) {                   #    y = -inf
-            $y -> bpi($scale) -> bmul("-0.5");          #       -pi/2
-        } else {                                        #   -inf < y < inf
-            $y -> bdiv($x, $scale) -> batan($scale);    #       atan(y/x)
-        }
-    }
+    my $limit = $class->new("1E-". ($scale-1));
+    #my $steps = 0;
+    while (3 < 5) {
+        # we calculate the next term, and add it to the last
+        # when the next term is below our limit, it won't affect the outcome
+        # anymore, so we stop:
+        my $next = $over->copy()->bdiv($below, $scale);
+        last if $next->bacmp($limit) <= 0;
 
-    elsif ($x < 0) {                                    # -inf < x < 0
-        my $pi = $class -> bpi($scale);
-        if ($y >= 0) {                                  #    y >= 0
-            $y -> bdiv($x, $scale) -> batan()           #       atan(y/x) + pi
-               -> badd($pi);
-        } else {                                        #    y < 0
-            $y -> bdiv($x, $scale) -> batan()           #       atan(y/x) - pi
-               -> bsub($pi);
+        if ($sign == 0) {
+            $x->badd($next);
+        } else {
+            $x->bsub($next);
         }
+        $sign = 1-$sign;        # alternate
+        # calculate things for the next term
+        $over->bmul($x2);                         # $x*$x
+        $below->bmul($factorial); $factorial->binc(); # n*(n+1)
+        $below->bmul($factorial); $factorial->binc(); # n*(n+1)
     }
 
-    else {                                              # x = 0
-        if ($y > 0) {                                   #    y > 0
-            $y -> bpi($scale) -> bmul("0.5");           #       pi/2
-        } elsif ($y < 0) {                              #    y < 0
-            $y -> bpi($scale) -> bmul("-0.5");          #       -pi/2
-        } else {                                        #    y = 0
-            return $y -> bzero(@r);                     #       0
-        }
+    # shortcut to not run through _find_round_parameters again
+    if (defined $params[0]) {
+        $x->bround($params[0], $params[2]); # then round accordingly
+    } else {
+        $x->bfround($params[1], $params[2]); # then round accordingly
     }
-
-    $y -> round(@r);
-
     if ($fallback) {
-        delete $y->{_a};
-        delete $y->{_p};
+        # clear a/p after round, since user did not request it
+        delete $x->{_a};
+        delete $x->{_p};
     }
-
-    return $y;
+    # restore globals
+    $$abr = $ab;
+    $$pbr = $pb;
+    $x;
 }
 
 sub batan {
@@ -3342,7 +2701,7 @@ sub batan {
         $self->{_e} = $pi->{_e};
         $self->{_es} = $pi->{_es};
         # -y => -PI/2, +y => PI/2
-        $self->{sign} = substr($self->{sign}, 0, 1);  # "+inf" => "+"
+        $self->{sign} = substr($self->{sign}, 0, 1); # "+inf" => "+"
         $MBI->_div($self->{_m}, $MBI->_new(2));
         return $self;
     }
@@ -3352,7 +2711,7 @@ sub batan {
     # no rounding at all, so must use fallback
     if (scalar @params == 0) {
         # simulate old behaviour
-        $params[0] = $class->div_scale();  # and round to it as accuracy
+        $params[0] = $class->div_scale(); # and round to it as accuracy
         $params[1] = undef;               # disable P
         $scale = $params[0]+4;            # at least four more for proper round
         $params[2] = $r[2];               # round mode by caller or undef
@@ -3380,20 +2739,21 @@ sub batan {
     # calculate PI/2 - atan(1/x):
     my $one = $MBI->_new(1);
     my $pi = undef;
-    if ($self->bacmp($self->copy->bone) >= 0) {
+    if ($self->bacmp($self->copy()->bone) >= 0) {
         # calculate PI/2
         $pi = $class->bpi($scale - 3);
         $MBI->_div($pi->{_m}, $MBI->_new(2));
         # calculate 1/$self:
         my $self_copy = $self->copy();
         # modify $self in place
-        $self->bone(); $self->bdiv($self_copy, $scale);
+        $self->bone();
+        $self->bdiv($self_copy, $scale);
     }
 
     my $fmul = 1;
     foreach my $k (0 .. int($scale / 20)) {
         $fmul *= 2;
-        $self->bdiv($self->copy->bmul($self)->binc->bsqrt($scale + 4)->binc, $scale + 4);
+        $self->bdiv($self->copy()->bmul($self)->binc->bsqrt($scale + 4)->binc, $scale + 4);
     }
 
     # When user set globals, they would interfere with our calculation, so
@@ -3403,18 +2763,20 @@ sub batan {
     my $pbr = "$class\::precision"; my $pb = $$pbr; $$pbr = undef;
     # We also need to disable any set A or P on $self (_find_round_parameters
     # took them already into account), since these would interfere, too
-    delete $self->{_a}; delete $self->{_p};
+    delete $self->{_a};
+    delete $self->{_p};
     # Need to disable $upgrade in BigInt, to avoid deep recursion.
     local $Math::BigInt::upgrade = undef;
 
     my $last = 0;
-    my $over = $self * $self;		# X ^ 2
-    my $self2 = $over->copy();		# X ^ 2; difference between terms
-    $over->bmul($self);			# X ^ 3 as starting value
-    my $sign = 1;			# start with -=
+    my $over = $self * $self;   # X ^ 2
+    my $self2 = $over->copy();  # X ^ 2; difference between terms
+    $over->bmul($self);         # X ^ 3 as starting value
+    my $sign = 1;               # start with -=
     my $below = $class->new(3);
     my $two = $class->new(2);
-    delete $self->{_a}; delete $self->{_p};
+    delete $self->{_a};
+    delete $self->{_p};
 
     my $limit = $class->new("1E-". ($scale-1));
     #my $steps = 0;
@@ -3455,1191 +2817,2152 @@ sub batan {
     }
     if ($fallback) {
         # Clear a/p after round, since user did not request it.
-        delete $self->{_a}; delete $self->{_p};
+        delete $self->{_a};
+        delete $self->{_p};
     }
 
     # restore globals
-    $$abr = $ab; $$pbr = $pb;
+    $$abr = $ab;
+    $$pbr = $pb;
     $self;
 }
 
-###############################################################################
-# rounding functions
-
-sub bfround
-  {
-  # precision: round to the $Nth digit left (+$n) or right (-$n) from the '.'
-  # $n == 0 means round to integer
-  # expects and returns normalized numbers!
-  my $x = shift; my $self = ref($x) || $x; $x = $self->new(shift) if !ref($x);
+sub batan2 {
+    # $y -> batan2($x) returns the arcus tangens of $y / $x.
 
-  my ($scale,$mode) = $x->_scale_p(@_);
-  return $x if !defined $scale || $x->modify('bfround'); # no-op
+    # Set up parameters.
+    my ($class, $y, $x, @r) = (ref($_[0]), @_);
 
-  # never round a 0, +-inf, NaN
-  if ($x->is_zero())
-    {
-    $x->{_p} = $scale if !defined $x->{_p} || $x->{_p} < $scale; # -3 < -2
-    return $x; 
+    # Objectify is costly, so avoid it if we can.
+    if ((!ref($_[0])) || (ref($_[0]) ne ref($_[1]))) {
+        ($class, $y, $x, @r) = objectify(2, @_);
     }
-  return $x if $x->{sign} !~ /^[+-]$/;
 
-  # don't round if x already has lower precision
-  return $x if (defined $x->{_p} && $x->{_p} < 0 && $scale < $x->{_p});
+    # Quick exit if $y is read-only.
+    return $y if $y -> modify('batan2');
 
-  $x->{_p} = $scale;			# remember round in any case
-  delete $x->{_a};			# and clear A
-  if ($scale < 0)
-    {
-    # round right from the '.'
-
-    return $x if $x->{_es} eq '+';		# e >= 0 => nothing to round
-
-    $scale = -$scale;				# positive for simplicity
-    my $len = $MBI->_len($x->{_m});		# length of mantissa
-
-    # the following poses a restriction on _e, but if _e is bigger than a
-    # scalar, you got other problems (memory etc) anyway
-    my $dad = -(0+ ($x->{_es}.$MBI->_num($x->{_e})));	# digits after dot
-    my $zad = 0;				# zeros after dot
-    $zad = $dad - $len if (-$dad < -$len);	# for 0.00..00xxx style
-   
-    # print "scale $scale dad $dad zad $zad len $len\n";
-    # number  bsstr   len zad dad	
-    # 0.123   123e-3	3   0 3
-    # 0.0123  123e-4	3   1 4
-    # 0.001   1e-3      1   2 3
-    # 1.23    123e-2	3   0 2
-    # 1.2345  12345e-4	5   0 4
-
-    # do not round after/right of the $dad
-    return $x if $scale > $dad;			# 0.123, scale >= 3 => exit
-
-    # round to zero if rounding inside the $zad, but not for last zero like:
-    # 0.0065, scale -2, round last '0' with following '65' (scale == zad case)
-    return $x->bzero() if $scale < $zad;
-    if ($scale == $zad)			# for 0.006, scale -3 and trunc
-      {
-      $scale = -$len;
-      }
-    else
-      {
-      # adjust round-point to be inside mantissa
-      if ($zad != 0)
-        {
-	$scale = $scale-$zad;
+    # Handle all NaN cases.
+    return $y -> bnan() if $x->{sign} eq $nan || $y->{sign} eq $nan;
+
+    # We need to limit the accuracy to protect against overflow.
+    my $fallback = 0;
+    my ($scale, @params);
+    ($y, @params) = $y -> _find_round_parameters(@r);
+
+    # Error in _find_round_parameters?
+    return $y if $y->is_nan();
+
+    # No rounding at all, so must use fallback.
+    if (scalar @params == 0) {
+        # Simulate old behaviour
+        $params[0] = $class -> div_scale(); # and round to it as accuracy
+        $params[1] = undef;                 # disable P
+        $scale = $params[0] + 4; # at least four more for proper round
+        $params[2] = $r[2];      # round mode by caller or undef
+        $fallback = 1;           # to clear a/p afterwards
+    } else {
+        # The 4 below is empirical, and there might be cases where it is not
+        # enough ...
+        $scale = abs($params[0] || $params[1]) + 4; # take whatever is defined
+    }
+
+    if ($x -> is_inf("+")) {                    # x = inf
+        if ($y -> is_inf("+")) {                #    y = inf
+            $y -> bpi($scale) -> bmul("0.25");  #       pi/4
+        } elsif ($y -> is_inf("-")) {           #    y = -inf
+            $y -> bpi($scale) -> bmul("-0.25"); #       -pi/4
+        } else {                                #    -inf < y < inf
+            return $y -> bzero(@r);             #       0
         }
-      else
-        {
-        my $dbd = $len - $dad; $dbd = 0 if $dbd < 0;	# digits before dot
-	$scale = $dbd+$scale;
+    } elsif ($x -> is_inf("-")) {               # x = -inf
+        if ($y -> is_inf("+")) {                #    y = inf
+            $y -> bpi($scale) -> bmul("0.75");  #       3/4 pi
+        } elsif ($y -> is_inf("-")) {           #    y = -inf
+            $y -> bpi($scale) -> bmul("-0.75"); #       -3/4 pi
+        } elsif ($y >= 0) {                     #    y >= 0
+            $y -> bpi($scale);                  #       pi
+        } else {                                #    y < 0
+            $y -> bpi($scale) -> bneg();        #       -pi
+        }
+    } elsif ($x > 0) {                               # 0 < x < inf
+        if ($y -> is_inf("+")) {                     #    y = inf
+            $y -> bpi($scale) -> bmul("0.5");        #       pi/2
+        } elsif ($y -> is_inf("-")) {                #    y = -inf
+            $y -> bpi($scale) -> bmul("-0.5");       #       -pi/2
+        } else {                                     #   -inf < y < inf
+            $y -> bdiv($x, $scale) -> batan($scale); #       atan(y/x)
+        }
+    } elsif ($x < 0) {          # -inf < x < 0
+        my $pi = $class -> bpi($scale);
+        if ($y >= 0) {                        #    y >= 0
+            $y -> bdiv($x, $scale) -> batan() #       atan(y/x) + pi
+              -> badd($pi);
+        } else {                              #    y < 0
+            $y -> bdiv($x, $scale) -> batan() #       atan(y/x) - pi
+              -> bsub($pi);
+        }
+    } else {                                   # x = 0
+        if ($y > 0) {                          #    y > 0
+            $y -> bpi($scale) -> bmul("0.5");  #       pi/2
+        } elsif ($y < 0) {                     #    y < 0
+            $y -> bpi($scale) -> bmul("-0.5"); #       -pi/2
+        } else {                               #    y = 0
+            return $y -> bzero(@r);            #       0
         }
-      }
     }
-  else
-    {
-    # round left from the '.'
-
-    # 123 => 100 means length(123) = 3 - $scale (2) => 1
-
-    my $dbt = $MBI->_len($x->{_m}); 
-    # digits before dot 
-    my $dbd = $dbt + ($x->{_es} . $MBI->_num($x->{_e}));
-    # should be the same, so treat it as this 
-    $scale = 1 if $scale == 0; 
-    # shortcut if already integer 
-    return $x if $scale == 1 && $dbt <= $dbd; 
-    # maximum digits before dot 
-    ++$dbd;
-
-    if ($scale > $dbd) 
-       { 
-       # not enough digits before dot, so round to zero 
-       return $x->bzero; 
-       }
-    elsif ( $scale == $dbd )
-       { 
-       # maximum 
-       $scale = -$dbt; 
-       } 
-    else
-       { 
-       $scale = $dbd - $scale; 
-       }
-    }
-  # pass sign to bround for rounding modes '+inf' and '-inf'
-  my $m = bless { sign => $x->{sign}, value => $x->{_m} }, 'Math::BigInt';
-  $m->bround($scale,$mode);
-  $x->{_m} = $m->{value};			# get our mantissa back
-  $x->bnorm();
-  }
-
-sub bround
-  {
-  # accuracy: preserve $N digits, and overwrite the rest with 0's
-  my $x = shift; my $self = ref($x) || $x; $x = $self->new(shift) if !ref($x);
-
-  if (($_[0] || 0) < 0)
-    {
-    require Carp; Carp::croak ('bround() needs positive accuracy');
+
+    $y -> round(@r);
+
+    if ($fallback) {
+        delete $y->{_a};
+        delete $y->{_p};
     }
 
-  my ($scale,$mode) = $x->_scale_a(@_);
-  return $x if !defined $scale || $x->modify('bround');	# no-op
+    return $y;
+}
+##############################################################################
+
+sub bsqrt {
+    # calculate square root
+    my ($class, $x, $a, $p, $r) = ref($_[0]) ? (ref($_[0]), @_) : objectify(1, @_);
 
-  # scale is now either $x->{_a}, $accuracy, or the user parameter
-  # test whether $x already has lower accuracy, do nothing in this case 
-  # but do round if the accuracy is the same, since a math operation might
-  # want to round a number with A=5 to 5 digits afterwards again
-  return $x if defined $x->{_a} && $x->{_a} < $scale;
+    return $x if $x->modify('bsqrt');
 
-  # scale < 0 makes no sense
-  # scale == 0 => keep all digits
-  # never round a +-inf, NaN
-  return $x if ($scale <= 0) || $x->{sign} !~ /^[+-]$/;
+    return $x->bnan() if $x->{sign} !~ /^[+]/; # NaN, -inf or < 0
+    return $x if $x->{sign} eq '+inf';         # sqrt(inf) == inf
+    return $x->round($a, $p, $r) if $x->is_zero() || $x->is_one();
 
-  # 1: never round a 0
-  # 2: if we should keep more digits than the mantissa has, do nothing
-  if ($x->is_zero() || $MBI->_len($x->{_m}) <= $scale)
-    {
-    $x->{_a} = $scale if !defined $x->{_a} || $x->{_a} > $scale;
-    return $x; 
+    # we need to limit the accuracy to protect against overflow
+    my $fallback = 0;
+    my (@params, $scale);
+    ($x, @params) = $x->_find_round_parameters($a, $p, $r);
+
+    return $x if $x->is_nan();  # error in _find_round_parameters?
+
+    # no rounding at all, so must use fallback
+    if (scalar @params == 0) {
+        # simulate old behaviour
+        $params[0] = $class->div_scale(); # and round to it as accuracy
+        $scale = $params[0]+4;            # at least four more for proper round
+        $params[2] = $r;                  # round mode by caller or undef
+        $fallback = 1;                    # to clear a/p afterwards
+    } else {
+        # the 4 below is empirical, and there might be cases where it is not
+        # enough...
+        $scale = abs($params[0] || $params[1]) + 4; # take whatever is defined
     }
 
-  # pass sign to bround for '+inf' and '-inf' rounding modes
-  my $m = bless { sign => $x->{sign}, value => $x->{_m} }, 'Math::BigInt';
+    # when user set globals, they would interfere with our calculation, so
+    # disable them and later re-enable them
+    no strict 'refs';
+    my $abr = "$class\::accuracy"; my $ab = $$abr; $$abr = undef;
+    my $pbr = "$class\::precision"; my $pb = $$pbr; $$pbr = undef;
+    # we also need to disable any set A or P on $x (_find_round_parameters took
+    # them already into account), since these would interfere, too
+    delete $x->{_a};
+    delete $x->{_p};
+    # need to disable $upgrade in BigInt, to avoid deep recursion
+    local $Math::BigInt::upgrade = undef; # should be really parent class vs MBI
+
+    my $i = $MBI->_copy($x->{_m});
+    $MBI->_lsft($i, $x->{_e}, 10) unless $MBI->_is_zero($x->{_e});
+    my $xas = Math::BigInt->bzero();
+    $xas->{value} = $i;
+
+    my $gs = $xas->copy()->bsqrt(); # some guess
+
+    if (($x->{_es} ne '-')           # guess can't be accurate if there are
+        # digits after the dot
+        && ($xas->bacmp($gs * $gs) == 0)) # guess hit the nail on the head?
+    {
+        # exact result, copy result over to keep $x
+        $x->{_m} = $gs->{value};
+        $x->{_e} = $MBI->_zero();
+        $x->{_es} = '+';
+        $x->bnorm();
+        # shortcut to not run through _find_round_parameters again
+        if (defined $params[0]) {
+            $x->bround($params[0], $params[2]); # then round accordingly
+        } else {
+            $x->bfround($params[1], $params[2]); # then round accordingly
+        }
+        if ($fallback) {
+            # clear a/p after round, since user did not request it
+            delete $x->{_a};
+            delete $x->{_p};
+        }
+        # re-enable A and P, upgrade is taken care of by "local"
+        ${"$class\::accuracy"} = $ab;
+        ${"$class\::precision"} = $pb;
+        return $x;
+    }
 
-  $m->bround($scale,$mode);		# round mantissa
-  $x->{_m} = $m->{value};		# get our mantissa back
-  $x->{_a} = $scale;			# remember rounding
-  delete $x->{_p};			# and clear P
-  $x->bnorm();				# del trailing zeros gen. by bround()
-  }
+    # sqrt(2) = 1.4 because sqrt(2*100) = 1.4*10; so we can increase the accuracy
+    # of the result by multiplying the input by 100 and then divide the integer
+    # result of sqrt(input) by 10. Rounding afterwards returns the real result.
 
-sub bfloor
-  {
-  # round towards minus infinity
-  my ($self,$x,$a,$p,$r) = ref($_[0]) ? (ref($_[0]),@_) : objectify(1,@_);
+    # The following steps will transform 123.456 (in $x) into 123456 (in $y1)
+    my $y1 = $MBI->_copy($x->{_m});
 
-  return $x if $x->modify('bfloor');
-   
-  return $x if $x->{sign} !~ /^[+-]$/;	# nan, +inf, -inf
+    my $length = $MBI->_len($y1);
 
-  # if $x has digits after dot
-  if ($x->{_es} eq '-')
-    {
-    $x->{_m} = $MBI->_rsft($x->{_m},$x->{_e},10); # cut off digits after dot
-    $x->{_e} = $MBI->_zero();			# trunc/norm	
-    $x->{_es} = '+';				# abs e
-    $MBI->_inc($x->{_m}) if $x->{sign} eq '-';	# increment if negative
-    }
-  $x->round($a,$p,$r);
-  }
+    # Now calculate how many digits the result of sqrt(y1) would have
+    my $digits = int($length / 2);
 
-sub bceil
-  {
-  # round towards plus infinity
-  my ($self,$x,$a,$p,$r) = ref($_[0]) ? (ref($_[0]),@_) : objectify(1,@_);
+    # But we need at least $scale digits, so calculate how many are missing
+    my $shift = $scale - $digits;
 
-  return $x if $x->modify('bceil');
-  return $x if $x->{sign} !~ /^[+-]$/;	# nan, +inf, -inf
+    # This happens if the input had enough digits
+    # (we take care of integer guesses above)
+    $shift = 0 if $shift < 0;
 
-  # if $x has digits after dot
-  if ($x->{_es} eq '-')
-    {
-    $x->{_m} = $MBI->_rsft($x->{_m},$x->{_e},10); # cut off digits after dot
-    $x->{_e} = $MBI->_zero();			# trunc/norm	
-    $x->{_es} = '+';				# abs e
-    if ($x->{sign} eq '+') {
-        $MBI->_inc($x->{_m});                   # increment if positive
+    # Multiply in steps of 100, by shifting left two times the "missing" digits
+    my $s2 = $shift * 2;
+
+    # We now make sure that $y1 has the same odd or even number of digits than
+    # $x had. So when _e of $x is odd, we must shift $y1 by one digit left,
+    # because we always must multiply by steps of 100 (sqrt(100) is 10) and not
+    # steps of 10. The length of $x does not count, since an even or odd number
+    # of digits before the dot is not changed by adding an even number of digits
+    # after the dot (the result is still odd or even digits long).
+    $s2++ if $MBI->_is_odd($x->{_e});
+
+    $MBI->_lsft($y1, $MBI->_new($s2), 10);
+
+    # now take the square root and truncate to integer
+    $y1 = $MBI->_sqrt($y1);
+
+    # By "shifting" $y1 right (by creating a negative _e) we calculate the final
+    # result, which is than later rounded to the desired scale.
+
+    # calculate how many zeros $x had after the '.' (or before it, depending
+    # on sign of $dat, the result should have half as many:
+    my $dat = $MBI->_num($x->{_e});
+    $dat = -$dat if $x->{_es} eq '-';
+    $dat += $length;
+
+    if ($dat > 0) {
+        # no zeros after the dot (e.g. 1.23, 0.49 etc)
+        # preserve half as many digits before the dot than the input had
+        # (but round this "up")
+        $dat = int(($dat+1)/2);
     } else {
-        $x->{sign} = '+' if $MBI->_is_zero($x->{_m});   # avoid -0
+        $dat = int(($dat)/2);
     }
+    $dat -= $MBI->_len($y1);
+    if ($dat < 0) {
+        $dat = abs($dat);
+        $x->{_e} = $MBI->_new($dat);
+        $x->{_es} = '-';
+    } else {
+        $x->{_e} = $MBI->_new($dat);
+        $x->{_es} = '+';
     }
-  $x->round($a,$p,$r);
-  }
+    $x->{_m} = $y1;
+    $x->bnorm();
 
-sub bint
-  {
-  # round towards zero
-  my ($self,$x,$a,$p,$r) = ref($_[0]) ? (ref($_[0]),@_) : objectify(1,@_);
+    # shortcut to not run through _find_round_parameters again
+    if (defined $params[0]) {
+        $x->bround($params[0], $params[2]); # then round accordingly
+    } else {
+        $x->bfround($params[1], $params[2]); # then round accordingly
+    }
+    if ($fallback) {
+        # clear a/p after round, since user did not request it
+        delete $x->{_a};
+        delete $x->{_p};
+    }
+    # restore globals
+    $$abr = $ab;
+    $$pbr = $pb;
+    $x;
+}
 
-  return $x if $x->modify('bint');
-  return $x if $x->{sign} !~ /^[+-]$/;  # nan, +inf, -inf
+sub broot {
+    # calculate $y'th root of $x
 
-  # if $x has digits after the decimal point
-  if ($x->{_es} eq '-')
-    {
-    $x->{_m} = $MBI->_rsft($x->{_m},$x->{_e},10); # cut off digits after dot
-    $x->{_e} = $MBI->_zero();                     # truncate/normalize
-    $x->{_es} = '+';                              # abs e
-    $x->{sign} = '+' if $MBI->_is_zero($x->{_m}); # avoid -0
-    }
-  $x->round($a,$p,$r);
-  }
-
-sub brsft
-  {
-  # shift right by $y (divide by power of $n)
-  
-  # set up parameters
-  my ($self,$x,$y,$n,$a,$p,$r) = (ref($_[0]),@_);
-  # objectify is costly, so avoid it
-  if ((!ref($_[0])) || (ref($_[0]) ne ref($_[1])))
-    {
-    ($self,$x,$y,$n,$a,$p,$r) = objectify(2,@_);
+    # set up parameters
+    my ($class, $x, $y, $a, $p, $r) = (ref($_[0]), @_);
+    # objectify is costly, so avoid it
+    if ((!ref($_[0])) || (ref($_[0]) ne ref($_[1]))) {
+        ($class, $x, $y, $a, $p, $r) = objectify(2, @_);
     }
 
-  return $x if $x->modify('brsft');
-  return $x if $x->{sign} !~ /^[+-]$/;	# nan, +inf, -inf
+    return $x if $x->modify('broot');
 
-  $n = 2 if !defined $n; $n = $self->new($n);
+    # NaN handling: $x ** 1/0, x or y NaN, or y inf/-inf or y == 0
+    return $x->bnan() if $x->{sign} !~ /^\+/ || $y->is_zero() ||
+      $y->{sign} !~ /^\+$/;
 
-  # negative amount?
-  return $x->blsft($y->copy()->babs(),$n) if $y->{sign} =~ /^-/;
+    return $x if $x->is_zero() || $x->is_one() || $x->is_inf() || $y->is_one();
 
-  # the following call to bdiv() will return either quo or (quo,remainder):
-  $x->bdiv($n->bpow($y),$a,$p,$r,$y);
-  }
+    # we need to limit the accuracy to protect against overflow
+    my $fallback = 0;
+    my (@params, $scale);
+    ($x, @params) = $x->_find_round_parameters($a, $p, $r);
 
-sub blsft
-  {
-  # shift left by $y (multiply by power of $n)
-  
-  # set up parameters
-  my ($self,$x,$y,$n,$a,$p,$r) = (ref($_[0]),@_);
-  # objectify is costly, so avoid it
-  if ((!ref($_[0])) || (ref($_[0]) ne ref($_[1])))
-    {
-    ($self,$x,$y,$n,$a,$p,$r) = objectify(2,@_);
+    return $x if $x->is_nan();  # error in _find_round_parameters?
+
+    # no rounding at all, so must use fallback
+    if (scalar @params == 0) {
+        # simulate old behaviour
+        $params[0] = $class->div_scale(); # and round to it as accuracy
+        $scale = $params[0]+4;            # at least four more for proper round
+        $params[2] = $r;                  # round mode by caller or undef
+        $fallback = 1;                    # to clear a/p afterwards
+    } else {
+        # the 4 below is empirical, and there might be cases where it is not
+        # enough...
+        $scale = abs($params[0] || $params[1]) + 4; # take whatever is defined
     }
 
-  return $x if $x->modify('blsft');
-  return $x if $x->{sign} !~ /^[+-]$/;	# nan, +inf, -inf
+    # when user set globals, they would interfere with our calculation, so
+    # disable them and later re-enable them
+    no strict 'refs';
+    my $abr = "$class\::accuracy"; my $ab = $$abr; $$abr = undef;
+    my $pbr = "$class\::precision"; my $pb = $$pbr; $$pbr = undef;
+    # we also need to disable any set A or P on $x (_find_round_parameters took
+    # them already into account), since these would interfere, too
+    delete $x->{_a};
+    delete $x->{_p};
+    # need to disable $upgrade in BigInt, to avoid deep recursion
+    local $Math::BigInt::upgrade = undef; # should be really parent class vs MBI
+
+    # remember sign and make $x positive, since -4 ** (1/2) => -2
+    my $sign = 0;
+    $sign = 1 if $x->{sign} eq '-';
+    $x->{sign} = '+';
 
-  $n = 2 if !defined $n; $n = $self->new($n);
+    my $is_two = 0;
+    if ($y->isa('Math::BigFloat')) {
+        $is_two = ($y->{sign} eq '+' && $MBI->_is_two($y->{_m}) && $MBI->_is_zero($y->{_e}));
+    } else {
+        $is_two = ($y == 2);
+    }
+
+    # normal square root if $y == 2:
+    if ($is_two) {
+        $x->bsqrt($scale+4);
+    } elsif ($y->is_one('-')) {
+        # $x ** -1 => 1/$x
+        my $u = $class->bone()->bdiv($x, $scale);
+        # copy private parts over
+        $x->{_m} = $u->{_m};
+        $x->{_e} = $u->{_e};
+        $x->{_es} = $u->{_es};
+    } else {
+        # calculate the broot() as integer result first, and if it fits, return
+        # it rightaway (but only if $x and $y are integer):
+
+        my $done = 0;           # not yet
+        if ($y->is_int() && $x->is_int()) {
+            my $i = $MBI->_copy($x->{_m});
+            $MBI->_lsft($i, $x->{_e}, 10) unless $MBI->_is_zero($x->{_e});
+            my $int = Math::BigInt->bzero();
+            $int->{value} = $i;
+            $int->broot($y->as_number());
+            # if ($exact)
+            if ($int->copy()->bpow($y) == $x) {
+                # found result, return it
+                $x->{_m} = $int->{value};
+                $x->{_e} = $MBI->_zero();
+                $x->{_es} = '+';
+                $x->bnorm();
+                $done = 1;
+            }
+        }
+        if ($done == 0) {
+            my $u = $class->bone()->bdiv($y, $scale+4);
+            delete $u->{_a}; delete $u->{_p}; # otherwise it conflicts
+            $x->bpow($u, $scale+4);            # el cheapo
+        }
+    }
+    $x->bneg() if $sign == 1;
 
-  # negative amount?
-  return $x->brsft($y->copy()->babs(),$n) if $y->{sign} =~ /^-/;
+    # shortcut to not run through _find_round_parameters again
+    if (defined $params[0]) {
+        $x->bround($params[0], $params[2]); # then round accordingly
+    } else {
+        $x->bfround($params[1], $params[2]); # then round accordingly
+    }
+    if ($fallback) {
+        # clear a/p after round, since user did not request it
+        delete $x->{_a};
+        delete $x->{_p};
+    }
+    # restore globals
+    $$abr = $ab;
+    $$pbr = $pb;
+    $x;
+}
 
-  $x->bmul($n->bpow($y),$a,$p,$r,$y);
-  }
+sub bfac {
+    # (BFLOAT or num_str, BFLOAT or num_str) return BFLOAT
+    # compute factorial number, modifies first argument
 
-###############################################################################
+    # set up parameters
+    my ($class, $x, @r) = (ref($_[0]), @_);
+    # objectify is costly, so avoid it
+    ($class, $x, @r) = objectify(1, @_) if !ref($x);
 
-sub DESTROY
-  {
-  # going through AUTOLOAD for every DESTROY is costly, avoid it by empty sub
-  }
-
-sub AUTOLOAD
-  {
-  # make fxxx and bxxx both work by selectively mapping fxxx() to MBF::bxxx()
-  # or falling back to MBI::bxxx()
-  my $name = $AUTOLOAD;
-
-  $name =~ s/(.*):://;	# split package
-  my $c = $1 || $class;
-  no strict 'refs';
-  $c->import() if $IMPORT == 0;
-  if (!_method_alias($name))
-    {
-    if (!defined $name)
-      {
-      # delayed load of Carp and avoid recursion	
-      require Carp;
-      Carp::croak ("$c: Can't call a method without name");
-      }
-    if (!_method_hand_up($name))
-      {
-      # delayed load of Carp and avoid recursion	
-      require Carp;
-      Carp::croak ("Can't call $c\-\>$name, not a valid method");
-      }
-    # try one level up, but subst. bxxx() for fxxx() since MBI only got bxxx()
-    $name =~ s/^f/b/;
-    return &{"Math::BigInt"."::$name"}(@_);
-    }
-  my $bname = $name; $bname =~ s/^f/b/;
-  $c .= "::$name";
-  *{$c} = \&{$bname};
-  &{$c};	# uses @_
-  }
-
-sub exponent
-  {
-  # return a copy of the exponent
-  my ($self,$x) = ref($_[0]) ? (ref($_[0]),$_[0]) : objectify(1,@_);
-
-  if ($x->{sign} !~ /^[+-]$/)
-    {
-    my $s = $x->{sign}; $s =~ s/^[+-]//;
-    return Math::BigInt->new($s); 		# -inf, +inf => +inf
-    }
-  Math::BigInt->new( $x->{_es} . $MBI->_str($x->{_e}));
-  }
-
-sub mantissa
-  {
-  # return a copy of the mantissa
-  my ($self,$x) = ref($_[0]) ? (ref($_[0]),$_[0]) : objectify(1,@_);
- 
-  if ($x->{sign} !~ /^[+-]$/)
-    {
-    my $s = $x->{sign}; $s =~ s/^[+]//;
-    return Math::BigInt->new($s);		# -inf, +inf => +inf
+    # inf => inf
+    return $x if $x->modify('bfac') || $x->{sign} eq '+inf';
+
+    return $x->bnan()
+      if (($x->{sign} ne '+') || # inf, NaN, <0 etc => NaN
+          ($x->{_es} ne '+'));   # digits after dot?
+
+    # use BigInt's bfac() for faster calc
+    if (! $MBI->_is_zero($x->{_e})) {
+        $MBI->_lsft($x->{_m}, $x->{_e}, 10); # change 12e1 to 120e0
+        $x->{_e} = $MBI->_zero();           # normalize
+        $x->{_es} = '+';
     }
-  my $m = Math::BigInt->new( $MBI->_str($x->{_m}));
-  $m->bneg() if $x->{sign} eq '-';
+    $MBI->_fac($x->{_m});       # calculate factorial
+    $x->bnorm()->round(@r);     # norm again and round result
+}
 
-  $m;
-  }
+sub blsft {
+    # shift left by $y (multiply by $b ** $y)
 
-sub parts
-  {
-  # return a copy of both the exponent and the mantissa
-  my ($self,$x) = ref($_[0]) ? (ref($_[0]),$_[0]) : objectify(1,@_);
+    # set up parameters
+    my ($class, $x, $y, $b, $a, $p, $r) = (ref($_[0]), @_);
 
-  if ($x->{sign} !~ /^[+-]$/)
-    {
-    my $s = $x->{sign}; $s =~ s/^[+]//; my $se = $s; $se =~ s/^[-]//;
-    return ($self->new($s),$self->new($se)); # +inf => inf and -inf,+inf => inf
+    # objectify is costly, so avoid it
+    if ((!ref($_[0])) || (ref($_[0]) ne ref($_[1]))) {
+        ($class, $x, $y, $b, $a, $p, $r) = objectify(2, @_);
     }
-  my $m = Math::BigInt->bzero();
-  $m->{value} = $MBI->_copy($x->{_m});
-  $m->bneg() if $x->{sign} eq '-';
-  ($m, Math::BigInt->new( $x->{_es} . $MBI->_num($x->{_e}) ));
-  }
 
-##############################################################################
-# private stuff (internal use only)
-
-sub import
-  {
-  my $self = shift;
-  my $l = scalar @_;
-  my $lib = ''; my @a;
-  my $lib_kind = 'try';
-  $IMPORT=1;
-  for ( my $i = 0; $i < $l ; $i++)
-    {
-    if ( $_[$i] eq ':constant' )
-      {
-      # This causes overlord er load to step in. 'binary' and 'integer'
-      # are handled by BigInt.
-      overload::constant float => sub { $self->new(shift); }; 
-      }
-    elsif ($_[$i] eq 'upgrade')
-      {
-      # this causes upgrading
-      $upgrade = $_[$i+1];		# or undef to disable
-      $i++;
-      }
-    elsif ($_[$i] eq 'downgrade')
-      {
-      # this causes downgrading
-      $downgrade = $_[$i+1];		# or undef to disable
-      $i++;
-      }
-    elsif ($_[$i] =~ /^(lib|try|only)\z/)
-      {
-      # alternative library
-      $lib = $_[$i+1] || '';		# default Calc
-      $lib_kind = $1;			# lib, try or only
-      $i++;
-      }
-    elsif ($_[$i] eq 'with')
-      {
-      # alternative class for our private parts()
-      # XXX: no longer supported
-      # $MBI = $_[$i+1] || 'Math::BigInt';
-      $i++;
-      }
-    else
-      {
-      push @a, $_[$i];
-      }
-    }
-
-  $lib =~ tr/a-zA-Z0-9,://cd;		# restrict to sane characters
-  # let use Math::BigInt lib => 'GMP'; use Math::BigFloat; still work
-  my $mbilib = eval { Math::BigInt->config()->{lib} };
-  if ((defined $mbilib) && ($MBI eq 'Math::BigInt::Calc'))
-    {
-    # MBI already loaded
-    Math::BigInt->import( $lib_kind, "$lib,$mbilib", 'objectify');
+    return $x if $x -> modify('blsft');
+    return $x if $x -> {sign} !~ /^[+-]$/; # nan, +inf, -inf
+
+    $b = 2 if !defined $b;
+    $b = $class -> new($b) unless ref($b) && $b -> isa($class);
+
+    return $x -> bnan() if $x -> is_nan() || $y -> is_nan() || $b -> is_nan();
+
+    # shift by a negative amount?
+    return $x -> brsft($y -> copy() -> babs(), $b) if $y -> {sign} =~ /^-/;
+
+    $x -> bmul($b -> bpow($y), $a, $p, $r, $y);
+}
+
+sub brsft {
+    # shift right by $y (divide $b ** $y)
+
+    # set up parameters
+    my ($class, $x, $y, $b, $a, $p, $r) = (ref($_[0]), @_);
+
+    # objectify is costly, so avoid it
+    if ((!ref($_[0])) || (ref($_[0]) ne ref($_[1]))) {
+        ($class, $x, $y, $b, $a, $p, $r) = objectify(2, @_);
     }
-  else
-    {
-    # MBI not loaded, or with ne "Math::BigInt::Calc"
-    $lib .= ",$mbilib" if defined $mbilib;
-    $lib =~ s/^,//;				# don't leave empty 
-    
-    # replacement library can handle lib statement, but also could ignore it
-    
-    # Perl < 5.6.0 dies with "out of memory!" when eval() and ':constant' is
-    # used in the same script, or eval inside import(). So we require MBI:
-    require Math::BigInt;
-    Math::BigInt->import( $lib_kind => $lib, 'objectify' );
-    }
-  if ($@)
-    {
-    require Carp; Carp::croak ("Couldn't load $lib: $! $@");
+
+    return $x if $x -> modify('brsft');
+    return $x if $x -> {sign} !~ /^[+-]$/; # nan, +inf, -inf
+
+    $b = 2 if !defined $b;
+    $b = $class -> new($b) unless ref($b) && $b -> isa($class);
+
+    return $x -> bnan() if $x -> is_nan() || $y -> is_nan() || $b -> is_nan();
+
+    # shift by a negative amount?
+    return $x -> blsft($y -> copy() -> babs(), $b) if $y -> {sign} =~ /^-/;
+
+    # the following call to bdiv() will return either quotient (scalar context)
+    # or quotient and remainder (list context).
+    $x -> bdiv($b -> bpow($y), $a, $p, $r, $y);
+}
+
+###############################################################################
+# Bitwise methods
+###############################################################################
+
+sub band {
+    my $x     = shift;
+    my $xref  = ref($x);
+    my $class = $xref || $x;
+
+    Carp::croak 'band() is an instance method, not a class method' unless $xref;
+    Carp::croak 'Not enough arguments for band()' if @_ < 1;
+
+    return if $x -> modify('band');
+
+    my $y = shift;
+    $y = $class -> new($y) unless ref($y);
+
+    my @r = @_;
+
+    my $xtmp = Math::BigInt -> new($x -> bint());   # to Math::BigInt
+    $xtmp -> band($y);
+    $xtmp = $class -> new($xtmp);                   # back to Math::BigFloat
+
+    $x -> {sign} = $xtmp -> {sign};
+    $x -> {_m}   = $xtmp -> {_m};
+    $x -> {_es}  = $xtmp -> {_es};
+    $x -> {_e}   = $xtmp -> {_e};
+
+    return $x -> round(@r);
+}
+
+sub bior {
+    my $x     = shift;
+    my $xref  = ref($x);
+    my $class = $xref || $x;
+
+    Carp::croak 'bior() is an instance method, not a class method' unless $xref;
+    Carp::croak 'Not enough arguments for bior()' if @_ < 1;
+
+    return if $x -> modify('bior');
+
+    my $y = shift;
+    $y = $class -> new($y) unless ref($y);
+
+    my @r = @_;
+
+    my $xtmp = Math::BigInt -> new($x -> bint());   # to Math::BigInt
+    $xtmp -> bior($y);
+    $xtmp = $class -> new($xtmp);                   # back to Math::BigFloat
+
+    $x -> {sign} = $xtmp -> {sign};
+    $x -> {_m}   = $xtmp -> {_m};
+    $x -> {_es}  = $xtmp -> {_es};
+    $x -> {_e}   = $xtmp -> {_e};
+
+    return $x -> round(@r);
+}
+
+sub bxor {
+    my $x     = shift;
+    my $xref  = ref($x);
+    my $class = $xref || $x;
+
+    Carp::croak 'bxor() is an instance method, not a class method' unless $xref;
+    Carp::croak 'Not enough arguments for bxor()' if @_ < 1;
+
+    return if $x -> modify('bxor');
+
+    my $y = shift;
+    $y = $class -> new($y) unless ref($y);
+
+    my @r = @_;
+
+    my $xtmp = Math::BigInt -> new($x -> bint());   # to Math::BigInt
+    $xtmp -> bxor($y);
+    $xtmp = $class -> new($xtmp);                   # back to Math::BigFloat
+
+    $x -> {sign} = $xtmp -> {sign};
+    $x -> {_m}   = $xtmp -> {_m};
+    $x -> {_es}  = $xtmp -> {_es};
+    $x -> {_e}   = $xtmp -> {_e};
+
+    return $x -> round(@r);
+}
+
+sub bnot {
+    my $x     = shift;
+    my $xref  = ref($x);
+    my $class = $xref || $x;
+
+    Carp::croak 'bnot() is an instance method, not a class method' unless $xref;
+
+    return if $x -> modify('bnot');
+
+    my @r = @_;
+
+    my $xtmp = Math::BigInt -> new($x -> bint());   # to Math::BigInt
+    $xtmp -> bnot();
+    $xtmp = $class -> new($xtmp);                   # back to Math::BigFloat
+
+    $x -> {sign} = $xtmp -> {sign};
+    $x -> {_m}   = $xtmp -> {_m};
+    $x -> {_es}  = $xtmp -> {_es};
+    $x -> {_e}   = $xtmp -> {_e};
+
+    return $x -> round(@r);
+}
+
+###############################################################################
+# Rounding methods
+###############################################################################
+
+sub bround {
+    # accuracy: preserve $N digits, and overwrite the rest with 0's
+    my $x = shift;
+    my $class = ref($x) || $x;
+    $x = $class->new(shift) if !ref($x);
+
+    if (($_[0] || 0) < 0) {
+        Carp::croak('bround() needs positive accuracy');
     }
-  # find out which one was actually loaded
-  $MBI = Math::BigInt->config()->{lib};
 
-  # register us with MBI to get notified of future lib changes
-  Math::BigInt::_register_callback( $self, sub { $MBI = $_[0]; } );
+    my ($scale, $mode) = $x->_scale_a(@_);
+    return $x if !defined $scale || $x->modify('bround'); # no-op
 
-  $self->export_to_level(1,$self,@a);		# export wanted functions
-  }
+    # scale is now either $x->{_a}, $accuracy, or the user parameter
+    # test whether $x already has lower accuracy, do nothing in this case
+    # but do round if the accuracy is the same, since a math operation might
+    # want to round a number with A=5 to 5 digits afterwards again
+    return $x if defined $x->{_a} && $x->{_a} < $scale;
 
-sub bnorm
-  {
-  # adjust m and e so that m is smallest possible
-  my ($self,$x) = ref($_[0]) ? (undef,$_[0]) : objectify(1,@_);
+    # scale < 0 makes no sense
+    # scale == 0 => keep all digits
+    # never round a +-inf, NaN
+    return $x if ($scale <= 0) || $x->{sign} !~ /^[+-]$/;
 
-  return $x if $x->{sign} !~ /^[+-]$/;		# inf, nan etc
+    # 1: never round a 0
+    # 2: if we should keep more digits than the mantissa has, do nothing
+    if ($x->is_zero() || $MBI->_len($x->{_m}) <= $scale) {
+        $x->{_a} = $scale if !defined $x->{_a} || $x->{_a} > $scale;
+        return $x;
+    }
 
-  my $zeros = $MBI->_zeros($x->{_m});		# correct for trailing zeros
-  if ($zeros != 0)
-    {
-    my $z = $MBI->_new($zeros);
-    $x->{_m} = $MBI->_rsft ($x->{_m}, $z, 10);
-    if ($x->{_es} eq '-')
-      {
-      if ($MBI->_acmp($x->{_e},$z) >= 0)
+    # pass sign to bround for '+inf' and '-inf' rounding modes
+    my $m = bless { sign => $x->{sign}, value => $x->{_m} }, 'Math::BigInt';
+
+    $m->bround($scale, $mode);   # round mantissa
+    $x->{_m} = $m->{value};     # get our mantissa back
+    $x->{_a} = $scale;          # remember rounding
+    delete $x->{_p};            # and clear P
+    $x->bnorm();                # del trailing zeros gen. by bround()
+}
+
+sub bfround {
+    # precision: round to the $Nth digit left (+$n) or right (-$n) from the '.'
+    # $n == 0 means round to integer
+    # expects and returns normalized numbers!
+    my $x = shift;
+    my $class = ref($x) || $x;
+    $x = $class->new(shift) if !ref($x);
+
+    my ($scale, $mode) = $x->_scale_p(@_);
+    return $x if !defined $scale || $x->modify('bfround'); # no-op
+
+    # never round a 0, +-inf, NaN
+    if ($x->is_zero()) {
+        $x->{_p} = $scale if !defined $x->{_p} || $x->{_p} < $scale; # -3 < -2
+        return $x;
+    }
+    return $x if $x->{sign} !~ /^[+-]$/;
+
+    # don't round if x already has lower precision
+    return $x if (defined $x->{_p} && $x->{_p} < 0 && $scale < $x->{_p});
+
+    $x->{_p} = $scale;          # remember round in any case
+    delete $x->{_a};            # and clear A
+    if ($scale < 0) {
+        # round right from the '.'
+
+        return $x if $x->{_es} eq '+'; # e >= 0 => nothing to round
+
+        $scale = -$scale;           # positive for simplicity
+        my $len = $MBI->_len($x->{_m}); # length of mantissa
+
+        # the following poses a restriction on _e, but if _e is bigger than a
+        # scalar, you got other problems (memory etc) anyway
+        my $dad = -(0+ ($x->{_es}.$MBI->_num($x->{_e}))); # digits after dot
+        my $zad = 0;                                      # zeros after dot
+        $zad = $dad - $len if (-$dad < -$len); # for 0.00..00xxx style
+
+        # print "scale $scale dad $dad zad $zad len $len\n";
+        # number  bsstr   len zad dad
+        # 0.123   123e-3    3   0 3
+        # 0.0123  123e-4    3   1 4
+        # 0.001   1e-3      1   2 3
+        # 1.23    123e-2    3   0 2
+        # 1.2345  12345e-4  5   0 4
+
+        # do not round after/right of the $dad
+        return $x if $scale > $dad; # 0.123, scale >= 3 => exit
+
+        # round to zero if rounding inside the $zad, but not for last zero like:
+        # 0.0065, scale -2, round last '0' with following '65' (scale == zad case)
+        return $x->bzero() if $scale < $zad;
+        if ($scale == $zad)     # for 0.006, scale -3 and trunc
         {
-        $x->{_e} = $MBI->_sub ($x->{_e}, $z);
-        $x->{_es} = '+' if $MBI->_is_zero($x->{_e});
+            $scale = -$len;
+        } else {
+            # adjust round-point to be inside mantissa
+            if ($zad != 0) {
+                $scale = $scale-$zad;
+            } else {
+                my $dbd = $len - $dad;
+                $dbd = 0 if $dbd < 0; # digits before dot
+                $scale = $dbd+$scale;
+            }
         }
-      else
-        {
-        $x->{_e} = $MBI->_sub ( $MBI->_copy($z), $x->{_e});
-        $x->{_es} = '+';
+    } else {
+        # round left from the '.'
+
+        # 123 => 100 means length(123) = 3 - $scale (2) => 1
+
+        my $dbt = $MBI->_len($x->{_m});
+        # digits before dot
+        my $dbd = $dbt + ($x->{_es} . $MBI->_num($x->{_e}));
+        # should be the same, so treat it as this
+        $scale = 1 if $scale == 0;
+        # shortcut if already integer
+        return $x if $scale == 1 && $dbt <= $dbd;
+        # maximum digits before dot
+        ++$dbd;
+
+        if ($scale > $dbd) {
+            # not enough digits before dot, so round to zero
+            return $x->bzero;
+        } elsif ($scale == $dbd) {
+            # maximum
+            $scale = -$dbt;
+        } else {
+            $scale = $dbd - $scale;
         }
-      }
-    else
-      {
-      $x->{_e} = $MBI->_add ($x->{_e}, $z);
-      }
     }
-  else
-    {
-    # $x can only be 0Ey if there are no trailing zeros ('0' has 0 trailing
-    # zeros). So, for something like 0Ey, set y to 1, and -0 => +0
-    $x->{sign} = '+', $x->{_es} = '+', $x->{_e} = $MBI->_one()
-     if $MBI->_is_zero($x->{_m});
+    # pass sign to bround for rounding modes '+inf' and '-inf'
+    my $m = bless { sign => $x->{sign}, value => $x->{_m} }, 'Math::BigInt';
+    $m->bround($scale, $mode);
+    $x->{_m} = $m->{value};     # get our mantissa back
+    $x->bnorm();
+}
+
+sub bfloor {
+    # round towards minus infinity
+    my ($class, $x, $a, $p, $r) = ref($_[0]) ? (ref($_[0]), @_) : objectify(1, @_);
+
+    return $x if $x->modify('bfloor');
+
+    return $x if $x->{sign} !~ /^[+-]$/; # nan, +inf, -inf
+
+    # if $x has digits after dot
+    if ($x->{_es} eq '-') {
+        $x->{_m} = $MBI->_rsft($x->{_m}, $x->{_e}, 10); # cut off digits after dot
+        $x->{_e} = $MBI->_zero();                     # trunc/norm
+        $x->{_es} = '+';                              # abs e
+        $MBI->_inc($x->{_m}) if $x->{sign} eq '-';    # increment if negative
     }
+    $x->round($a, $p, $r);
+}
 
-  $x;					# MBI bnorm is no-op, so do not call it
-  } 
- 
-##############################################################################
+sub bceil {
+    # round towards plus infinity
+    my ($class, $x, $a, $p, $r) = ref($_[0]) ? (ref($_[0]), @_) : objectify(1, @_);
 
-sub as_hex
-  {
-  # return number as hexadecimal string (only for integers defined)
-  my ($self,$x) = ref($_[0]) ? (ref($_[0]),$_[0]) : objectify(1,@_);
+    return $x if $x->modify('bceil');
+    return $x if $x->{sign} !~ /^[+-]$/; # nan, +inf, -inf
+
+    # if $x has digits after dot
+    if ($x->{_es} eq '-') {
+        $x->{_m} = $MBI->_rsft($x->{_m}, $x->{_e}, 10); # cut off digits after dot
+        $x->{_e} = $MBI->_zero();                     # trunc/norm
+        $x->{_es} = '+';                              # abs e
+        if ($x->{sign} eq '+') {
+            $MBI->_inc($x->{_m}); # increment if positive
+        } else {
+            $x->{sign} = '+' if $MBI->_is_zero($x->{_m}); # avoid -0
+        }
+    }
+    $x->round($a, $p, $r);
+}
 
-  return $x->bstr() if $x->{sign} !~ /^[+-]$/;  # inf, nan etc
-  return '0x0' if $x->is_zero();
+sub bint {
+    # round towards zero
+    my ($class, $x, $a, $p, $r) = ref($_[0]) ? (ref($_[0]), @_) : objectify(1, @_);
 
-  return $nan if $x->{_es} ne '+';		# how to do 1e-1 in hex!?
+    return $x if $x->modify('bint');
+    return $x if $x->{sign} !~ /^[+-]$/; # nan, +inf, -inf
 
-  my $z = $MBI->_copy($x->{_m});
-  if (! $MBI->_is_zero($x->{_e}))		# > 0 
-    {
-    $MBI->_lsft( $z, $x->{_e},10);
+    # if $x has digits after the decimal point
+    if ($x->{_es} eq '-') {
+        $x->{_m} = $MBI->_rsft($x->{_m}, $x->{_e}, 10); # cut off digits after dot
+        $x->{_e} = $MBI->_zero();                     # truncate/normalize
+        $x->{_es} = '+';                              # abs e
+        $x->{sign} = '+' if $MBI->_is_zero($x->{_m}); # avoid -0
     }
-  $z = Math::BigInt->new( $x->{sign} . $MBI->_num($z));
-  $z->as_hex();
-  }
+    $x->round($a, $p, $r);
+}
 
-sub as_bin
-  {
-  # return number as binary digit string (only for integers defined)
-  my ($self,$x) = ref($_[0]) ? (ref($_[0]),$_[0]) : objectify(1,@_);
+###############################################################################
+# Other mathematical methods
+###############################################################################
 
-  return $x->bstr() if $x->{sign} !~ /^[+-]$/;  # inf, nan etc
-  return '0b0' if $x->is_zero();
+sub bgcd {
+    # (BINT or num_str, BINT or num_str) return BINT
+    # does not modify arguments, but returns new object
 
-  return $nan if $x->{_es} ne '+';		# how to do 1e-1 in hex!?
+    my $y = shift;
+    $y = __PACKAGE__->new($y) if !ref($y);
+    my $class = ref($y);
+    my $x = $y->copy()->babs(); # keep arguments
 
-  my $z = $MBI->_copy($x->{_m});
-  if (! $MBI->_is_zero($x->{_e}))		# > 0 
-    {
-    $MBI->_lsft( $z, $x->{_e},10);
-    }
-  $z = Math::BigInt->new( $x->{sign} . $MBI->_num($z));
-  $z->as_bin();
-  }
+    return $x->bnan() if $x->{sign} !~ /^[+-]$/ # x NaN?
+      || !$x->is_int();                         # only for integers now
 
-sub as_oct
-  {
-  # return number as octal digit string (only for integers defined)
-  my ($self,$x) = ref($_[0]) ? (ref($_[0]),$_[0]) : objectify(1,@_);
+    while (@_) {
+        my $t = shift;
+        $t = $class->new($t) if !ref($t);
+        $y = $t->copy()->babs();
 
-  return $x->bstr() if $x->{sign} !~ /^[+-]$/;  # inf, nan etc
-  return '0' if $x->is_zero();
+        return $x->bnan() if $y->{sign} !~ /^[+-]$/ # y NaN?
+          || !$y->is_int();                         # only for integers now
 
-  return $nan if $x->{_es} ne '+';		# how to do 1e-1 in hex!?
+        # greatest common divisor
+        while (! $y->is_zero()) {
+            ($x, $y) = ($y->copy(), $x->copy()->bmod($y));
+        }
 
-  my $z = $MBI->_copy($x->{_m});
-  if (! $MBI->_is_zero($x->{_e}))		# > 0 
-    {
-    $MBI->_lsft( $z, $x->{_e},10);
+        last if $x->is_one();
     }
-  $z = Math::BigInt->new( $x->{sign} . $MBI->_num($z));
-  $z->as_oct();
-  }
+    $x;
+}
 
-sub as_number
-  {
-  # return copy as a bigint representation of this BigFloat number
-  my ($self,$x) = ref($_[0]) ? (ref($_[0]),$_[0]) : objectify(1,@_);
+sub blcm {
+    # (BFLOAT or num_str, BFLOAT or num_str) return BFLOAT
+    # does not modify arguments, but returns new object
+    # Lowest Common Multiplicator
 
-  return $x if $x->modify('as_number');
+    my ($class, @arg) = objectify(0, @_);
+    my $x = $class->new(shift @arg);
+    while (@arg) {
+        $x = Math::BigInt::__lcm($x, shift @arg);
+    }
+    $x;
+}
 
-  if (!$x->isa('Math::BigFloat'))
-    {
-    # if the object can as_number(), use it
-    return $x->as_number() if $x->can('as_number');
-    # otherwise, get us a float and then a number
-    $x = $x->can('as_float') ? $x->as_float() : $self->new(0+"$x");
+###############################################################################
+# Object property methods
+###############################################################################
+
+sub length {
+    my $x = shift;
+    my $class = ref($x) || $x;
+    $x = $class->new(shift) unless ref($x);
+
+    return 1 if $MBI->_is_zero($x->{_m});
+
+    my $len = $MBI->_len($x->{_m});
+    $len += $MBI->_num($x->{_e}) if $x->{_es} eq '+';
+    if (wantarray()) {
+        my $t = 0;
+        $t = $MBI->_num($x->{_e}) if $x->{_es} eq '-';
+        return ($len, $t);
     }
+    $len;
+}
 
-  return Math::BigInt->binf($x->sign()) if $x->is_inf();
-  return Math::BigInt->bnan()           if $x->is_nan();
+sub mantissa {
+    # return a copy of the mantissa
+    my ($class, $x) = ref($_[0]) ? (ref($_[0]), $_[0]) : objectify(1, @_);
 
-  my $z = $MBI->_copy($x->{_m});
-  if ($x->{_es} eq '-')			# < 0
-    {
-    $MBI->_rsft( $z, $x->{_e},10);
-    } 
-  elsif (! $MBI->_is_zero($x->{_e}))	# > 0 
-    {
-    $MBI->_lsft( $z, $x->{_e},10);
+    if ($x->{sign} !~ /^[+-]$/) {
+        my $s = $x->{sign};
+        $s =~ s/^[+]//;
+        return Math::BigInt->new($s, undef, undef); # -inf, +inf => +inf
     }
-  $z = Math::BigInt->new( $x->{sign} . $MBI->_str($z));
-  $z;
-  }
+    my $m = Math::BigInt->new($MBI->_str($x->{_m}), undef, undef);
+    $m->bneg() if $x->{sign} eq '-';
 
-sub length
-  {
-  my $x = shift;
-  my $class = ref($x) || $x;
-  $x = $class->new(shift) unless ref($x);
+    $m;
+}
 
-  return 1 if $MBI->_is_zero($x->{_m});
+sub exponent {
+    # return a copy of the exponent
+    my ($class, $x) = ref($_[0]) ? (ref($_[0]), $_[0]) : objectify(1, @_);
 
-  my $len = $MBI->_len($x->{_m});
-  $len += $MBI->_num($x->{_e}) if $x->{_es} eq '+';
-  if (wantarray())
-    {
-    my $t = 0;
-    $t = $MBI->_num($x->{_e}) if $x->{_es} eq '-';
-    return ($len, $t);
+    if ($x->{sign} !~ /^[+-]$/) {
+        my $s = $x->{sign};
+$s =~ s/^[+-]//;
+        return Math::BigInt->new($s, undef, undef); # -inf, +inf => +inf
     }
-  $len;
-  }
+    Math::BigInt->new($x->{_es} . $MBI->_str($x->{_e}), undef, undef);
+}
 
-sub from_hex {
-    my $self    = shift;
-    my $selfref = ref $self;
-    my $class   = $selfref || $self;
+sub parts {
+    # return a copy of both the exponent and the mantissa
+    my ($class, $x) = ref($_[0]) ? (ref($_[0]), $_[0]) : objectify(1, @_);
+
+    if ($x->{sign} !~ /^[+-]$/) {
+        my $s = $x->{sign};
+$s =~ s/^[+]//;
+my $se = $s;
+$se =~ s/^[-]//;
+        return ($class->new($s), $class->new($se)); # +inf => inf and -inf, +inf => inf
+    }
+    my $m = Math::BigInt->bzero();
+    $m->{value} = $MBI->_copy($x->{_m});
+    $m->bneg() if $x->{sign} eq '-';
+    ($m, Math::BigInt->new($x->{_es} . $MBI->_num($x->{_e})));
+}
 
-    my $str = shift;
+sub sparts {
+    my $self  = shift;
+    my $class = ref $self;
 
-    # If called as a class method, initialize a new object.
+    Carp::croak("sparts() is an instance method, not a class method")
+        unless $class;
 
-    $self = $class -> bzero() unless $selfref;
+    # Not-a-number.
 
-    if ($str =~ s/
-                     ^
+    if ($self -> is_nan()) {
+        my $mant = $self -> copy();             # mantissa
+        return $mant unless wantarray;          # scalar context
+        my $expo = $class -> bnan();            # exponent
+        return ($mant, $expo);                  # list context
+    }
 
-                     # sign
-                     ( [+-]? )
+    # Infinity.
 
-                     # optional "hex marker"
-                     (?: 0? x )?
+    if ($self -> is_inf()) {
+        my $mant = $self -> copy();             # mantissa
+        return $mant unless wantarray;          # scalar context
+        my $expo = $class -> binf('+');         # exponent
+        return ($mant, $expo);                  # list context
+    }
 
-                     # significand using the hex digits 0..9 and a..f
-                     (
-                         [0-9a-fA-F]+ (?: _ [0-9a-fA-F]+ )*
-                         (?:
-                             \.
-                             (?: [0-9a-fA-F]+ (?: _ [0-9a-fA-F]+ )* )?
-                         )?
-                     |
-                         \.
-                         [0-9a-fA-F]+ (?: _ [0-9a-fA-F]+ )*
-                     )
+    # Finite number.
 
-                     # exponent (power of 2) using decimal digits
-                     (?:
-                         [Pp]
-                         ( [+-]? )
-                         ( \d+ (?: _ \d+ )* )
-                     )?
+    my $mant = $class -> bzero();
+    $mant -> {sign} = $self -> {sign};
+    $mant -> {_m}   = $MBI->_copy($self -> {_m});
+    return $mant unless wantarray;
 
-                     $
-                 //x)
-    {
-        my $s_sign  = $1 || '+';
-        my $s_value = $2;
-        my $e_sign  = $3 || '+';
-        my $e_value = $4 || '0';
-        $s_value =~ tr/_//d;
-        $e_value =~ tr/_//d;
+    my $expo = $class -> bzero();
+    $expo -> {sign} = $self -> {_es};
+    $expo -> {_m}   = $MBI->_copy($self -> {_e});
 
-        # The significand must be multiplied by 2 raised to this exponent.
+    return ($mant, $expo);
+}
 
-        my $two_expon = $class -> new($e_value);
-        $two_expon -> bneg() if $e_sign eq '-';
+sub nparts {
+    my $self  = shift;
+    my $class = ref $self;
 
-        # If there is a dot in the significand, remove it and adjust the
-        # exponent according to the number of digits in the fraction part of
-        # the significand. Since the digits in the significand are in base 16,
-        # but the exponent is only in base 2, multiply the exponent adjustment
-        # value by log(16) / log(2) = 4.
+    Carp::croak("nparts() is an instance method, not a class method")
+        unless $class;
 
-        my $idx = index($s_value, '.');
-        if ($idx >= 0) {
-            substr($s_value, $idx, 1) = '';
-            $two_expon -= $class -> new(CORE::length($s_value))
-                                 -> bsub($idx)
-                                 -> bmul("4");
+    # Not-a-number.
+
+    if ($self -> is_nan()) {
+        my $mant = $self -> copy();             # mantissa
+        return $mant unless wantarray;          # scalar context
+        my $expo = $class -> bnan();            # exponent
+        return ($mant, $expo);                  # list context
+    }
+
+    # Infinity.
+
+    if ($self -> is_inf()) {
+        my $mant = $self -> copy();             # mantissa
+        return $mant unless wantarray;          # scalar context
+        my $expo = $class -> binf('+');         # exponent
+        return ($mant, $expo);                  # list context
+    }
+
+    # Finite number.
+
+    my ($mant, $expo) = $self -> sparts();
+
+    if ($mant -> bcmp(0)) {
+        my ($ndigtot, $ndigfrac) = $mant -> length();
+        my $expo10adj = $ndigtot - $ndigfrac - 1;
+
+        if ($expo10adj != 0) {
+            my $factor  = "1e" . -$expo10adj;
+            $mant -> bmul($factor);
+            return $mant unless wantarray;
+            $expo -> badd($expo10adj);
+            return ($mant, $expo);
         }
+    }
 
-        $self -> {sign} = $s_sign;
-        $self -> {_m}   = $MBI -> _from_hex('0x' . $s_value);
+    return $mant unless wantarray;
+    return ($mant, $expo);
+}
 
-        if ($two_expon > 0) {
-            my $factor = $class -> new("2") -> bpow($two_expon);
-            $self -> bmul($factor);
-        } elsif ($two_expon < 0) {
-            my $factor = $class -> new("0.5") -> bpow(-$two_expon);
-            $self -> bmul($factor);
+sub eparts {
+    my $self  = shift;
+    my $class = ref $self;
+
+    Carp::croak("eparts() is an instance method, not a class method")
+        unless $class;
+
+    # Not-a-number and Infinity.
+
+    return $self -> sparts() if $self -> is_nan() || $self -> is_inf();
+
+    # Finite number.
+
+    my ($mant, $expo) = $self -> nparts();
+
+    my $c = $expo -> copy() -> bmod(3);
+    $mant -> blsft($c, 10);
+    return $mant unless wantarray;
+
+    $expo -> bsub($c);
+    return ($mant, $expo);
+}
+
+sub dparts {
+    my $self  = shift;
+    my $class = ref $self;
+
+    Carp::croak("dparts() is an instance method, not a class method")
+        unless $class;
+
+    # Not-a-number and Infinity.
+
+    if ($self -> is_nan() || $self -> is_inf()) {
+        my $int = $self -> copy();
+        return $int unless wantarray;
+        my $frc = $class -> bzero();
+        return ($int, $frc);
+    }
+
+    my $int = $self  -> copy();
+    my $frc = $class -> bzero();
+
+    # If the input has a fraction part.
+
+    if ($int->{_es} eq '-') {
+        $int->{_m} = $MBI -> _rsft($int->{_m}, $int->{_e}, 10);
+        $int->{_e} = $MBI -> _zero();
+        $int->{_es} = '+';
+        $int->{sign} = '+' if $MBI->_is_zero($int->{_m});   # avoid -0
+
+        return $int unless wantarray;
+        $frc = $self -> copy() -> bsub($int);
+        return ($int, $frc);
+    }
+
+    return $int unless wantarray;
+    return ($int, $frc);
+}
+
+###############################################################################
+# String conversion methods
+###############################################################################
+
+sub bstr {
+    # (ref to BFLOAT or num_str) return num_str
+    # Convert number from internal format to (non-scientific) string format.
+    # internal format is always normalized (no leading zeros, "-0" => "+0")
+    my ($class, $x) = ref($_[0]) ? (undef, $_[0]) : objectify(1, @_);
+
+    if ($x->{sign} !~ /^[+-]$/) {
+        return $x->{sign} unless $x->{sign} eq '+inf'; # -inf, NaN
+        return 'inf';                                  # +inf
+    }
+
+    my $es = '0';
+my $len = 1;
+my $cad = 0;
+my $dot = '.';
+
+    # $x is zero?
+    my $not_zero = !($x->{sign} eq '+' && $MBI->_is_zero($x->{_m}));
+    if ($not_zero) {
+        $es = $MBI->_str($x->{_m});
+        $len = CORE::length($es);
+        my $e = $MBI->_num($x->{_e});
+        $e = -$e if $x->{_es} eq '-';
+        if ($e < 0) {
+            $dot = '';
+            # if _e is bigger than a scalar, the following will blow your memory
+            if ($e <= -$len) {
+                my $r = abs($e) - $len;
+                $es = '0.'. ('0' x $r) . $es;
+$cad = -($len+$r);
+            } else {
+                substr($es, $e, 0) = '.';
+$cad = $MBI->_num($x->{_e});
+                $cad = -$cad if $x->{_es} eq '-';
+            }
+        } elsif ($e > 0) {
+            # expand with zeros
+            $es .= '0' x $e;
+$len += $e;
+$cad = 0;
         }
+    }                           # if not zero
+
+    $es = '-'.$es if $x->{sign} eq '-';
+    # if set accuracy or precision, pad with zeros on the right side
+    if ((defined $x->{_a}) && ($not_zero)) {
+        # 123400 => 6, 0.1234 => 4, 0.001234 => 4
+        my $zeros = $x->{_a} - $cad; # cad == 0 => 12340
+        $zeros = $x->{_a} - $len if $cad != $len;
+        $es .= $dot.'0' x $zeros if $zeros > 0;
+    } elsif ((($x->{_p} || 0) < 0)) {
+        # 123400 => 6, 0.1234 => 4, 0.001234 => 6
+        my $zeros = -$x->{_p} + $cad;
+        $es .= $dot.'0' x $zeros if $zeros > 0;
+    }
+    $es;
+}
 
-        return $self;
+# Decimal notation, e.g., "12345.6789".
+
+sub bdstr {
+    my $x = shift;
+
+    if ($x->{sign} ne '+' && $x->{sign} ne '-') {
+        return $x->{sign} unless $x->{sign} eq '+inf'; # -inf, NaN
+        return 'inf';                                  # +inf
     }
 
-    return $self->bnan();
+    my $mant = $MBI->_str($x->{_m});
+    my $expo = $x -> exponent();
+
+    my $str = $mant;
+    if ($expo >= 0) {
+        $str .= "0" x $expo;
+    } else {
+        my $mantlen = CORE::length($mant);
+        my $c = $mantlen + $expo;
+        $str = "0" x (1 - $c) . $str if $c <= 0;
+        substr($str, $expo, 0) = '.';
+    }
+
+    return $x->{sign} eq '-' ? "-$str" : $str;
 }
 
-sub from_oct {
-    my $self    = shift;
-    my $selfref = ref $self;
-    my $class   = $selfref || $self;
+# Scientific notation with significand/mantissa as an integer, e.g., "12345.6789"
+# is written as "123456789e-4".
 
-    my $str = shift;
+sub bsstr {
+    my ($class, $x) = ref($_[0]) ? (undef, $_[0]) : objectify(1, @_);
 
-    # If called as a class method, initialize a new object.
+    if ($x->{sign} ne '+' && $x->{sign} ne '-') {
+        return $x->{sign} unless $x->{sign} eq '+inf'; # -inf, NaN
+        return 'inf';                                  # +inf
+    }
 
-    $self = $class -> bzero() unless $selfref;
+    my $str = $MBI->_str($x->{_m}) . 'e' . $x->{_es}. $MBI->_str($x->{_e});
+    return $x->{sign} eq '-' ? "-$str" : $str;
+}
 
-    if ($str =~ s/
-                     ^
+# Normalized notation, e.g., "12345.6789" is written as "1.23456789e+4".
 
-                     # sign
-                     ( [+-]? )
+sub bnstr {
+    my $x = shift;
 
-                     # significand using the octal digits 0..7
-                     (
-                         [0-7]+ (?: _ [0-7]+ )*
-                         (?:
-                             \.
-                             (?: [0-7]+ (?: _ [0-7]+ )* )?
-                         )?
-                     |
-                         \.
-                         [0-7]+ (?: _ [0-7]+ )*
-                     )
+    if ($x->{sign} ne '+' && $x->{sign} ne '-') {
+        return $x->{sign} unless $x->{sign} eq '+inf'; # -inf, NaN
+        return 'inf';                                  # +inf
+    }
 
-                     # exponent (power of 2) using decimal digits
-                     (?:
-                         [Pp]
-                         ( [+-]? )
-                         ( \d+ (?: _ \d+ )* )
-                     )?
+    my ($mant, $expo) = $x -> nparts();
 
-                     $
-                 //x)
-    {
-        my $s_sign  = $1 || '+';
-        my $s_value = $2;
-        my $e_sign  = $3 || '+';
-        my $e_value = $4 || '0';
-        $s_value =~ tr/_//d;
-        $e_value =~ tr/_//d;
+    my $esgn = $expo < 0 ? '-' : '+';
+    my $eabs = $expo -> babs() -> bfround(0) -> bstr();
+    #$eabs = '0' . $eabs if length($eabs) < 2;
 
-        # The significand must be multiplied by 2 raised to this exponent.
+    return $mant . 'e' . $esgn . $eabs;
+}
 
-        my $two_expon = $class -> new($e_value);
-        $two_expon -> bneg() if $e_sign eq '-';
+# Engineering notation, e.g., "12345.6789" is written as "12.3456789e+3".
 
-        # If there is a dot in the significand, remove it and adjust the
-        # exponent according to the number of digits in the fraction part of
-        # the significand. Since the digits in the significand are in base 8,
-        # but the exponent is only in base 2, multiply the exponent adjustment
-        # value by log(8) / log(2) = 3.
+sub bestr {
+    my $x = shift;
 
-        my $idx = index($s_value, '.');
-        if ($idx >= 0) {
-            substr($s_value, $idx, 1) = '';
-            $two_expon -= $class -> new(CORE::length($s_value))
-                                 -> bsub($idx)
-                                 -> bmul("3");
-        }
+    if ($x->{sign} ne '+' && $x->{sign} ne '-') {
+        return $x->{sign} unless $x->{sign} eq '+inf'; # -inf, NaN
+        return 'inf';                                  # +inf
+    }
 
-        $self -> {sign} = $s_sign;
-        $self -> {_m}   = $MBI -> _from_oct($s_value);
+    my ($mant, $expo) = $x -> eparts();
 
-        if ($two_expon > 0) {
-            my $factor = $class -> new("2") -> bpow($two_expon);
-            $self -> bmul($factor);
-        } elsif ($two_expon < 0) {
-            my $factor = $class -> new("0.5") -> bpow(-$two_expon);
-            $self -> bmul($factor);
-        }
+    my $esgn = $expo < 0 ? '-' : '+';
+    my $eabs = $expo -> babs() -> bfround(0) -> bstr();
+    #$eabs = '0' . $eabs if length($eabs) < 2;
 
-        return $self;
+    return $mant . 'e' . $esgn . $eabs;
+}
+
+sub as_hex {
+    # return number as hexadecimal string (only for integers defined)
+    my ($class, $x) = ref($_[0]) ? (ref($_[0]), $_[0]) : objectify(1, @_);
+
+    return $x->bstr() if $x->{sign} !~ /^[+-]$/; # inf, nan etc
+    return '0x0' if $x->is_zero();
+
+    return $nan if $x->{_es} ne '+';    # how to do 1e-1 in hex?
+
+    my $z = $MBI->_copy($x->{_m});
+    if (! $MBI->_is_zero($x->{_e})) {   # > 0
+        $MBI->_lsft($z, $x->{_e}, 10);
     }
+    $z = Math::BigInt->new($x->{sign} . $MBI->_num($z));
+    $z->as_hex();
+}
 
-    return $self->bnan();
+sub as_oct {
+    # return number as octal digit string (only for integers defined)
+    my ($class, $x) = ref($_[0]) ? (ref($_[0]), $_[0]) : objectify(1, @_);
+
+    return $x->bstr() if $x->{sign} !~ /^[+-]$/; # inf, nan etc
+    return '0' if $x->is_zero();
+
+    return $nan if $x->{_es} ne '+';    # how to do 1e-1 in octal?
+
+    my $z = $MBI->_copy($x->{_m});
+    if (! $MBI->_is_zero($x->{_e})) {   # > 0
+        $MBI->_lsft($z, $x->{_e}, 10);
+    }
+    $z = Math::BigInt->new($x->{sign} . $MBI->_num($z));
+    $z->as_oct();
 }
 
-sub from_bin {
-    my $self    = shift;
-    my $selfref = ref $self;
-    my $class   = $selfref || $self;
+sub as_bin {
+    # return number as binary digit string (only for integers defined)
+    my ($class, $x) = ref($_[0]) ? (ref($_[0]), $_[0]) : objectify(1, @_);
 
-    my $str = shift;
+    return $x->bstr() if $x->{sign} !~ /^[+-]$/; # inf, nan etc
+    return '0b0' if $x->is_zero();
 
-    # If called as a class method, initialize a new object.
+    return $nan if $x->{_es} ne '+';    # how to do 1e-1 in binary?
 
-    $self = $class -> bzero() unless $selfref;
+    my $z = $MBI->_copy($x->{_m});
+    if (! $MBI->_is_zero($x->{_e})) {   # > 0
+        $MBI->_lsft($z, $x->{_e}, 10);
+    }
+    $z = Math::BigInt->new($x->{sign} . $MBI->_num($z));
+    $z->as_bin();
+}
 
-    if ($str =~ s/
-                     ^
+sub numify {
+    # Make a Perl scalar number from a Math::BigFloat object.
+    my ($class, $x) = ref($_[0]) ? (undef, $_[0]) : objectify(1, @_);
 
-                     # sign
-                     ( [+-]? )
+    if ($x -> is_nan()) {
+        require Math::Complex;
+        my $inf = Math::Complex::Inf();
+        return $inf - $inf;
+    }
 
-                     # optional "bin marker"
-                     (?: 0? b )?
+    if ($x -> is_inf()) {
+        require Math::Complex;
+        my $inf = Math::Complex::Inf();
+        return $x -> is_negative() ? -$inf : $inf;
+    }
 
-                     # significand using the binary digits 0 and 1
-                     (
-                         [01]+ (?: _ [01]+ )*
-                         (?:
-                             \.
-                             (?: [01]+ (?: _ [01]+ )* )?
-                         )?
-                     |
-                         \.
-                         [01]+ (?: _ [01]+ )*
-                     )
+    # Create a string and let Perl's atoi()/atof() handle the rest.
+    return 0 + $x -> bsstr();
+}
 
-                     # exponent (power of 2) using decimal digits
-                     (?:
-                         [Pp]
-                         ( [+-]? )
-                         ( \d+ (?: _ \d+ )* )
-                     )?
+###############################################################################
+# Private methods and functions.
+###############################################################################
 
-                     $
-                 //x)
-    {
-        my $s_sign  = $1 || '+';
-        my $s_value = $2;
-        my $e_sign  = $3 || '+';
-        my $e_value = $4 || '0';
-        $s_value =~ tr/_//d;
-        $e_value =~ tr/_//d;
+sub import {
+    my $class = shift;
+    my $l = scalar @_;
+    my $lib = '';
+my @a;
+    my $lib_kind = 'try';
+    $IMPORT=1;
+    for (my $i = 0; $i < $l ; $i++) {
+        if ($_[$i] eq ':constant') {
+            # This causes overlord er load to step in. 'binary' and 'integer'
+            # are handled by BigInt.
+            overload::constant float => sub { $class->new(shift); };
+        } elsif ($_[$i] eq 'upgrade') {
+            # this causes upgrading
+            $upgrade = $_[$i+1]; # or undef to disable
+            $i++;
+        } elsif ($_[$i] eq 'downgrade') {
+            # this causes downgrading
+            $downgrade = $_[$i+1]; # or undef to disable
+            $i++;
+        } elsif ($_[$i] =~ /^(lib|try|only)\z/) {
+            # alternative library
+            $lib = $_[$i+1] || ''; # default Calc
+            $lib_kind = $1;        # lib, try or only
+            $i++;
+        } elsif ($_[$i] eq 'with') {
+            # alternative class for our private parts()
+            # XXX: no longer supported
+            # $MBI = $_[$i+1] || 'Math::BigInt';
+            $i++;
+        } else {
+            push @a, $_[$i];
+        }
+    }
 
-        # The significand must be multiplied by 2 raised to this exponent.
+    $lib =~ tr/a-zA-Z0-9,://cd; # restrict to sane characters
+    # let use Math::BigInt lib => 'GMP'; use Math::BigFloat; still work
+    my $mbilib = eval { Math::BigInt->config()->{lib} };
+    if ((defined $mbilib) && ($MBI eq 'Math::BigInt::Calc')) {
+        # MBI already loaded
+        Math::BigInt->import($lib_kind, "$lib, $mbilib", 'objectify');
+    } else {
+        # MBI not loaded, or with ne "Math::BigInt::Calc"
+        $lib .= ",$mbilib" if defined $mbilib;
+        $lib =~ s/^,//;         # don't leave empty
 
-        my $two_expon = $class -> new($e_value);
-        $two_expon -> bneg() if $e_sign eq '-';
+        # replacement library can handle lib statement, but also could ignore it
 
-        # If there is a dot in the significand, remove it and adjust the
-        # exponent according to the number of digits in the fraction part of
-        # the significand.
+        # Perl < 5.6.0 dies with "out of memory!" when eval() and ':constant' is
+        # used in the same script, or eval inside import(). So we require MBI:
+        require Math::BigInt;
+        Math::BigInt->import($lib_kind => $lib, 'objectify');
+    }
+    if ($@) {
+        Carp::croak("Couldn't load $lib: $! $@");
+    }
+    # find out which one was actually loaded
+    $MBI = Math::BigInt->config()->{lib};
 
-        my $idx = index($s_value, '.');
-        if ($idx >= 0) {
-            substr($s_value, $idx, 1) = '';
-            $two_expon -= $class -> new(CORE::length($s_value))
-                                 -> bsub($idx);
+    # register us with MBI to get notified of future lib changes
+    Math::BigInt::_register_callback($class, sub { $MBI = $_[0]; });
+
+    $class->export_to_level(1, $class, @a); # export wanted functions
+}
+
+sub _len_to_steps {
+    # Given D (digits in decimal), compute N so that N! (N factorial) is
+    # at least D digits long. D should be at least 50.
+    my $d = shift;
+
+    # two constants for the Ramanujan estimate of ln(N!)
+    my $lg2 = log(2 * 3.14159265) / 2;
+    my $lg10 = log(10);
+
+    # D = 50 => N => 42, so L = 40 and R = 50
+    my $l = 40;
+my $r = $d;
+
+    # Otherwise this does not work under -Mbignum and we do not yet have "no bignum;" :(
+    $l = $l->numify if ref($l);
+    $r = $r->numify if ref($r);
+    $lg2 = $lg2->numify if ref($lg2);
+    $lg10 = $lg10->numify if ref($lg10);
+
+    # binary search for the right value (could this be written as the reverse of lg(n!)?)
+    while ($r - $l > 1) {
+        my $n = int(($r - $l) / 2) + $l;
+        my $ramanujan =
+          int(($n * log($n) - $n + log($n * (1 + 4*$n*(1+2*$n))) / 6 + $lg2) / $lg10);
+        $ramanujan > $d ? $r = $n : $l = $n;
+    }
+    $l;
+}
+
+sub _log {
+    # internal log function to calculate ln() based on Taylor series.
+    # Modifies $x in place.
+    my ($class, $x, $scale) = @_;
+
+    # in case of $x == 1, result is 0
+    return $x->bzero() if $x->is_one();
+
+    # XXX TODO: rewrite this in a similar manner to bexp()
+
+    # http://www.efunda.com/math/taylor_series/logarithmic.cfm?search_string=log
+
+    # u = x-1, v = x+1
+    #              _                               _
+    # Taylor:     |    u    1   u^3   1   u^5       |
+    # ln (x)  = 2 |   --- + - * --- + - * --- + ... |  x > 0
+    #             |_   v    3   v^3   5   v^5      _|
+
+    # This takes much more steps to calculate the result and is thus not used
+    # u = x-1
+    #              _                               _
+    # Taylor:     |    u    1   u^2   1   u^3       |
+    # ln (x)  = 2 |   --- + - * --- + - * --- + ... |  x > 1/2
+    #             |_   x    2   x^2   3   x^3      _|
+
+    my ($limit, $v, $u, $below, $factor, $two, $next, $over, $f);
+
+    $v = $x->copy(); $v->binc(); # v = x+1
+    $x->bdec(); $u = $x->copy(); # u = x-1; x = x-1
+    $x->bdiv($v, $scale);        # first term: u/v
+    $below = $v->copy();
+    $over = $u->copy();
+    $u *= $u; $v *= $v;         # u^2, v^2
+    $below->bmul($v);           # u^3, v^3
+    $over->bmul($u);
+    $factor = $class->new(3); $f = $class->new(2);
+
+    my $steps = 0;
+    $limit = $class->new("1E-". ($scale-1));
+    while (3 < 5) {
+        # we calculate the next term, and add it to the last
+        # when the next term is below our limit, it won't affect the outcome
+        # anymore, so we stop
+
+        # calculating the next term simple from over/below will result in quite
+        # a time hog if the input has many digits, since over and below will
+        # accumulate more and more digits, and the result will also have many
+        # digits, but in the end it is rounded to $scale digits anyway. So if we
+        # round $over and $below first, we save a lot of time for the division
+        # (not with log(1.2345), but try log (123**123) to see what I mean. This
+        # can introduce a rounding error if the division result would be f.i.
+        # 0.1234500000001 and we round it to 5 digits it would become 0.12346, but
+        # if we truncated $over and $below we might get 0.12345. Does this matter
+        # for the end result? So we give $over and $below 4 more digits to be
+        # on the safe side (unscientific error handling as usual... :+D
+
+        $next = $over->copy()->bround($scale+4)
+          ->bdiv($below->copy()->bmul($factor)->bround($scale+4),
+                 $scale);
+
+        ## old version:
+        ##    $next = $over->copy()->bdiv($below->copy()->bmul($factor), $scale);
+
+        last if $next->bacmp($limit) <= 0;
+
+        delete $next->{_a};
+        delete $next->{_p};
+        $x->badd($next);
+        # calculate things for the next term
+        $over *= $u;
+        $below *= $v;
+        $factor->badd($f);
+        if (DEBUG) {
+            $steps++;
+            print "step $steps = $x\n" if $steps % 10 == 0;
         }
+    }
+    print "took $steps steps\n" if DEBUG;
+    $x->bmul($f);               # $x *= 2
+}
 
-        $self -> {sign} = $s_sign;
-        $self -> {_m}   = $MBI -> _from_bin('0b' . $s_value);
+sub _log_10 {
+    # Internal log function based on reducing input to the range of 0.1 .. 9.99
+    # and then "correcting" the result to the proper one. Modifies $x in place.
+    my ($class, $x, $scale) = @_;
+
+    # Taking blog() from numbers greater than 10 takes a *very long* time, so we
+    # break the computation down into parts based on the observation that:
+    #  blog(X*Y) = blog(X) + blog(Y)
+    # We set Y here to multiples of 10 so that $x becomes below 1 - the smaller
+    # $x is the faster it gets. Since 2*$x takes about 10 times as
+    # long, we make it faster by about a factor of 100 by dividing $x by 10.
+
+    # The same observation is valid for numbers smaller than 0.1, e.g. computing
+    # log(1) is fastest, and the further away we get from 1, the longer it takes.
+    # So we also 'break' this down by multiplying $x with 10 and subtract the
+    # log(10) afterwards to get the correct result.
+
+    # To get $x even closer to 1, we also divide by 2 and then use log(2) to
+    # correct for this. For instance if $x is 2.4, we use the formula:
+    #  blog(2.4 * 2) == blog (1.2) + blog(2)
+    # and thus calculate only blog(1.2) and blog(2), which is faster in total
+    # than calculating blog(2.4).
+
+    # In addition, the values for blog(2) and blog(10) are cached.
+
+    # Calculate nr of digits before dot:
+    my $dbd = $MBI->_num($x->{_e});
+    $dbd = -$dbd if $x->{_es} eq '-';
+    $dbd += $MBI->_len($x->{_m});
+
+    # more than one digit (e.g. at least 10), but *not* exactly 10 to avoid
+    # infinite recursion
+
+    my $calc = 1;               # do some calculation?
+
+    # disable the shortcut for 10, since we need log(10) and this would recurse
+    # infinitely deep
+    if ($x->{_es} eq '+' && $MBI->_is_one($x->{_e}) && $MBI->_is_one($x->{_m})) {
+        $dbd = 0;               # disable shortcut
+        # we can use the cached value in these cases
+        if ($scale <= $LOG_10_A) {
+            $x->bzero();
+            $x->badd($LOG_10); # modify $x in place
+            $calc = 0;                      # no need to calc, but round
+        }
+        # if we can't use the shortcut, we continue normally
+    } else {
+        # disable the shortcut for 2, since we maybe have it cached
+        if (($MBI->_is_zero($x->{_e}) && $MBI->_is_two($x->{_m}))) {
+            $dbd = 0;           # disable shortcut
+            # we can use the cached value in these cases
+            if ($scale <= $LOG_2_A) {
+                $x->bzero();
+                $x->badd($LOG_2); # modify $x in place
+                $calc = 0;                     # no need to calc, but round
+            }
+            # if we can't use the shortcut, we continue normally
+        }
+    }
 
-        if ($two_expon > 0) {
-            my $factor = $class -> new("2") -> bpow($two_expon);
-            $self -> bmul($factor);
-        } elsif ($two_expon < 0) {
-            my $factor = $class -> new("0.5") -> bpow(-$two_expon);
-            $self -> bmul($factor);
+    # if $x = 0.1, we know the result must be 0-log(10)
+    if ($calc != 0 && $x->{_es} eq '-' && $MBI->_is_one($x->{_e}) &&
+        $MBI->_is_one($x->{_m})) {
+        $dbd = 0;               # disable shortcut
+        # we can use the cached value in these cases
+        if ($scale <= $LOG_10_A) {
+            $x->bzero();
+            $x->bsub($LOG_10);
+            $calc = 0;          # no need to calc, but round
         }
+    }
+
+    return if $calc == 0;       # already have the result
+
+    # default: these correction factors are undef and thus not used
+    my $l_10;                   # value of ln(10) to A of $scale
+    my $l_2;                    # value of ln(2) to A of $scale
+
+    my $two = $class->new(2);
+
+    # $x == 2 => 1, $x == 13 => 2, $x == 0.1 => 0, $x == 0.01 => -1
+    # so don't do this shortcut for 1 or 0
+    if (($dbd > 1) || ($dbd < 0)) {
+        # convert our cached value to an object if not already (avoid doing this
+        # at import() time, since not everybody needs this)
+        $LOG_10 = $class->new($LOG_10, undef, undef) unless ref $LOG_10;
+
+        #print "x = $x, dbd = $dbd, calc = $calc\n";
+        # got more than one digit before the dot, or more than one zero after the
+        # dot, so do:
+        #  log(123)    == log(1.23) + log(10) * 2
+        #  log(0.0123) == log(1.23) - log(10) * 2
+
+        if ($scale <= $LOG_10_A) {
+            # use cached value
+            $l_10 = $LOG_10->copy(); # copy for mul
+        } else {
+            # else: slower, compute and cache result
+            # also disable downgrade for this code path
+            local $Math::BigFloat::downgrade = undef;
+
+            # shorten the time to calculate log(10) based on the following:
+            # log(1.25 * 8) = log(1.25) + log(8)
+            #               = log(1.25) + log(2) + log(2) + log(2)
+
+            # first get $l_2 (and possible compute and cache log(2))
+            $LOG_2 = $class->new($LOG_2, undef, undef) unless ref $LOG_2;
+            if ($scale <= $LOG_2_A) {
+                # use cached value
+                $l_2 = $LOG_2->copy(); # copy() for the mul below
+            } else {
+                # else: slower, compute and cache result
+                $l_2 = $two->copy();
+                $class->_log($l_2, $scale); # scale+4, actually
+                $LOG_2 = $l_2->copy(); # cache the result for later
+                # the copy() is for mul below
+                $LOG_2_A = $scale;
+            }
+
+            # now calculate log(1.25):
+            $l_10 = $class->new('1.25');
+            $class->_log($l_10, $scale); # scale+4, actually
+
+            # log(1.25) + log(2) + log(2) + log(2):
+            $l_10->badd($l_2);
+            $l_10->badd($l_2);
+            $l_10->badd($l_2);
+            $LOG_10 = $l_10->copy(); # cache the result for later
+            # the copy() is for mul below
+            $LOG_10_A = $scale;
+        }
+        $dbd-- if ($dbd > 1);       # 20 => dbd=2, so make it dbd=1
+        $l_10->bmul($class->new($dbd)); # log(10) * (digits_before_dot-1)
+        my $dbd_sign = '+';
+        if ($dbd < 0) {
+            $dbd = -$dbd;
+            $dbd_sign = '-';
+        }
+        ($x->{_e}, $x->{_es}) =
+          _e_sub($x->{_e}, $MBI->_new($dbd), $x->{_es}, $dbd_sign); # 123 => 1.23
 
-        return $self;
     }
 
-    return $self->bnan();
-}
+    # Now: 0.1 <= $x < 10 (and possible correction in l_10)
 
-1;
+    ### Since $x in the range 0.5 .. 1.5 is MUCH faster, we do a repeated div
+    ### or mul by 2 (maximum times 3, since x < 10 and x > 0.1)
 
-__END__
+    $HALF = $class->new($HALF) unless ref($HALF);
 
-=pod
+    my $twos = 0;               # default: none (0 times)
+    while ($x->bacmp($HALF) <= 0) { # X <= 0.5
+        $twos--;
+        $x->bmul($two);
+    }
+    while ($x->bacmp($two) >= 0) { # X >= 2
+        $twos++;
+        $x->bdiv($two, $scale+4); # keep all digits
+    }
+    $x->bround($scale+4);
+    # $twos > 0 => did mul 2, < 0 => did div 2 (but we never did both)
+    # So calculate correction factor based on ln(2):
+    if ($twos != 0) {
+        $LOG_2 = $class->new($LOG_2, undef, undef) unless ref $LOG_2;
+        if ($scale <= $LOG_2_A) {
+            # use cached value
+            $l_2 = $LOG_2->copy(); # copy() for the mul below
+        } else {
+            # else: slower, compute and cache result
+            # also disable downgrade for this code path
+            local $Math::BigFloat::downgrade = undef;
+            $l_2 = $two->copy();
+            $class->_log($l_2, $scale); # scale+4, actually
+            $LOG_2 = $l_2->copy(); # cache the result for later
+            # the copy() is for mul below
+            $LOG_2_A = $scale;
+        }
+        $l_2->bmul($twos);      # * -2 => subtract, * 2 => add
+    } else {
+        undef $l_2;
+    }
 
-=head1 NAME
+    $class->_log($x, $scale);       # need to do the "normal" way
+    $x->badd($l_10) if defined $l_10; # correct it by ln(10)
+    $x->badd($l_2) if defined $l_2;   # and maybe by ln(2)
 
-Math::BigFloat - Arbitrary size floating point math package
+    # all done, $x contains now the result
+    $x;
+}
 
-=head1 SYNOPSIS
+sub _e_add {
+    # Internal helper sub to take two positive integers and their signs and
+    # then add them. Input ($CALC, $CALC, ('+'|'-'), ('+'|'-')), output
+    # ($CALC, ('+'|'-')).
 
- use Math::BigFloat;
-
- # Number creation
- my $x = Math::BigFloat->new($str);	# defaults to 0
- my $y = $x->copy();			# make a true copy
- my $nan  = Math::BigFloat->bnan();	# create a NotANumber
- my $zero = Math::BigFloat->bzero();	# create a +0
- my $inf = Math::BigFloat->binf();	# create a +inf
- my $inf = Math::BigFloat->binf('-');	# create a -inf
- my $one = Math::BigFloat->bone();	# create a +1
- my $mone = Math::BigFloat->bone('-');	# create a -1
- my $x = Math::BigFloat->bone('-');	#
-
- my $x = Math::BigFloat->from_hex('0xc.afep+3');    # from hexadecimal
- my $x = Math::BigFloat->from_bin('0b1.1001p-4');   # from binary
- my $x = Math::BigFloat->from_oct('1.3267p-4');     # from octal
-
- my $pi = Math::BigFloat->bpi(100);	# PI to 100 digits
-
- # the following examples compute their result to 100 digits accuracy:
- my $cos  = Math::BigFloat->new(1)->bcos(100);	      # cosinus(1)
- my $sin  = Math::BigFloat->new(1)->bsin(100);	      # sinus(1)
- my $atan = Math::BigFloat->new(1)->batan(100);	      # arcus tangens(1)
-
- my $atan2 = Math::BigFloat->new(  1 )->batan2( 1 ,100); # batan(1)
- my $atan2 = Math::BigFloat->new(  1 )->batan2( 8 ,100); # batan(1/8)
- my $atan2 = Math::BigFloat->new( -2 )->batan2( 1 ,100); # batan(-2)
-
- # Testing
- $x->is_zero();		 # true if arg is +0
- $x->is_nan();		 # true if arg is NaN
- $x->is_one();		 # true if arg is +1
- $x->is_one('-');	 # true if arg is -1
- $x->is_odd();		 # true if odd, false for even
- $x->is_even();		 # true if even, false for odd
- $x->is_pos();		 # true if >= 0
- $x->is_neg();		 # true if <  0
- $x->is_inf(sign);	 # true if +inf, or -inf (default is '+')
-
- $x->bcmp($y);		 # compare numbers (undef,<0,=0,>0)
- $x->bacmp($y);		 # compare absolutely (undef,<0,=0,>0)
- $x->sign();		 # return the sign, either +,- or NaN
- $x->digit($n);		 # return the nth digit, counting from right
- $x->digit(-$n);	 # return the nth digit, counting from left 
-
- # The following all modify their first argument. If you want to pre-
- # serve $x, use $z = $x->copy()->bXXX($y); See under L</CAVEATS> for
- # necessary when mixing $a = $b assignments with non-overloaded math.
-
- # set 
- $x->bzero();		 # set $i to 0
- $x->bnan();		 # set $i to NaN
- $x->bone();		 # set $x to +1
- $x->bone('-');		 # set $x to -1
- $x->binf();		 # set $x to inf
- $x->binf('-');		 # set $x to -inf
-
- $x->bneg();		 # negation
- $x->babs();		 # absolute value
- $x->bnorm();		 # normalize (no-op)
- $x->bnot();		 # two's complement (bit wise not)
- $x->binc();		 # increment x by 1
- $x->bdec();		 # decrement x by 1
-
- $x->badd($y);		 # addition (add $y to $x)
- $x->bsub($y);		 # subtraction (subtract $y from $x)
- $x->bmul($y);		 # multiplication (multiply $x by $y)
- $x->bdiv($y);		 # divide, set $x to quotient
-			 # return (quo,rem) or quo if scalar
-
- $x->bmod($y);		 # modulus ($x % $y)
- $x->bpow($y);		 # power of arguments ($x ** $y)
- $x->bmodpow($exp,$mod); # modular exponentiation (($num**$exp) % $mod))
- $x->blsft($y, $n);	 # left shift by $y places in base $n
- $x->brsft($y, $n);	 # right shift by $y places in base $n
-			 # returns (quo,rem) or quo if in scalar context
-
- $x->blog();		 # logarithm of $x to base e (Euler's number)
- $x->blog($base);	 # logarithm of $x to base $base (f.i. 2)
- $x->bexp();		 # calculate e ** $x where e is Euler's number
-
- $x->band($y);		 # bit-wise and
- $x->bior($y);		 # bit-wise inclusive or
- $x->bxor($y);		 # bit-wise exclusive or
- $x->bnot();		 # bit-wise not (two's complement)
-
- $x->bsqrt();		 # calculate square-root
- $x->broot($y);		 # $y'th root of $x (e.g. $y == 3 => cubic root)
- $x->bfac();		 # factorial of $x (1*2*3*4*..$x)
-
- $x->bround($N); 	 # accuracy: preserve $N digits
- $x->bfround($N);	 # precision: round to the $Nth digit
-
- $x->bfloor();		 # return integer less or equal than $x
- $x->bceil();		 # return integer greater or equal than $x
- $x->bint();             # round towards zero
-
-  # The following do not modify their arguments:
-
- bgcd(@values);		 # greatest common divisor
- blcm(@values);		 # lowest common multiplicator
-
- $x->bstr();		 # return string
- $x->bsstr();		 # return string in scientific notation
-
- $x->as_int();		 # return $x as BigInt 
- $x->exponent();	 # return exponent as BigInt
- $x->mantissa();	 # return mantissa as BigInt
- $x->parts();		 # return (mantissa,exponent) as BigInt
-
- $x->length();		 # number of digits (w/o sign and '.')
- ($l,$f) = $x->length(); # number of digits, and length of fraction
-
- $x->precision();	 # return P of $x (or global, if P of $x undef)
- $x->precision($n);	 # set P of $x to $n
- $x->accuracy();	 # return A of $x (or global, if A of $x undef)
- $x->accuracy($n);	 # set A $x to $n
-
- # these get/set the appropriate global value for all BigFloat objects
- Math::BigFloat->precision();	# Precision
- Math::BigFloat->accuracy();	# Accuracy
- Math::BigFloat->round_mode();	# rounding mode
+    my ($x, $y, $xs, $ys) = @_;
 
-=head1 DESCRIPTION
+    # if the signs are equal we can add them (-5 + -3 => -(5 + 3) => -8)
+    if ($xs eq $ys) {
+        $x = $MBI->_add($x, $y); # +a + +b or -a + -b
+    } else {
+        my $a = $MBI->_acmp($x, $y);
+        if ($a == 0) {
+            # This does NOT modify $x in-place. TODO: Fix this?
+            $x = $MBI->_zero(); # result is 0
+            $xs = '+';
+            return ($x, $xs);
+        }
+        if ($a > 0) {
+            $x = $MBI->_sub($x, $y);     # abs sub
+        } else {                         # a < 0
+            $x = $MBI->_sub ($y, $x, 1); # abs sub
+            $xs = $ys;
+        }
+    }
 
-All operators (including basic math operations) are overloaded if you
-declare your big floating point numbers as
+    $xs = '+' if $xs eq '-' && $MBI->_is_zero($x); # no "-0"
 
-  $i = Math::BigFloat -> new('12_3.456_789_123_456_789E-2');
+    return ($x, $xs);
+}
 
-Operations with overloaded operators preserve the arguments, which is
-exactly what you expect.
+sub _e_sub {
+    # Internal helper sub to take two positive integers and their signs and
+    # then subtract them. Input ($CALC, $CALC, ('+'|'-'), ('+'|'-')),
+    # output ($CALC, ('+'|'-'))
+    my ($x, $y, $xs, $ys) = @_;
 
-=head2 Input
+    # flip sign
+    $ys = $ys eq '+' ? '-' : '+'; # swap sign of second operand ...
+    _e_add($x, $y, $xs, $ys);     # ... and let _e_add() do the job
+}
 
-Input to these routines are either BigFloat objects, or strings of the
-following four forms:
+sub _pow {
+    # Calculate a power where $y is a non-integer, like 2 ** 0.3
+    my ($x, $y, @r) = @_;
+    my $class = ref($x);
 
-=over
+    # if $y == 0.5, it is sqrt($x)
+    $HALF = $class->new($HALF) unless ref($HALF);
+    return $x->bsqrt(@r, $y) if $y->bcmp($HALF) == 0;
 
-=item *
+    # Using:
+    # a ** x == e ** (x * ln a)
 
-C</^[+-]\d+$/>
+    # u = y * ln x
+    #                _                         _
+    # Taylor:       |   u    u^2    u^3         |
+    # x ** y  = 1 + |  --- + --- + ----- + ...  |
+    #               |_  1    1*2   1*2*3       _|
 
-=item *
+    # we need to limit the accuracy to protect against overflow
+    my $fallback = 0;
+    my ($scale, @params);
+    ($x, @params) = $x->_find_round_parameters(@r);
 
-C</^[+-]\d+\.\d*$/>
+    return $x if $x->is_nan();  # error in _find_round_parameters?
 
-=item *
+    # no rounding at all, so must use fallback
+    if (scalar @params == 0) {
+        # simulate old behaviour
+        $params[0] = $class->div_scale(); # and round to it as accuracy
+        $params[1] = undef;               # disable P
+        $scale = $params[0]+4;            # at least four more for proper round
+        $params[2] = $r[2];               # round mode by caller or undef
+        $fallback = 1;                    # to clear a/p afterwards
+    } else {
+        # the 4 below is empirical, and there might be cases where it is not
+        # enough...
+        $scale = abs($params[0] || $params[1]) + 4; # take whatever is defined
+    }
 
-C</^[+-]\d+E[+-]?\d+$/>
+    # when user set globals, they would interfere with our calculation, so
+    # disable them and later re-enable them
+    no strict 'refs';
+    my $abr = "$class\::accuracy"; my $ab = $$abr; $$abr = undef;
+    my $pbr = "$class\::precision"; my $pb = $$pbr; $$pbr = undef;
+    # we also need to disable any set A or P on $x (_find_round_parameters took
+    # them already into account), since these would interfere, too
+    delete $x->{_a};
+delete $x->{_p};
+    # need to disable $upgrade in BigInt, to avoid deep recursion
+    local $Math::BigInt::upgrade = undef;
 
-=item *
+    my ($limit, $v, $u, $below, $factor, $next, $over);
 
-C</^[+-]\d*\.\d+E[+-]?\d+$/>
+    $u = $x->copy()->blog(undef, $scale)->bmul($y);
+    my $do_invert = ($u->{sign} eq '-');
+    $u->bneg()  if $do_invert;
+    $v = $class->bone();        # 1
+    $factor = $class->new(2);   # 2
+    $x->bone();                 # first term: 1
 
-=back
+    $below = $v->copy();
+    $over = $u->copy();
 
-all with optional leading and trailing zeros and/or spaces. Additionally,
-numbers are allowed to have an underscore between any two digits.
+    $limit = $class->new("1E-". ($scale-1));
+    #my $steps = 0;
+    while (3 < 5) {
+        # we calculate the next term, and add it to the last
+        # when the next term is below our limit, it won't affect the outcome
+        # anymore, so we stop:
+        $next = $over->copy()->bdiv($below, $scale);
+        last if $next->bacmp($limit) <= 0;
+        $x->badd($next);
+        # calculate things for the next term
+        $over *= $u;
+        $below *= $factor;
+        $factor->binc();
 
-Empty strings as well as other illegal numbers results in 'NaN'.
+        last if $x->{sign} !~ /^[-+]$/;
 
-bnorm() on a BigFloat object is now effectively a no-op, since the numbers 
-are always stored in normalized form. On a string, it creates a BigFloat 
-object.
+        #$steps++;
+    }
 
-=head2 Output
+    if ($do_invert) {
+        my $x_copy = $x->copy();
+        $x->bone->bdiv($x_copy, $scale);
+    }
 
-Output values are BigFloat objects (normalized), except for bstr() and bsstr().
+    # shortcut to not run through _find_round_parameters again
+    if (defined $params[0]) {
+        $x->bround($params[0], $params[2]); # then round accordingly
+    } else {
+        $x->bfround($params[1], $params[2]); # then round accordingly
+    }
+    if ($fallback) {
+        # clear a/p after round, since user did not request it
+        delete $x->{_a};
+        delete $x->{_p};
+    }
+    # restore globals
+    $$abr = $ab;
+    $$pbr = $pb;
+    $x;
+}
 
-The string output will always have leading and trailing zeros stripped and drop
-a plus sign. C<bstr()> will give you always the form with a decimal point,
-while C<bsstr()> (s for scientific) gives you the scientific notation.
+# helper function for bpi() and batan2(), calculates arcus tanges (1/x)
 
-	Input			bstr()		bsstr()
-	'-0'			'0'		'0E1'
-   	'  -123 123 123'	'-123123123'	'-123123123E0'
-	'00.0123'		'0.0123'	'123E-4'
-	'123.45E-2'		'1.2345'	'12345E-4'
-	'10E+3'			'10000'		'1E4'
+sub _atan_inv {
+    # return a/b so that a/b approximates atan(1/x) to at least limit digits
+    my ($class, $x, $limit) = @_;
 
-Some routines (C<is_odd()>, C<is_even()>, C<is_zero()>, C<is_one()>,
-C<is_nan()>) return true or false, while others (C<bcmp()>, C<bacmp()>)
-return either undef, <0, 0 or >0 and are suited for sort.
+    # Taylor:       x^3   x^5   x^7   x^9
+    #    atan = x - --- + --- - --- + --- - ...
+    #                3     5     7     9
 
-Actual math is done by using the class defined with C<< with => Class; >>
-(which defaults to BigInts) to represent the mantissa and exponent.
+    #               1      1         1        1
+    #    atan 1/x = - - ------- + ------- - ------- + ...
+    #               x   x^3 * 3   x^5 * 5   x^7 * 7
 
-The sign C</^[+-]$/> is stored separately. The string 'NaN' is used to 
-represent the result when input arguments are not numbers, and 'inf' and
-'-inf' are used to represent positive and negative infinity, respectively.
+    #               1      1         1            1
+    #    atan 1/x = - - --------- + ---------- - ----------- + ...
+    #               5    3 * 125     5 * 3125     7 * 78125
 
-=head2 mantissa(), exponent() and parts()
+    # Subtraction/addition of a rational:
 
-mantissa() and exponent() return the said parts of the BigFloat
-as BigInts such that:
+    #  5    7    5*3 +- 7*4
+    #  - +- -  = ----------
+    #  4    3       4*3
 
-	$m = $x->mantissa();
-	$e = $x->exponent();
-	$y = $m * ( 10 ** $e );
-	print "ok\n" if $x == $y;
+    # Term:  N        N+1
+    #
+    #        a             1                  a * d * c +- b
+    #        ----- +- ------------------  =  ----------------
+    #        b           d * c                b * d * c
+
+    #  since b1 = b0 * (d-2) * c
+
+    #        a             1                  a * d +- b / c
+    #        ----- +- ------------------  =  ----------------
+    #        b           d * c                b * d
+
+    # and  d = d + 2
+    # and  c = c * x * x
+
+    #        u = d * c
+    #        stop if length($u) > limit
+    #        a = a * u +- b
+    #        b = b * u
+    #        d = d + 2
+    #        c = c * x * x
+    #        sign = 1 - sign
+
+    my $a = $MBI->_one();
+    my $b = $MBI->_copy($x);
+
+    my $x2  = $MBI->_mul($MBI->_copy($x), $b); # x2 = x * x
+    my $d   = $MBI->_new(3);                   # d = 3
+    my $c   = $MBI->_mul($MBI->_copy($x), $x2); # c = x ^ 3
+    my $two = $MBI->_new(2);
+
+    # run the first step unconditionally
+    my $u = $MBI->_mul($MBI->_copy($d), $c);
+    $a = $MBI->_mul($a, $u);
+    $a = $MBI->_sub($a, $b);
+    $b = $MBI->_mul($b, $u);
+    $d = $MBI->_add($d, $two);
+    $c = $MBI->_mul($c, $x2);
 
-C<< ($m,$e) = $x->parts(); >> is just a shortcut giving you both of them.
+    # a is now a * (d-3) * c
+    # b is now b * (d-2) * c
 
-Currently the mantissa is reduced as much as possible, favouring higher
-exponents over lower ones (e.g. returning 1e7 instead of 10e6 or 10000000e0).
-This might change in the future, so do not depend on it.
+    # run the second step unconditionally
+    $u = $MBI->_mul($MBI->_copy($d), $c);
+    $a = $MBI->_mul($a, $u);
+    $a = $MBI->_add($a, $b);
+    $b = $MBI->_mul($b, $u);
+    $d = $MBI->_add($d, $two);
+    $c = $MBI->_mul($c, $x2);
 
-=head2 Accuracy vs. Precision
+    # a is now a * (d-3) * (d-5) * c * c
+    # b is now b * (d-2) * (d-4) * c * c
+
+    # so we can remove c * c from both a and b to shorten the numbers involved:
+    $a = $MBI->_div($a, $x2);
+    $b = $MBI->_div($b, $x2);
+    $a = $MBI->_div($a, $x2);
+    $b = $MBI->_div($b, $x2);
+
+    #  my $step = 0;
+    my $sign = 0;               # 0 => -, 1 => +
+    while (3 < 5) {
+        #    $step++;
+        #    if (($i++ % 100) == 0)
+        #      {
+        #    print "a=", $MBI->_str($a), "\n";
+        #    print "b=", $MBI->_str($b), "\n";
+        #      }
+        #    print "d=", $MBI->_str($d), "\n";
+        #    print "x2=", $MBI->_str($x2), "\n";
+        #    print "c=", $MBI->_str($c), "\n";
+
+        my $u = $MBI->_mul($MBI->_copy($d), $c);
+        # use _alen() for libs like GMP where _len() would be O(N^2)
+        last if $MBI->_alen($u) > $limit;
+        my ($bc, $r) = $MBI->_div($MBI->_copy($b), $c);
+        if ($MBI->_is_zero($r)) {
+            # b / c is an integer, so we can remove c from all terms
+            # this happens almost every time:
+            $a = $MBI->_mul($a, $d);
+            $a = $MBI->_sub($a, $bc) if $sign == 0;
+            $a = $MBI->_add($a, $bc) if $sign == 1;
+            $b = $MBI->_mul($b, $d);
+        } else {
+            # b / c is not an integer, so we keep c in the terms
+            # this happens very rarely, for instance for x = 5, this happens only
+            # at the following steps:
+            # 1, 5, 14, 32, 72, 157, 340, ...
+            $a = $MBI->_mul($a, $u);
+            $a = $MBI->_sub($a, $b) if $sign == 0;
+            $a = $MBI->_add($a, $b) if $sign == 1;
+            $b = $MBI->_mul($b, $u);
+        }
+        $d = $MBI->_add($d, $two);
+        $c = $MBI->_mul($c, $x2);
+        $sign = 1 - $sign;
 
-See also: L<Rounding|/Rounding>.
+    }
 
-Math::BigFloat supports both precision (rounding to a certain place before or
-after the dot) and accuracy (rounding to a certain number of digits). For a
-full documentation, examples and tips on these topics please see the large
-section about rounding in L<Math::BigInt>.
+    #  print "Took $step steps for ", $MBI->_str($x), "\n";
+    #  print "a=", $MBI->_str($a), "\n"; print "b=", $MBI->_str($b), "\n";
+    # return a/b so that a/b approximates atan(1/x)
+    ($a, $b);
+}
 
-Since things like C<sqrt(2)> or C<1 / 3> must presented with a limited
-accuracy lest a operation consumes all resources, each operation produces
-no more than the requested number of digits.
+1;
 
-If there is no global precision or accuracy set, B<and> the operation in
-question was not called with a requested precision or accuracy, B<and> the
-input $x has no accuracy or precision set, then a fallback parameter will
-be used. For historical reasons, it is called C<div_scale> and can be accessed
-via:
+__END__
 
-	$d = Math::BigFloat->div_scale();	# query
-	Math::BigFloat->div_scale($n);		# set to $n digits
+=pod
 
-The default value for C<div_scale> is 40.
+=head1 NAME
 
-In case the result of one operation has more digits than specified,
-it is rounded. The rounding mode taken is either the default mode, or the one
-supplied to the operation after the I<scale>:
+Math::BigFloat - Arbitrary size floating point math package
 
-    $x = Math::BigFloat->new(2);
-    Math::BigFloat->accuracy(5);	      # 5 digits max
-    $y = $x->copy()->bdiv(3);		      # will give 0.66667
-    $y = $x->copy()->bdiv(3,6);		      # will give 0.666667
-    $y = $x->copy()->bdiv(3,6,undef,'odd');   # will give 0.666667
-    Math::BigFloat->round_mode('zero');
-    $y = $x->copy()->bdiv(3,6);		      # will also give 0.666667
+=head1 SYNOPSIS
 
-Note that C<< Math::BigFloat->accuracy() >> and C<< Math::BigFloat->precision() >>
-set the global variables, and thus B<any> newly created number will be subject
-to the global rounding B<immediately>. This means that in the examples above, the
-C<3> as argument to C<bdiv()> will also get an accuracy of B<5>.
+  use Math::BigFloat;
+
+  # Configuration methods (may be used as class methods and instance methods)
+
+  Math::BigFloat->accuracy();     # get class accuracy
+  Math::BigFloat->accuracy($n);   # set class accuracy
+  Math::BigFloat->precision();    # get class precision
+  Math::BigFloat->precision($n);  # set class precision
+  Math::BigFloat->round_mode();   # get class rounding mode
+  Math::BigFloat->round_mode($m); # set global round mode, must be one of
+                                  # 'even', 'odd', '+inf', '-inf', 'zero',
+                                  # 'trunc', or 'common'
+  Math::BigFloat->config();       # return hash with configuration
+
+  # Constructor methods (when the class methods below are used as instance
+  # methods, the value is assigned the invocand)
+
+  $x = Math::BigFloat->new($str);               # defaults to 0
+  $x = Math::BigFloat->new('0x123');            # from hexadecimal
+  $x = Math::BigFloat->new('0b101');            # from binary
+  $x = Math::BigFloat->from_hex('0xc.afep+3');  # from hex
+  $x = Math::BigFloat->from_hex('cafe');        # ditto
+  $x = Math::BigFloat->from_oct('1.3267p-4');   # from octal
+  $x = Math::BigFloat->from_oct('0377');        # ditto
+  $x = Math::BigFloat->from_bin('0b1.1001p-4'); # from binary
+  $x = Math::BigFloat->from_bin('0101');        # ditto
+  $x = Math::BigFloat->bzero();                 # create a +0
+  $x = Math::BigFloat->bone();                  # create a +1
+  $x = Math::BigFloat->bone('-');               # create a -1
+  $x = Math::BigFloat->binf();                  # create a +inf
+  $x = Math::BigFloat->binf('-');               # create a -inf
+  $x = Math::BigFloat->bnan();                  # create a Not-A-Number
+  $x = Math::BigFloat->bpi();                   # returns pi
+
+  $y = $x->copy();        # make a copy (unlike $y = $x)
+  $y = $x->as_int();      # return as BigInt
+
+  # Boolean methods (these don't modify the invocand)
+
+  $x->is_zero();          # if $x is 0
+  $x->is_one();           # if $x is +1
+  $x->is_one("+");        # ditto
+  $x->is_one("-");        # if $x is -1
+  $x->is_inf();           # if $x is +inf or -inf
+  $x->is_inf("+");        # if $x is +inf
+  $x->is_inf("-");        # if $x is -inf
+  $x->is_nan();           # if $x is NaN
+
+  $x->is_positive();      # if $x > 0
+  $x->is_pos();           # ditto
+  $x->is_negative();      # if $x < 0
+  $x->is_neg();           # ditto
+
+  $x->is_odd();           # if $x is odd
+  $x->is_even();          # if $x is even
+  $x->is_int();           # if $x is an integer
+
+  # Comparison methods
+
+  $x->bcmp($y);           # compare numbers (undef, < 0, == 0, > 0)
+  $x->bacmp($y);          # compare absolutely (undef, < 0, == 0, > 0)
+  $x->beq($y);            # true if and only if $x == $y
+  $x->bne($y);            # true if and only if $x != $y
+  $x->blt($y);            # true if and only if $x < $y
+  $x->ble($y);            # true if and only if $x <= $y
+  $x->bgt($y);            # true if and only if $x > $y
+  $x->bge($y);            # true if and only if $x >= $y
+
+  # Arithmetic methods
+
+  $x->bneg();             # negation
+  $x->babs();             # absolute value
+  $x->bsgn();             # sign function (-1, 0, 1, or NaN)
+  $x->bnorm();            # normalize (no-op)
+  $x->binc();             # increment $x by 1
+  $x->bdec();             # decrement $x by 1
+  $x->badd($y);           # addition (add $y to $x)
+  $x->bsub($y);           # subtraction (subtract $y from $x)
+  $x->bmul($y);           # multiplication (multiply $x by $y)
+  $x->bmuladd($y,$z);     # $x = $x * $y + $z
+  $x->bdiv($y);           # division (floored), set $x to quotient
+                          # return (quo,rem) or quo if scalar
+  $x->btdiv($y);          # division (truncated), set $x to quotient
+                          # return (quo,rem) or quo if scalar
+  $x->bmod($y);           # modulus (x % y)
+  $x->btmod($y);          # modulus (truncated)
+  $x->bmodinv($mod);      # modular multiplicative inverse
+  $x->bmodpow($y,$mod);   # modular exponentiation (($x ** $y) % $mod)
+  $x->bpow($y);           # power of arguments (x ** y)
+  $x->blog();             # logarithm of $x to base e (Euler's number)
+  $x->blog($base);        # logarithm of $x to base $base (e.g., base 2)
+  $x->bexp();             # calculate e ** $x where e is Euler's number
+  $x->bnok($y);           # x over y (binomial coefficient n over k)
+  $x->bsin();             # sine
+  $x->bcos();             # cosine
+  $x->batan();            # inverse tangent
+  $x->batan2($y);         # two-argument inverse tangent
+  $x->bsqrt();            # calculate square-root
+  $x->broot($y);          # $y'th root of $x (e.g. $y == 3 => cubic root)
+  $x->bfac();             # factorial of $x (1*2*3*4*..$x)
+
+  $x->blsft($n);          # left shift $n places in base 2
+  $x->blsft($n,$b);       # left shift $n places in base $b
+                          # returns (quo,rem) or quo (scalar context)
+  $x->brsft($n);          # right shift $n places in base 2
+  $x->brsft($n,$b);       # right shift $n places in base $b
+                          # returns (quo,rem) or quo (scalar context)
+
+  # Bitwise methods
+
+  $x->band($y);           # bitwise and
+  $x->bior($y);           # bitwise inclusive or
+  $x->bxor($y);           # bitwise exclusive or
+  $x->bnot();             # bitwise not (two's complement)
+
+  # Rounding methods
+  $x->round($A,$P,$mode); # round to accuracy or precision using
+                          # rounding mode $mode
+  $x->bround($n);         # accuracy: preserve $n digits
+  $x->bfround($n);        # $n > 0: round to $nth digit left of dec. point
+                          # $n < 0: round to $nth digit right of dec. point
+  $x->bfloor();           # round towards minus infinity
+  $x->bceil();            # round towards plus infinity
+  $x->bint();             # round towards zero
+
+  # Other mathematical methods
+
+  $x->bgcd($y);            # greatest common divisor
+  $x->blcm($y);            # least common multiple
+
+  # Object property methods (do not modify the invocand)
+
+  $x->sign();              # the sign, either +, - or NaN
+  $x->digit($n);           # the nth digit, counting from the right
+  $x->digit(-$n);          # the nth digit, counting from the left
+  $x->length();            # return number of digits in number
+  ($xl,$f) = $x->length(); # length of number and length of fraction
+                           # part, latter is always 0 digits long
+                           # for Math::BigInt objects
+  $x->mantissa();          # return (signed) mantissa as BigInt
+  $x->exponent();          # return exponent as BigInt
+  $x->parts();             # return (mantissa,exponent) as BigInt
+  $x->sparts();            # mantissa and exponent (as integers)
+  $x->nparts();            # mantissa and exponent (normalised)
+  $x->eparts();            # mantissa and exponent (engineering notation)
+  $x->dparts();            # integer and fraction part
+
+  # Conversion methods (do not modify the invocand)
+
+  $x->bstr();         # decimal notation, possibly zero padded
+  $x->bsstr();        # string in scientific notation with integers
+  $x->bnstr();        # string in normalized notation
+  $x->bestr();        # string in engineering notation
+  $x->bdstr();        # string in decimal notation
+  $x->as_hex();       # as signed hexadecimal string with prefixed 0x
+  $x->as_bin();       # as signed binary string with prefixed 0b
+  $x->as_oct();       # as signed octal string with prefixed 0
+
+  # Other conversion methods
+
+  $x->numify();           # return as scalar (might overflow or underflow)
 
-It is less confusing to either calculate the result fully, and afterwards
-round it explicitly, or use the additional parameters to the math
-functions like so:
+=head1 DESCRIPTION
 
-	use Math::BigFloat;
-	$x = Math::BigFloat->new(2);
-	$y = $x->copy()->bdiv(3);
-	print $y->bround(5),"\n";		# will give 0.66667
+Math::BigFloat provides support for arbitrary precision floating point.
+Overloading is also provided for Perl operators.
 
-	or
+All operators (including basic math operations) are overloaded if you
+declare your big floating point numbers as
 
-	use Math::BigFloat;
-	$x = Math::BigFloat->new(2);
-	$y = $x->copy()->bdiv(3,5);		# will give 0.66667
-	print "$y\n";
+  $x = Math::BigFloat -> new('12_3.456_789_123_456_789E-2');
 
-=head2 Rounding
+Operations with overloaded operators preserve the arguments, which is
+exactly what you expect.
+
+=head2 Input
+
+Input values to these routines may be any scalar number or string that looks
+like a number and represents a floating point number.
 
 =over
 
-=item bfround ( +$scale )
+=item *
 
-Rounds to the $scale'th place left from the '.', counting from the dot.
-The first digit is numbered 1. 
+Leading and trailing whitespace is ignored.
 
-=item bfround ( -$scale )
+=item *
 
-Rounds to the $scale'th place right from the '.', counting from the dot.
+Leading and trailing zeros are ignored.
 
-=item bfround ( 0 )
+=item *
 
-Rounds to an integer.
+If the string has a "0x" prefix, it is interpreted as a hexadecimal number.
 
-=item bround  ( +$scale )
+=item *
 
-Preserves accuracy to $scale digits from the left (aka significant digits)
-and pads the rest with zeros. If the number is between 1 and -1, the
-significant digits count from the first non-zero after the '.'
+If the string has a "0b" prefix, it is interpreted as a binary number.
 
-=item bround  ( -$scale ) and bround ( 0 )
+=item *
 
-These are effectively no-ops.
+For hexadecimal and binary numbers, the exponent must be separated from the
+significand (mantissa) by the letter "p" or "P", not "e" or "E" as with decimal
+numbers.
+
+=item *
+
+One underline is allowed between any two digits, including hexadecimal and
+binary digits.
+
+=item *
+
+If the string can not be interpreted, NaN is returned.
 
 =back
 
-All rounding functions take as a second parameter a rounding mode from one of
-the following: 'even', 'odd', '+inf', '-inf', 'zero', 'trunc' or 'common'.
+Octal numbers are typically prefixed by "0", but since leading zeros are
+stripped, these methods can not automatically recognize octal numbers, so use
+the constructor from_oct() to intepret octal strings.
 
-The default rounding mode is 'even'. By using
-C<< Math::BigFloat->round_mode($round_mode); >> you can get and set the default
-mode for subsequent rounding. The usage of C<$Math::BigFloat::$round_mode> is
-no longer supported.
-The second parameter to the round functions then overrides the default
-temporarily. 
+Some examples of valid string input
 
-The C<as_number()> function returns a BigInt from a Math::BigFloat. It uses
-'trunc' as rounding mode to make it equivalent to:
+    Input string                Resulting value
+    123                         123
+    1.23e2                      123
+    12300e-2                    123
+    0xcafe                      51966
+    0b1101                      13
+    67_538_754                  67538754
+    -4_5_6.7_8_9e+0_1_0         -4567890000000
+    0x1.921fb5p+1               3.14159262180328369140625e+0
+    0b1.1001p-4                 9.765625e-2
 
-	$x = 2.5;
-	$y = int($x) + 2;
+=head2 Output
 
-You can override this by passing the desired rounding mode as parameter to
-C<as_number()>:
+Output values are usually Math::BigFloat objects.
 
-	$x = Math::BigFloat->new(2.5);
-	$y = $x->as_number('odd');	# $y = 3
+Boolean operators C<is_zero()>, C<is_one()>, C<is_inf()>, etc. return true or
+false.
+
+Comparison operators C<bcmp()> and C<bacmp()>) return -1, 0, 1, or
+undef.
 
 =head1 METHODS
 
 Math::BigFloat supports all methods that Math::BigInt supports, except it
-calculates non-integer results when possible. Please see L<Math::BigInt>
-for a full description of each method. Below are just the most important
-differences:
+calculates non-integer results when possible. Please see L<Math::BigInt> for a
+full description of each method. Below are just the most important differences:
+
+=head2 Configuration methods
 
 =over
 
 =item accuracy()
 
-      $x->accuracy(5);           # local for $x
-      CLASS->accuracy(5);        # global for all members of CLASS
-                                 # Note: This also applies to new()!
+    $x->accuracy(5);           # local for $x
+    CLASS->accuracy(5);        # global for all members of CLASS
+                               # Note: This also applies to new()!
 
-      $A = $x->accuracy();       # read out accuracy that affects $x
-      $A = CLASS->accuracy();    # read out global accuracy
+    $A = $x->accuracy();       # read out accuracy that affects $x
+    $A = CLASS->accuracy();    # read out global accuracy
 
 Set or get the global or local accuracy, aka how many significant digits the
 results have. If you set a global accuracy, then this also applies to new()!
@@ -4649,36 +4972,101 @@ influence of C<< CLASS->accuracy($A) >>, all results from math operations with
 that number will also be rounded.
 
 In most cases, you should probably round the results explicitly using one of
-L<Math::BigInt/round()>, L<Math::BigInt/bround()> or L<Math::BigInt/bfround()> or by passing the desired accuracy
-to the math operation as additional parameter:
+L<Math::BigInt/round()>, L<Math::BigInt/bround()> or L<Math::BigInt/bfround()>
+or by passing the desired accuracy to the math operation as additional
+parameter:
 
-        my $x = Math::BigInt->new(30000);
-        my $y = Math::BigInt->new(7);
-        print scalar $x->copy()->bdiv($y, 2);           # print 4300
-        print scalar $x->copy()->bdiv($y)->bround(2);   # print 4300
+    my $x = Math::BigInt->new(30000);
+    my $y = Math::BigInt->new(7);
+    print scalar $x->copy()->bdiv($y, 2);           # print 4300
+    print scalar $x->copy()->bdiv($y)->bround(2);   # print 4300
 
 =item precision()
 
-      $x->precision(-2);      # local for $x, round at the second
+    $x->precision(-2);        # local for $x, round at the second
                               # digit right of the dot
-      $x->precision(2);       # ditto, round at the second digit
+    $x->precision(2);         # ditto, round at the second digit
                               # left of the dot
 
-      CLASS->precision(5);    # Global for all members of CLASS
+    CLASS->precision(5);      # Global for all members of CLASS
                               # This also applies to new()!
-      CLASS->precision(-5);   # ditto
+    CLASS->precision(-5);     # ditto
 
-      $P = CLASS->precision();  # read out global precision
-      $P = $x->precision();     # read out precision that affects $x
+    $P = CLASS->precision();  # read out global precision
+    $P = $x->precision();     # read out precision that affects $x
 
 Note: You probably want to use L</accuracy()> instead. With L</accuracy()> you
 set the number of digits each result should have, with L</precision()> you
 set the place where to round!
 
+=back
+
+=head2 Constructor methods
+
+=over
+
+=item from_hex()
+
+    $x -> from_hex("0x1.921fb54442d18p+1");
+    $x = Math::BigFloat -> from_hex("0x1.921fb54442d18p+1");
+
+Interpret input as a hexadecimal string.A prefix ("0x", "x", ignoring case) is
+optional. A single underscore character ("_") may be placed between any two
+digits. If the input is invalid, a NaN is returned. The exponent is in base 2
+using decimal digits.
+
+If called as an instance method, the value is assigned to the invocand.
+
+=item from_oct()
+
+    $x -> from_oct("1.3267p-4");
+    $x = Math::BigFloat -> from_oct("1.3267p-4");
+
+Interpret input as an octal string. A single underscore character ("_") may be
+placed between any two digits. If the input is invalid, a NaN is returned. The
+exponent is in base 2 using decimal digits.
+
+If called as an instance method, the value is assigned to the invocand.
+
+=item from_bin()
+
+    $x -> from_bin("0b1.1001p-4");
+    $x = Math::BigFloat -> from_bin("0b1.1001p-4");
+
+Interpret input as a hexadecimal string. A prefix ("0b" or "b", ignoring case)
+is optional. A single underscore character ("_") may be placed between any two
+digits. If the input is invalid, a NaN is returned. The exponent is in base 2
+using decimal digits.
+
+If called as an instance method, the value is assigned to the invocand.
+
+=item bpi()
+
+    print Math::BigFloat->bpi(100), "\n";
+
+Calculate PI to N digits (including the 3 before the dot). The result is
+rounded according to the current rounding mode, which defaults to "even".
+
+This method was added in v1.87 of Math::BigInt (June 2007).
+
+=back
+
+=head2 Arithmetic methods
+
+=over
+
+=item bmuladd()
+
+    $x->bmuladd($y,$z);
+
+Multiply $x by $y, and then add $z to the result.
+
+This method was added in v1.87 of Math::BigInt (June 2007).
+
 =item bdiv()
 
-        $q = $x->bdiv($y);
-        ($q, $r) = $x->bdiv($y);
+    $q = $x->bdiv($y);
+    ($q, $r) = $x->bdiv($y);
 
 In scalar context, divides $x by $y and returns the result to the given or
 default accuracy/precision. In list context, does floored division
@@ -4687,7 +5075,7 @@ $r. The remainer (modulo) is equal to what is returned by C<$x->bmod($y)>.
 
 =item bmod()
 
-	$x->bmod($y);
+    $x->bmod($y);
 
 Returns $x modulo $y. When $x is finite, and $y is finite and non-zero, the
 result is identical to the remainder after floored division (F-division). If,
@@ -4696,7 +5084,7 @@ from Perl's % operator.
 
 =item bexp()
 
-	$x->bexp($accuracy);		# calculate e ** X
+    $x->bexp($accuracy);            # calculate e ** X
 
 Calculates the expression C<e ** $x> where C<e> is Euler's number.
 
@@ -4704,72 +5092,55 @@ This method was added in v1.82 of Math::BigInt (April 2007).
 
 =item bnok()
 
-	$x->bnok($y);	# x over y (binomial coefficient n over k)
+    $x->bnok($y);   # x over y (binomial coefficient n over k)
 
 Calculates the binomial coefficient n over k, also called the "choose"
 function. The result is equivalent to:
 
-	( n )      n!
-	| - |  = -------
-	( k )    k!(n-k)!
+    ( n )      n!
+    | - |  = -------
+    ( k )    k!(n-k)!
 
 This method was added in v1.84 of Math::BigInt (April 2007).
 
-=item bpi()
+=item bsin()
 
-	print Math::BigFloat->bpi(100), "\n";
+    my $x = Math::BigFloat->new(1);
+    print $x->bsin(100), "\n";
 
-Calculate PI to N digits (including the 3 before the dot). The result is
-rounded according to the current rounding mode, which defaults to "even".
+Calculate the sinus of $x, modifying $x in place.
 
 This method was added in v1.87 of Math::BigInt (June 2007).
 
 =item bcos()
 
-	my $x = Math::BigFloat->new(1);
-	print $x->bcos(100), "\n";
+    my $x = Math::BigFloat->new(1);
+    print $x->bcos(100), "\n";
 
 Calculate the cosinus of $x, modifying $x in place.
 
 This method was added in v1.87 of Math::BigInt (June 2007).
 
-=item bsin()
+=item batan()
 
-	my $x = Math::BigFloat->new(1);
-	print $x->bsin(100), "\n";
+    my $x = Math::BigFloat->new(1);
+    print $x->batan(100), "\n";
 
-Calculate the sinus of $x, modifying $x in place.
+Calculate the arcus tanges of $x, modifying $x in place. See also L</batan2()>.
 
 This method was added in v1.87 of Math::BigInt (June 2007).
 
 =item batan2()
 
-	my $y = Math::BigFloat->new(2);
-	my $x = Math::BigFloat->new(3);
-	print $y->batan2($x), "\n";
+    my $y = Math::BigFloat->new(2);
+    my $x = Math::BigFloat->new(3);
+    print $y->batan2($x), "\n";
 
 Calculate the arcus tanges of C<$y> divided by C<$x>, modifying $y in place.
 See also L</batan()>.
 
 This method was added in v1.87 of Math::BigInt (June 2007).
 
-=item batan()
-
-	my $x = Math::BigFloat->new(1);
-	print $x->batan(100), "\n";
-
-Calculate the arcus tanges of $x, modifying $x in place. See also L</batan2()>.
-
-This method was added in v1.87 of Math::BigInt (June 2007).
-
-=item bmuladd()
-
-	$x->bmuladd($y,$z);
-
-Multiply $x by $y, and then add $z to the result.
-
-This method was added in v1.87 of Math::BigInt (June 2007).
-
 =item as_float()
 
 This method is called when Math::BigFloat encounters an object it doesn't know
@@ -4788,43 +5159,116 @@ C<ref($x)-E<gt>new()> can parse to create an object.
 
 In Math::BigFloat, C<as_float()> has the same effect as C<copy()>.
 
-=item from_hex()
+=back
 
-    $x -> from_hex("0x1.921fb54442d18p+1");
-    $x = Math::BigFloat -> from_hex("0x1.921fb54442d18p+1");
+=head2 ACCURACY AND PRECISION
 
-Interpret input as a hexadecimal string.A prefix ("0x", "x", ignoring case) is
-optional. A single underscore character ("_") may be placed between any two
-digits. If the input is invalid, a NaN is returned. The exponent is in base 2
-using decimal digits.
+See also: L<Rounding|/Rounding>.
 
-If called as an instance method, the value is assigned to the invocand.
+Math::BigFloat supports both precision (rounding to a certain place before or
+after the dot) and accuracy (rounding to a certain number of digits). For a
+full documentation, examples and tips on these topics please see the large
+section about rounding in L<Math::BigInt>.
 
-=item from_bin()
+Since things like C<sqrt(2)> or C<1 / 3> must presented with a limited
+accuracy lest a operation consumes all resources, each operation produces
+no more than the requested number of digits.
 
-    $x -> from_bin("0b1.1001p-4");
-    $x = Math::BigFloat -> from_bin("0b1.1001p-4");
+If there is no global precision or accuracy set, B<and> the operation in
+question was not called with a requested precision or accuracy, B<and> the
+input $x has no accuracy or precision set, then a fallback parameter will
+be used. For historical reasons, it is called C<div_scale> and can be accessed
+via:
 
-Interpret input as a hexadecimal string. A prefix ("0b" or "b", ignoring case)
-is optional. A single underscore character ("_") may be placed between any two
-digits. If the input is invalid, a NaN is returned. The exponent is in base 2
-using decimal digits.
+    $d = Math::BigFloat->div_scale();       # query
+    Math::BigFloat->div_scale($n);          # set to $n digits
 
-If called as an instance method, the value is assigned to the invocand.
+The default value for C<div_scale> is 40.
 
-=item from_oct()
+In case the result of one operation has more digits than specified,
+it is rounded. The rounding mode taken is either the default mode, or the one
+supplied to the operation after the I<scale>:
 
-    $x -> from_oct("1.3267p-4");
-    $x = Math::BigFloat -> from_oct("1.3267p-4");
+    $x = Math::BigFloat->new(2);
+    Math::BigFloat->accuracy(5);              # 5 digits max
+    $y = $x->copy()->bdiv(3);                 # gives 0.66667
+    $y = $x->copy()->bdiv(3,6);               # gives 0.666667
+    $y = $x->copy()->bdiv(3,6,undef,'odd');   # gives 0.666667
+    Math::BigFloat->round_mode('zero');
+    $y = $x->copy()->bdiv(3,6);               # will also give 0.666667
 
-Interpret input as an octal string. A single underscore character ("_") may be
-placed between any two digits. If the input is invalid, a NaN is returned. The
-exponent is in base 2 using decimal digits.
+Note that C<< Math::BigFloat->accuracy() >> and C<< Math::BigFloat->precision() >>
+set the global variables, and thus B<any> newly created number will be subject
+to the global rounding B<immediately>. This means that in the examples above, the
+C<3> as argument to C<bdiv()> will also get an accuracy of B<5>.
 
-If called as an instance method, the value is assigned to the invocand.
+It is less confusing to either calculate the result fully, and afterwards
+round it explicitly, or use the additional parameters to the math
+functions like so:
+
+    use Math::BigFloat;
+    $x = Math::BigFloat->new(2);
+    $y = $x->copy()->bdiv(3);
+    print $y->bround(5),"\n";               # gives 0.66667
+
+    or
+
+    use Math::BigFloat;
+    $x = Math::BigFloat->new(2);
+    $y = $x->copy()->bdiv(3,5);             # gives 0.66667
+    print "$y\n";
+
+=head2 Rounding
+
+=over
+
+=item bfround ( +$scale )
+
+Rounds to the $scale'th place left from the '.', counting from the dot.
+The first digit is numbered 1.
+
+=item bfround ( -$scale )
+
+Rounds to the $scale'th place right from the '.', counting from the dot.
+
+=item bfround ( 0 )
+
+Rounds to an integer.
+
+=item bround  ( +$scale )
+
+Preserves accuracy to $scale digits from the left (aka significant digits) and
+pads the rest with zeros. If the number is between 1 and -1, the significant
+digits count from the first non-zero after the '.'
+
+=item bround  ( -$scale ) and bround ( 0 )
+
+These are effectively no-ops.
 
 =back
 
+All rounding functions take as a second parameter a rounding mode from one of
+the following: 'even', 'odd', '+inf', '-inf', 'zero', 'trunc' or 'common'.
+
+The default rounding mode is 'even'. By using
+C<< Math::BigFloat->round_mode($round_mode); >> you can get and set the default
+mode for subsequent rounding. The usage of C<$Math::BigFloat::$round_mode> is
+no longer supported.
+The second parameter to the round functions then overrides the default
+temporarily.
+
+The C<as_number()> function returns a BigInt from a Math::BigFloat. It uses
+'trunc' as rounding mode to make it equivalent to:
+
+    $x = 2.5;
+    $y = int($x) + 2;
+
+You can override this by passing the desired rounding mode as parameter to
+C<as_number()>:
+
+    $x = Math::BigFloat->new(2.5);
+    $y = $x->as_number('odd');      # $y = 3
+
 =head1 Autocreating constants
 
 After C<use Math::BigFloat ':constant'> all the floating point constants
@@ -4833,13 +5277,13 @@ happens at compile time.
 
 In particular
 
-  perl -MMath::BigFloat=:constant -e 'print 2E-100,"\n"'
+    perl -MMath::BigFloat=:constant -e 'print 2E-100,"\n"'
 
-prints the value of C<2E-100>. Note that without conversion of 
-constants the expression 2E-100 will be calculated as normal floating point 
+prints the value of C<2E-100>. Note that without conversion of
+constants the expression 2E-100 will be calculated as normal floating point
 number.
 
-Please note that ':constant' does not affect integer constants, nor binary 
+Please note that ':constant' does not affect integer constants, nor binary
 nor hexadecimal constants. Use L<bignum> or L<Math::BigInt> to get this to
 work.
 
@@ -4848,11 +5292,11 @@ work.
 Math with the numbers is done (by default) by a module called
 Math::BigInt::Calc. This is equivalent to saying:
 
-	use Math::BigFloat lib => 'Calc';
+    use Math::BigFloat lib => 'Calc';
 
 You can change this by using:
 
-	use Math::BigFloat lib => 'GMP';
+    use Math::BigFloat lib => 'GMP';
 
 B<Note>: General purpose packages should not be explicit about the library
 to use; let the script author decide which is best.
@@ -4860,18 +5304,18 @@ to use; let the script author decide which is best.
 Note: The keyword 'lib' will warn when the requested library could not be
 loaded. To suppress the warning use 'try' instead:
 
-	use Math::BigFloat try => 'GMP';
+    use Math::BigFloat try => 'GMP';
 
 If your script works with huge numbers and Calc is too slow for them,
 you can also for the loading of one of these libraries and if none
 of them can be used, the code will die:
 
-        use Math::BigFloat only => 'GMP,Pari';
+    use Math::BigFloat only => 'GMP,Pari';
 
 The following would first try to find Math::BigInt::Foo, then
 Math::BigInt::Bar, and when this also fails, revert to Math::BigInt::Calc:
 
-	use Math::BigFloat lib => 'Foo,Math::BigInt::Bar';
+    use Math::BigFloat lib => 'Foo,Math::BigInt::Bar';
 
 See the respective low-level library documentation for further details.
 
@@ -4879,16 +5323,16 @@ Please note that Math::BigFloat does B<not> use the denoted library itself,
 but it merely passes the lib argument to Math::BigInt. So, instead of the need
 to do:
 
-	use Math::BigInt lib => 'GMP';
-	use Math::BigFloat;
+    use Math::BigInt lib => 'GMP';
+    use Math::BigFloat;
 
 you can roll it all into one line:
 
-	use Math::BigFloat lib => 'GMP';
+    use Math::BigFloat lib => 'GMP';
 
 It is also possible to just require Math::BigFloat:
 
-	require Math::BigFloat;
+    require Math::BigFloat;
 
 This will load the necessary things (like BigInt) when they are needed, and
 automatically.
@@ -4901,7 +5345,7 @@ a different low-level library.
 For backwards compatibility reasons it is still possible to
 request a different storage class for use with Math::BigFloat:
 
-        use Math::BigFloat with => 'Math::BigInt::Lite';
+    use Math::BigFloat with => 'Math::BigInt::Lite';
 
 However, this request is ignored, as the current code now uses the low-level
 math library for directly storing the number parts.
@@ -4910,9 +5354,9 @@ math library for directly storing the number parts.
 
 C<Math::BigFloat> exports nothing by default, but can export the C<bpi()> method:
 
-	use Math::BigFloat qw/bpi/;
+    use Math::BigFloat qw/bpi/;
 
-	print bpi(10), "\n";
+    print bpi(10), "\n";
 
 =head1 CAVEATS
 
@@ -4920,14 +5364,14 @@ Do not try to be clever to insert some operations in between switching
 libraries:
 
     require Math::BigFloat;
-    my $matter = Math::BigFloat->bone() + 4;	# load BigInt and Calc
-    Math::BigFloat->import( lib => 'Pari' );	# load Pari, too
-    my $anti_matter = Math::BigFloat->bone()+4;	# now use Pari
+    my $matter = Math::BigFloat->bone() + 4;    # load BigInt and Calc
+    Math::BigFloat->import( lib => 'Pari' );    # load Pari, too
+    my $anti_matter = Math::BigFloat->bone()+4; # now use Pari
 
 This will create objects with numbers stored in two different backend libraries,
 and B<VERY BAD THINGS> will happen when you use these together:
 
-	my $flash_and_bang = $matter + $anti_matter;	# Don't do this!
+    my $flash_and_bang = $matter + $anti_matter;    # Don't do this!
 
 =over
 
@@ -4937,35 +5381,20 @@ Both stringify and bstr() now drop the leading '+'. The old code would return
 '+1.23', the new returns '1.23'. See the documentation in L<Math::BigInt> for
 reasoning and details.
 
-=item bdiv()
-
-The following will probably not print what you expect:
-
-	print $c->bdiv(123.456),"\n";
-
-It prints both quotient and remainder since print works in list context. Also,
-bdiv() will modify $c, so be careful. You probably want to use
-
-    print $c / 123.456,"\n";
-    # or if you want to modify $c:
-    print scalar $c->bdiv(123.456),"\n";
-
-instead.
-
 =item brsft()
 
 The following will probably not print what you expect:
 
-	my $c = Math::BigFloat->new('3.14159');
-        print $c->brsft(3,10),"\n";	# prints 0.00314153.1415
+    my $c = Math::BigFloat->new('3.14159');
+    print $c->brsft(3,10),"\n";     # prints 0.00314153.1415
 
 It prints both quotient and remainder, since print calls C<brsft()> in list
 context. Also, C<< $c->brsft() >> will modify $c, so be careful.
 You probably want to use
 
-	print scalar $c->copy()->brsft(3,10),"\n";
-	# or if you really want to modify $c
-        print scalar $c->brsft(3,10),"\n";
+    print scalar $c->copy()->brsft(3,10),"\n";
+    # or if you really want to modify $c
+    print scalar $c->brsft(3,10),"\n";
 
 instead.
 
@@ -4973,24 +5402,14 @@ instead.
 
 Beware of:
 
-	$x = Math::BigFloat->new(5);
-	$y = $x;
+    $x = Math::BigFloat->new(5);
+    $y = $x;
 
 It will not do what you think, e.g. making a copy of $x. Instead it just makes
 a second reference to the B<same> object and stores it in $y. Thus anything
 that modifies $x will modify $y (except overloaded math operators), and vice
 versa. See L<Math::BigInt> for details and how to avoid that.
 
-=item bpow()
-
-C<bpow()> now modifies the first argument, unlike the old code which left
-it alone and only returned the result. This is to be consistent with
-C<badd()> etc. The first will modify $x, the second one won't:
-
-	print bpow($x,$i),"\n"; 	# modify $x
-	print $x->bpow($i),"\n"; 	# ditto
-	print $x ** $i,"\n";		# leave $x alone 
-
 =item precision() vs. accuracy()
 
 A common pitfall is to use L</precision()> when you want to round a result to
@@ -4998,39 +5417,39 @@ a certain number of digits:
 
     use Math::BigFloat;
 
-    Math::BigFloat->precision(4);	    # does not do what you
-					    # think it does
-    my $x = Math::BigFloat->new(12345);	    # rounds $x to "12000"!
-    print "$x\n";			    # print "12000"
-    my $y = Math::BigFloat->new(3);	    # rounds $y to "0"!
-    print "$y\n";			    # print "0"
-    $z = $x / $y;			    # 12000 / 0 => NaN!
+    Math::BigFloat->precision(4);           # does not do what you
+                                            # think it does
+    my $x = Math::BigFloat->new(12345);     # rounds $x to "12000"!
+    print "$x\n";                           # print "12000"
+    my $y = Math::BigFloat->new(3);         # rounds $y to "0"!
+    print "$y\n";                           # print "0"
+    $z = $x / $y;                           # 12000 / 0 => NaN!
     print "$z\n";
-    print $z->precision(),"\n";		    # 4
+    print $z->precision(),"\n";             # 4
 
 Replacing L</precision()> with L</accuracy()> is probably not what you want, either:
 
     use Math::BigFloat;
 
-    Math::BigFloat->accuracy(4);	  # enables global rounding:
+    Math::BigFloat->accuracy(4);          # enables global rounding:
     my $x = Math::BigFloat->new(123456);  # rounded immediately
                                           #   to "12350"
-    print "$x\n";			  # print "123500"
-    my $y = Math::BigFloat->new(3);	  # rounded to "3
-    print "$y\n";			  # print "3"
+    print "$x\n";                         # print "123500"
+    my $y = Math::BigFloat->new(3);       # rounded to "3
+    print "$y\n";                         # print "3"
     print $z = $x->copy()->bdiv($y),"\n"; # 41170
-    print $z->accuracy(),"\n";		  # 4
+    print $z->accuracy(),"\n";            # 4
 
 What you want to use instead is:
 
     use Math::BigFloat;
 
     my $x = Math::BigFloat->new(123456);    # no rounding
-    print "$x\n";			    # print "123456"
-    my $y = Math::BigFloat->new(3);	    # no rounding
-    print "$y\n";			    # print "3"
+    print "$x\n";                           # print "123456"
+    my $y = Math::BigFloat->new(3);         # no rounding
+    print "$y\n";                           # print "3"
     print $z = $x->copy()->bdiv($y,4),"\n"; # 41150
-    print $z->accuracy(),"\n";		    # undef
+    print $z->accuracy(),"\n";              # undef
 
 In addition to computing what you expected, the last example also does B<not>
 "taint" the result with an accuracy or precision setting, which would
@@ -5124,11 +5543,11 @@ Completely rewritten by Tels L<http://bloodgate.com> in 2001-2008.
 
 =item *
 
-Florian Ragwitz L<flora@cpan.org>, 2010.
+Florian Ragwitz E<lt>flora@cpan.orgE<gt>, 2010.
 
 =item *
 
-Peter John Acklam, L<pjacklam@online.no>, 2011-.
+Peter John Acklam E<lt>pjacklam@online.noE<gt>, 2011-.
 
 =back
 
diff --git a/cpan/Math-BigInt/lib/Math/BigInt.pm b/cpan/Math-BigInt/lib/Math/BigInt.pm
index a50b37e832..72fb3d7cb6 100644
--- a/cpan/Math-BigInt/lib/Math/BigInt.pm
+++ b/cpan/Math-BigInt/lib/Math/BigInt.pm
@@ -7,10 +7,9 @@ package Math::BigInt;
 
 # The following hash values are used:
 #   value: unsigned int with actual value (as a Math::BigInt::Calc or similar)
-#   sign : +,-,NaN,+inf,-inf
+#   sign : +, -, NaN, +inf, -inf
 #   _a   : accuracy
 #   _p   : precision
-#   _f   : flags, used by MBF to flag parts of a float as untouchable
 
 # Remember not to take shortcuts ala $xs = $x->{value}; $CALC->foo($xs); since
 # underlying lib might change the reference!
@@ -19,17 +18,14 @@ use 5.006001;
 use strict;
 use warnings;
 
-our $VERSION = '1.999715';
+use Carp ();
+
+our $VERSION = '1.999724';
 $VERSION = eval $VERSION;
 
 our @ISA = qw(Exporter);
 our @EXPORT_OK = qw(objectify bgcd blcm);
 
-# _trap_inf and _trap_nan are internal and should never be accessed from the
-# outside
-our ($round_mode, $accuracy, $precision, $div_scale, $rnd_mode,
-     $upgrade, $downgrade, $_trap_nan, $_trap_inf);
-
 my $class = "Math::BigInt";
 
 # Inside overload, the first arg is always an object. If the original code had
@@ -43,120 +39,176 @@ my $class = "Math::BigInt";
 # Thus inheritance of overload operators becomes possible and transparent for
 # our subclasses without the need to repeat the entire overload section there.
 
-# We register ops that are not registerable yet, so suppress warnings
-{ no warnings;
 use overload
-'='     =>      sub { $_[0]->copy(); },
-
-# some shortcuts for speed (assumes that reversed order of arguments is routed
-# to normal '+' and we thus can always modify first arg. If this is changed,
-# this breaks and must be adjusted.)
-'+='    =>      sub { $_[0]->badd($_[1]); },
-'-='    =>      sub { $_[0]->bsub($_[1]); },
-'*='    =>      sub { $_[0]->bmul($_[1]); },
-'/='    =>      sub { scalar $_[0]->bdiv($_[1]); },
-'%='    =>      sub { $_[0]->bmod($_[1]); },
-'^='    =>      sub { $_[0]->bxor($_[1]); },
-'&='    =>      sub { $_[0]->band($_[1]); },
-'|='    =>      sub { $_[0]->bior($_[1]); },
-
-'**='   =>      sub { $_[0]->bpow($_[1]); },
-'<<='   =>      sub { $_[0]->blsft($_[1]); },
-'>>='   =>      sub { $_[0]->brsft($_[1]); },
-
-# not supported by Perl yet
-'..'    =>      \&_pointpoint,
-
-'<=>'   =>      sub { my $rc = $_[2] ?
-                      ref($_[0])->bcmp($_[1],$_[0]) :
-                      $_[0]->bcmp($_[1]);
-                      $rc = 1 unless defined $rc;
-                      $rc <=> 0;
-                },
-# we need '>=' to get things like "1 >= NaN" right:
-'>='    =>      sub { my $rc = $_[2] ?
-                      ref($_[0])->bcmp($_[1],$_[0]) :
-                      $_[0]->bcmp($_[1]);
-                      # if there was a NaN involved, return false
-                      return '' unless defined $rc;
-                      $rc >= 0;
-                },
-'cmp'   =>      sub {
-         $_[2] ?
-               "$_[1]" cmp $_[0]->bstr() :
-               $_[0]->bstr() cmp "$_[1]" },
-
-'cos'   =>      sub { $_[0]->copy->bcos(); },
-'sin'   =>      sub { $_[0]->copy->bsin(); },
-'atan2' =>      sub { $_[2] ?
-                        ref($_[0])->new($_[1])->batan2($_[0]) :
-                        $_[0]->copy()->batan2($_[1]) },
-
-# are not yet overloadable
-#'hex'  =>      sub { print "hex"; $_[0]; },
-#'oct'  =>      sub { print "oct"; $_[0]; },
-
-# log(N) is log(N, e), where e is Euler's number
-'log'   =>      sub { $_[0]->copy()->blog(); },
-'exp'   =>      sub { $_[0]->copy()->bexp($_[1]); },
-'int'   =>      sub { $_[0]->copy(); },
-'neg'   =>      sub { $_[0]->copy()->bneg(); },
-'abs'   =>      sub { $_[0]->copy()->babs(); },
-'sqrt'  =>      sub { $_[0]->copy()->bsqrt(); },
-'~'     =>      sub { $_[0]->copy()->bnot(); },
-
-# for subtract it's a bit tricky to not modify b: b-a => -a+b
-'-'     =>      sub { my $c = $_[0]->copy; $_[2] ?
-                        $c->bneg()->badd( $_[1]) :
-                        $c->bsub( $_[1]) },
-'+'     =>      sub { $_[0]->copy()->badd($_[1]); },
-'*'     =>      sub { $_[0]->copy()->bmul($_[1]); },
-
-'/'     =>      sub {
-   $_[2] ? ref($_[0])->new($_[1])->bdiv($_[0]) : $_[0]->copy->bdiv($_[1]);
-  },
-'%'     =>      sub {
-   $_[2] ? ref($_[0])->new($_[1])->bmod($_[0]) : $_[0]->copy->bmod($_[1]);
-  },
-'**'    =>      sub {
-   $_[2] ? ref($_[0])->new($_[1])->bpow($_[0]) : $_[0]->copy->bpow($_[1]);
-  },
-'<<'    =>      sub {
-   $_[2] ? ref($_[0])->new($_[1])->blsft($_[0]) : $_[0]->copy->blsft($_[1]);
-  },
-'>>'    =>      sub {
-   $_[2] ? ref($_[0])->new($_[1])->brsft($_[0]) : $_[0]->copy->brsft($_[1]);
-  },
-'&'     =>      sub {
-   $_[2] ? ref($_[0])->new($_[1])->band($_[0]) : $_[0]->copy->band($_[1]);
-  },
-'|'     =>      sub {
-   $_[2] ? ref($_[0])->new($_[1])->bior($_[0]) : $_[0]->copy->bior($_[1]);
-  },
-'^'     =>      sub {
-   $_[2] ? ref($_[0])->new($_[1])->bxor($_[0]) : $_[0]->copy->bxor($_[1]);
-  },
-
-# can modify arg of ++ and --, so avoid a copy() for speed, but don't
-# use $_[0]->bone(), it would modify $_[0] to be 1!
-'++'    =>      sub { $_[0]->binc() },
-'--'    =>      sub { $_[0]->bdec() },
-
-# if overloaded, O(1) instead of O(N) and twice as fast for small numbers
-'bool'  =>      sub {
-  # this kludge is needed for perl prior 5.6.0 since returning 0 here fails :-/
-  # v5.6.1 dumps on this: return !$_[0]->is_zero() || undef;                :-(
-  my $t = undef;
-  $t = 1 if !$_[0]->is_zero();
-  $t;
-  },
-
-# the original qw() does not work with the TIESCALAR below, why?
-# Order of arguments insignificant
-'""' => sub { $_[0]->bstr(); },
-'0+' => sub { $_[0]->numify(); }
-;
-} # no warnings scope
+
+  # overload key: with_assign
+
+  '+'     =>      sub { $_[0] -> copy() -> badd($_[1]); },
+
+  '-'     =>      sub { my $c = $_[0] -> copy;
+                        $_[2] ? $c -> bneg() -> badd($_[1])
+                              : $c -> bsub($_[1]); },
+
+  '*'     =>      sub { $_[0] -> copy() -> bmul($_[1]); },
+
+  '/'     =>      sub { $_[2] ? ref($_[0]) -> new($_[1]) -> bdiv($_[0])
+                              : $_[0] -> copy -> bdiv($_[1]); },
+
+
+  '%'     =>      sub { $_[2] ? ref($_[0]) -> new($_[1]) -> bmod($_[0])
+                              : $_[0] -> copy -> bmod($_[1]); },
+
+  '**'    =>      sub { $_[2] ? ref($_[0]) -> new($_[1]) -> bpow($_[0])
+                              : $_[0] -> copy -> bpow($_[1]); },
+
+  '<<'    =>      sub { $_[2] ? ref($_[0]) -> new($_[1]) -> blsft($_[0])
+                              : $_[0] -> copy -> blsft($_[1]); },
+
+  '>>'    =>      sub { $_[2] ? ref($_[0]) -> new($_[1]) -> brsft($_[0])
+                              : $_[0] -> copy -> brsft($_[1]); },
+
+  # overload key: assign
+
+  '+='    =>      sub { $_[0]->badd($_[1]); },
+
+  '-='    =>      sub { $_[0]->bsub($_[1]); },
+
+  '*='    =>      sub { $_[0]->bmul($_[1]); },
+
+  '/='    =>      sub { scalar $_[0]->bdiv($_[1]); },
+
+  '%='    =>      sub { $_[0]->bmod($_[1]); },
+
+  '**='   =>      sub { $_[0]->bpow($_[1]); },
+
+
+  '<<='   =>      sub { $_[0]->blsft($_[1]); },
+
+  '>>='   =>      sub { $_[0]->brsft($_[1]); },
+
+#  'x='    =>      sub { },
+
+#  '.='    =>      sub { },
+
+  # overload key: num_comparison
+
+  '<'     =>      sub { $_[2] ? ref($_[0]) -> new($_[1]) -> blt($_[0])
+                              : $_[0] -> blt($_[1]); },
+
+  '<='    =>      sub { $_[2] ? ref($_[0]) -> new($_[1]) -> ble($_[0])
+                              : $_[0] -> ble($_[1]); },
+
+  '>'     =>      sub { $_[2] ? ref($_[0]) -> new($_[1]) -> bgt($_[0])
+                              : $_[0] -> bgt($_[1]); },
+
+  '>='    =>      sub { $_[2] ? ref($_[0]) -> new($_[1]) -> bge($_[0])
+                              : $_[0] -> bge($_[1]); },
+
+  '=='    =>      sub { $_[0] -> beq($_[1]); },
+
+  '!='    =>      sub { $_[0] -> bne($_[1]); },
+
+  # overload key: 3way_comparison
+
+  '<=>'   =>      sub { my $cmp = $_[0] -> bcmp($_[1]);
+                        defined($cmp) && $_[2] ? -$cmp : $cmp; },
+
+  'cmp'   =>      sub { $_[2] ? "$_[1]" cmp $_[0] -> bstr()
+                              : $_[0] -> bstr() cmp "$_[1]"; },
+
+  # overload key: str_comparison
+
+#  'lt'     =>      sub { $_[2] ? ref($_[0]) -> new($_[1]) -> bstrlt($_[0])
+#                              : $_[0] -> bstrlt($_[1]); },
+#
+#  'le'    =>      sub { $_[2] ? ref($_[0]) -> new($_[1]) -> bstrle($_[0])
+#                              : $_[0] -> bstrle($_[1]); },
+#
+#  'gt'     =>      sub { $_[2] ? ref($_[0]) -> new($_[1]) -> bstrgt($_[0])
+#                              : $_[0] -> bstrgt($_[1]); },
+#
+#  'ge'    =>      sub { $_[2] ? ref($_[0]) -> new($_[1]) -> bstrge($_[0])
+#                              : $_[0] -> bstrge($_[1]); },
+#
+#  'eq'    =>      sub { $_[0] -> bstreq($_[1]); },
+#
+#  'ne'    =>      sub { $_[0] -> bstrne($_[1]); },
+
+  # overload key: binary
+
+  '&'     =>      sub { $_[2] ? ref($_[0]) -> new($_[1]) -> band($_[0])
+                              : $_[0] -> copy -> band($_[1]); },
+
+  '&='    =>      sub { $_[0] -> band($_[1]); },
+
+  '|'     =>      sub { $_[2] ? ref($_[0]) -> new($_[1]) -> bior($_[0])
+                              : $_[0] -> copy -> bior($_[1]); },
+
+  '|='    =>      sub { $_[0] -> bior($_[1]); },
+
+  '^'     =>      sub { $_[2] ? ref($_[0]) -> new($_[1]) -> bxor($_[0])
+                              : $_[0] -> copy -> bxor($_[1]); },
+
+  '^='    =>      sub { $_[0] -> bxor($_[1]); },
+
+#  '&.'    =>      sub { },
+
+#  '&.='   =>      sub { },
+
+#  '|.'    =>      sub { },
+
+#  '|.='   =>      sub { },
+
+#  '^.'    =>      sub { },
+
+#  '^.='   =>      sub { },
+
+  # overload key: unary
+
+  'neg'   =>      sub { $_[0] -> copy() -> bneg(); },
+
+#  '!'     =>      sub { },
+
+  '~'     =>      sub { $_[0] -> copy() -> bnot(); },
+
+#  '~.'    =>      sub { },
+
+  # overload key: mutators
+
+  '++'    =>      sub { $_[0] -> binc() },
+
+  '--'    =>      sub { $_[0] -> bdec() },
+
+  # overload key: func
+
+  'atan2' =>      sub { $_[2] ? ref($_[0]) -> new($_[1]) -> batan2($_[0])
+                              : $_[0] -> copy() -> batan2($_[1]); },
+
+  'cos'   =>      sub { $_[0] -> copy -> bcos(); },
+
+  'sin'   =>      sub { $_[0] -> copy -> bsin(); },
+
+  'exp'   =>      sub { $_[0] -> copy() -> bexp($_[1]); },
+
+  'abs'   =>      sub { $_[0] -> copy() -> babs(); },
+
+  'log'   =>      sub { $_[0] -> copy() -> blog(); },
+
+  'sqrt'  =>      sub { $_[0] -> copy() -> bsqrt(); },
+
+  'int'   =>      sub { $_[0] -> copy() -> bint(); },
+
+  # overload key: conversion
+
+  'bool'  =>      sub { $_[0] -> is_zero() ? '' : 1; },
+
+  '""'    =>      sub { $_[0] -> bstr(); },
+
+  '0+'    =>      sub { $_[0] -> numify(); },
+
+  '='     =>      sub { $_[0]->copy(); },
+
+  ;
 
 ##############################################################################
 # global constants, flags and accessory
@@ -164,18 +216,18 @@ use overload
 # These vars are public, but their direct usage is not recommended, use the
 # accessor methods instead
 
-$round_mode = 'even'; # one of 'even', 'odd', '+inf', '-inf', 'zero', 'trunc' or 'common'
-$accuracy   = undef;
-$precision  = undef;
-$div_scale  = 40;
-
-$upgrade = undef;                       # default is no upgrade
-$downgrade = undef;                     # default is no downgrade
+our $round_mode = 'even'; # one of 'even', 'odd', '+inf', '-inf', 'zero', 'trunc' or 'common'
+our $accuracy   = undef;
+our $precision  = undef;
+our $div_scale  = 40;
+our $upgrade    = undef;                    # default is no upgrade
+our $downgrade  = undef;                    # default is no downgrade
 
 # These are internally, and not to be used from the outside at all
 
-$_trap_nan = 0;                         # are NaNs ok? set w/ config()
-$_trap_inf = 0;                         # are infs ok? set w/ config()
+our $_trap_nan = 0;                         # are NaNs ok? set w/ config()
+our $_trap_inf = 0;                         # are infs ok? set w/ config()
+
 my $nan = 'NaN';                        # constants for easier life
 
 my $CALC = 'Math::BigInt::Calc';        # module to do the low level math
@@ -190,328 +242,287 @@ my $EMU_LIB = 'Math/BigInt/CalcEmu.pm'; # emulate low-level math
 ##############################################################################
 # the old code had $rnd_mode, so we need to support it, too
 
-$rnd_mode   = 'even';
-sub TIESCALAR  { my ($class) = @_; bless \$round_mode, $class; }
-sub FETCH      { return $round_mode; }
-sub STORE      { $rnd_mode = $_[0]->round_mode($_[1]); }
+our $rnd_mode   = 'even';
 
-BEGIN
-  {
-  # tie to enable $rnd_mode to work transparently
-  tie $rnd_mode, 'Math::BigInt';
+sub TIESCALAR {
+    my ($class) = @_;
+    bless \$round_mode, $class;
+}
 
-  # set up some handy alias names
-  *as_int = \&as_number;
-  *is_pos = \&is_positive;
-  *is_neg = \&is_negative;
-  }
+sub FETCH {
+    return $round_mode;
+}
 
-##############################################################################
+sub STORE {
+    $rnd_mode = $_[0]->round_mode($_[1]);
+}
 
-sub round_mode
-  {
-  no strict 'refs';
-  # make Class->round_mode() work
-  my $self = shift;
-  my $class = ref($self) || $self || __PACKAGE__;
-  if (defined $_[0])
-    {
-    my $m = shift;
-    if ($m !~ /^(even|odd|\+inf|\-inf|zero|trunc|common)$/)
-      {
-      require Carp; Carp::croak ("Unknown round mode '$m'");
-      }
-    return ${"${class}::round_mode"} = $m;
-    }
-  ${"${class}::round_mode"};
-  }
-
-sub upgrade
-  {
-  no strict 'refs';
-  # make Class->upgrade() work
-  my $self = shift;
-  my $class = ref($self) || $self || __PACKAGE__;
-  # need to set new value?
-  if (@_ > 0)
-    {
-    return ${"${class}::upgrade"} = $_[0];
-    }
-  ${"${class}::upgrade"};
-  }
-
-sub downgrade
-  {
-  no strict 'refs';
-  # make Class->downgrade() work
-  my $self = shift;
-  my $class = ref($self) || $self || __PACKAGE__;
-  # need to set new value?
-  if (@_ > 0)
-    {
-    return ${"${class}::downgrade"} = $_[0];
-    }
-  ${"${class}::downgrade"};
-  }
-
-sub div_scale
-  {
-  no strict 'refs';
-  # make Class->div_scale() work
-  my $self = shift;
-  my $class = ref($self) || $self || __PACKAGE__;
-  if (defined $_[0])
-    {
-    if ($_[0] < 0)
-      {
-      require Carp; Carp::croak ('div_scale must be greater than zero');
-      }
-    ${"${class}::div_scale"} = $_[0];
-    }
-  ${"${class}::div_scale"};
-  }
-
-sub accuracy
-  {
-  # $x->accuracy($a);           ref($x) $a
-  # $x->accuracy();             ref($x)
-  # Class->accuracy();          class
-  # Class->accuracy($a);        class $a
-
-  my $x = shift;
-  my $class = ref($x) || $x || __PACKAGE__;
-
-  no strict 'refs';
-  # need to set new value?
-  if (@_ > 0)
-    {
-    my $a = shift;
-    # convert objects to scalars to avoid deep recursion. If object doesn't
-    # have numify(), then hopefully it will have overloading for int() and
-    # boolean test without wandering into a deep recursion path...
-    $a = $a->numify() if ref($a) && $a->can('numify');
-
-    if (defined $a)
-      {
-      # also croak on non-numerical
-      if (!$a || $a <= 0)
-        {
-        require Carp;
-        Carp::croak ('Argument to accuracy must be greater than zero');
-        }
-      if (int($a) != $a)
-        {
-        require Carp;
-        Carp::croak ('Argument to accuracy must be an integer');
-        }
-      }
-    if (ref($x))
-      {
-      # $object->accuracy() or fallback to global
-      $x->bround($a) if $a;             # not for undef, 0
-      $x->{_a} = $a;                    # set/overwrite, even if not rounded
-      delete $x->{_p};                  # clear P
-      $a = ${"${class}::accuracy"} unless defined $a;   # proper return value
-      }
-    else
-      {
-      ${"${class}::accuracy"} = $a;     # set global A
-      ${"${class}::precision"} = undef; # clear global P
-      }
-    return $a;                          # shortcut
-    }
-
-  my $a;
-  # $object->accuracy() or fallback to global
-  $a = $x->{_a} if ref($x);
-  # but don't return global undef, when $x's accuracy is 0!
-  $a = ${"${class}::accuracy"} if !defined $a;
-  $a;
-  }
-
-sub precision
-  {
-  # $x->precision($p);          ref($x) $p
-  # $x->precision();            ref($x)
-  # Class->precision();         class
-  # Class->precision($p);       class $p
-
-  my $x = shift;
-  my $class = ref($x) || $x || __PACKAGE__;
-
-  no strict 'refs';
-  if (@_ > 0)
-    {
-    my $p = shift;
-    # convert objects to scalars to avoid deep recursion. If object doesn't
-    # have numify(), then hopefully it will have overloading for int() and
-    # boolean test without wandering into a deep recursion path...
-    $p = $p->numify() if ref($p) && $p->can('numify');
-    if ((defined $p) && (int($p) != $p))
-      {
-      require Carp; Carp::croak ('Argument to precision must be an integer');
-      }
-    if (ref($x))
-      {
-      # $object->precision() or fallback to global
-      $x->bfround($p) if $p;            # not for undef, 0
-      $x->{_p} = $p;                    # set/overwrite, even if not rounded
-      delete $x->{_a};                  # clear A
-      $p = ${"${class}::precision"} unless defined $p;  # proper return value
-      }
-    else
-      {
-      ${"${class}::precision"} = $p;    # set global P
-      ${"${class}::accuracy"} = undef;  # clear global A
-      }
-    return $p;                          # shortcut
-    }
-
-  my $p;
-  # $object->precision() or fallback to global
-  $p = $x->{_p} if ref($x);
-  # but don't return global undef, when $x's precision is 0!
-  $p = ${"${class}::precision"} if !defined $p;
-  $p;
-  }
-
-sub config
-  {
-  # return (or set) configuration data as hash ref
-  my $class = shift || 'Math::BigInt';
-
-  no strict 'refs';
-  if (@_ > 1 || (@_ == 1 && (ref($_[0]) eq 'HASH')))
-    {
-    # try to set given options as arguments from hash
-
-    my $args = $_[0];
-    if (ref($args) ne 'HASH')
-      {
-      $args = { @_ };
-      }
-    # these values can be "set"
-    my $set_args = {};
-    foreach my $key (
-     qw/trap_inf trap_nan
-        upgrade downgrade precision accuracy round_mode div_scale/
-     )
-      {
-      $set_args->{$key} = $args->{$key} if exists $args->{$key};
-      delete $args->{$key};
-      }
-    if (keys %$args > 0)
-      {
-      require Carp;
-      Carp::croak ("Illegal key(s) '",
-       join("','",keys %$args),"' passed to $class\->config()");
-      }
-    foreach my $key (keys %$set_args)
-      {
-      if ($key =~ /^trap_(inf|nan)\z/)
-        {
-        ${"${class}::_trap_$1"} = ($set_args->{"trap_$1"} ? 1 : 0);
-        next;
+BEGIN {
+    # tie to enable $rnd_mode to work transparently
+    tie $rnd_mode, 'Math::BigInt';
+
+    # set up some handy alias names
+    *as_int = \&as_number;
+    *is_pos = \&is_positive;
+    *is_neg = \&is_negative;
+}
+
+###############################################################################
+# Configuration methods
+###############################################################################
+
+sub round_mode {
+    no strict 'refs';
+    # make Class->round_mode() work
+    my $self = shift;
+    my $class = ref($self) || $self || __PACKAGE__;
+    if (defined $_[0]) {
+        my $m = shift;
+        if ($m !~ /^(even|odd|\+inf|\-inf|zero|trunc|common)$/) {
+            Carp::croak("Unknown round mode '$m'");
         }
-      # use a call instead of just setting the $variable to check argument
-      $class->$key($set_args->{$key});
-      }
-    }
-
-  # now return actual configuration
-
-  my $cfg = {
-    lib => $CALC,
-    lib_version => ${"${CALC}::VERSION"},
-    class => $class,
-    trap_nan => ${"${class}::_trap_nan"},
-    trap_inf => ${"${class}::_trap_inf"},
-    version => ${"${class}::VERSION"},
-    };
-  foreach my $key (qw/
-     upgrade downgrade precision accuracy round_mode div_scale
-     /)
-    {
-    $cfg->{$key} = ${"${class}::$key"};
-    };
-  if (@_ == 1 && (ref($_[0]) ne 'HASH'))
-    {
-    # calls of the style config('lib') return just this value
-    return $cfg->{$_[0]};
+        return ${"${class}::round_mode"} = $m;
+    }
+    ${"${class}::round_mode"};
+}
+
+sub upgrade {
+    no strict 'refs';
+    # make Class->upgrade() work
+    my $self = shift;
+    my $class = ref($self) || $self || __PACKAGE__;
+    # need to set new value?
+    if (@_ > 0) {
+        return ${"${class}::upgrade"} = $_[0];
     }
-  $cfg;
-  }
+    ${"${class}::upgrade"};
+}
 
-sub _scale_a
-  {
-  # select accuracy parameter based on precedence,
-  # used by bround() and bfround(), may return undef for scale (means no op)
-  my ($x,$scale,$mode) = @_;
+sub downgrade {
+    no strict 'refs';
+    # make Class->downgrade() work
+    my $self = shift;
+    my $class = ref($self) || $self || __PACKAGE__;
+    # need to set new value?
+    if (@_ > 0) {
+        return ${"${class}::downgrade"} = $_[0];
+    }
+    ${"${class}::downgrade"};
+}
 
-  $scale = $x->{_a} unless defined $scale;
+sub div_scale {
+    no strict 'refs';
+    # make Class->div_scale() work
+    my $self = shift;
+    my $class = ref($self) || $self || __PACKAGE__;
+    if (defined $_[0]) {
+        if ($_[0] < 0) {
+            Carp::croak('div_scale must be greater than zero');
+        }
+        ${"${class}::div_scale"} = $_[0];
+    }
+    ${"${class}::div_scale"};
+}
 
-  no strict 'refs';
-  my $class = ref($x);
+sub accuracy {
+    # $x->accuracy($a);           ref($x) $a
+    # $x->accuracy();             ref($x)
+    # Class->accuracy();          class
+    # Class->accuracy($a);        class $a
 
-  $scale = ${ $class . '::accuracy' } unless defined $scale;
-  $mode = ${ $class . '::round_mode' } unless defined $mode;
+    my $x = shift;
+    my $class = ref($x) || $x || __PACKAGE__;
 
-  if (defined $scale)
-    {
-    $scale = $scale->can('numify') ? $scale->numify()
-                                   : "$scale" if ref($scale);
-    $scale = int($scale);
+    no strict 'refs';
+    # need to set new value?
+    if (@_ > 0) {
+        my $a = shift;
+        # convert objects to scalars to avoid deep recursion. If object doesn't
+        # have numify(), then hopefully it will have overloading for int() and
+        # boolean test without wandering into a deep recursion path...
+        $a = $a->numify() if ref($a) && $a->can('numify');
+
+        if (defined $a) {
+            # also croak on non-numerical
+            if (!$a || $a <= 0) {
+                Carp::croak('Argument to accuracy must be greater than zero');
+            }
+            if (int($a) != $a) {
+                Carp::croak('Argument to accuracy must be an integer');
+            }
+        }
+        if (ref($x)) {
+            # $object->accuracy() or fallback to global
+            $x->bround($a) if $a; # not for undef, 0
+            $x->{_a} = $a;        # set/overwrite, even if not rounded
+            delete $x->{_p};      # clear P
+            $a = ${"${class}::accuracy"} unless defined $a; # proper return value
+        } else {
+            ${"${class}::accuracy"} = $a; # set global A
+            ${"${class}::precision"} = undef; # clear global P
+        }
+        return $a;              # shortcut
     }
 
-  ($scale,$mode);
-  }
+    my $a;
+    # $object->accuracy() or fallback to global
+    $a = $x->{_a} if ref($x);
+    # but don't return global undef, when $x's accuracy is 0!
+    $a = ${"${class}::accuracy"} if !defined $a;
+    $a;
+}
+
+sub precision {
+    # $x->precision($p);          ref($x) $p
+    # $x->precision();            ref($x)
+    # Class->precision();         class
+    # Class->precision($p);       class $p
+
+    my $x = shift;
+    my $class = ref($x) || $x || __PACKAGE__;
+
+    no strict 'refs';
+    if (@_ > 0) {
+        my $p = shift;
+        # convert objects to scalars to avoid deep recursion. If object doesn't
+        # have numify(), then hopefully it will have overloading for int() and
+        # boolean test without wandering into a deep recursion path...
+        $p = $p->numify() if ref($p) && $p->can('numify');
+        if ((defined $p) && (int($p) != $p)) {
+            Carp::croak('Argument to precision must be an integer');
+        }
+        if (ref($x)) {
+            # $object->precision() or fallback to global
+            $x->bfround($p) if $p; # not for undef, 0
+            $x->{_p} = $p;         # set/overwrite, even if not rounded
+            delete $x->{_a};       # clear A
+            $p = ${"${class}::precision"} unless defined $p; # proper return value
+        } else {
+            ${"${class}::precision"} = $p; # set global P
+            ${"${class}::accuracy"} = undef; # clear global A
+        }
+        return $p;              # shortcut
+    }
 
-sub _scale_p
-  {
-  # select precision parameter based on precedence,
-  # used by bround() and bfround(), may return undef for scale (means no op)
-  my ($x,$scale,$mode) = @_;
+    my $p;
+    # $object->precision() or fallback to global
+    $p = $x->{_p} if ref($x);
+    # but don't return global undef, when $x's precision is 0!
+    $p = ${"${class}::precision"} if !defined $p;
+    $p;
+}
 
-  $scale = $x->{_p} unless defined $scale;
+sub config {
+    # return (or set) configuration data as hash ref
+    my $class = shift || 'Math::BigInt';
 
-  no strict 'refs';
-  my $class = ref($x);
+    no strict 'refs';
+    if (@_ > 1 || (@_ == 1 && (ref($_[0]) eq 'HASH'))) {
+        # try to set given options as arguments from hash
 
-  $scale = ${ $class . '::precision' } unless defined $scale;
-  $mode = ${ $class . '::round_mode' } unless defined $mode;
+        my $args = $_[0];
+        if (ref($args) ne 'HASH') {
+            $args = { @_ };
+        }
+        # these values can be "set"
+        my $set_args = {};
+        foreach my $key (qw/
+                               accuracy precision
+                               round_mode div_scale
+                               upgrade downgrade
+                               trap_inf trap_nan
+                           /)
+        {
+            $set_args->{$key} = $args->{$key} if exists $args->{$key};
+            delete $args->{$key};
+        }
+        if (keys %$args > 0) {
+            Carp::croak("Illegal key(s) '", join("', '", keys %$args),
+                        "' passed to $class\->config()");
+        }
+        foreach my $key (keys %$set_args) {
+            if ($key =~ /^trap_(inf|nan)\z/) {
+                ${"${class}::_trap_$1"} = ($set_args->{"trap_$1"} ? 1 : 0);
+                next;
+            }
+            # use a call instead of just setting the $variable to check argument
+            $class->$key($set_args->{$key});
+        }
+    }
 
-  if (defined $scale)
+    # now return actual configuration
+
+    my $cfg = {
+               lib         => $CALC,
+               lib_version => ${"${CALC}::VERSION"},
+               class       => $class,
+               trap_nan    => ${"${class}::_trap_nan"},
+               trap_inf    => ${"${class}::_trap_inf"},
+               version     => ${"${class}::VERSION"},
+              };
+    foreach my $key (qw/
+                           accuracy precision
+                           round_mode div_scale
+                           upgrade downgrade
+                       /)
     {
-    $scale = $scale->can('numify') ? $scale->numify()
-                                   : "$scale" if ref($scale);
-    $scale = int($scale);
+        $cfg->{$key} = ${"${class}::$key"};
     }
+    if (@_ == 1 && (ref($_[0]) ne 'HASH')) {
+        # calls of the style config('lib') return just this value
+        return $cfg->{$_[0]};
+    }
+    $cfg;
+}
 
-  ($scale,$mode);
-  }
+sub _scale_a {
+    # select accuracy parameter based on precedence,
+    # used by bround() and bfround(), may return undef for scale (means no op)
+    my ($x, $scale, $mode) = @_;
 
-##############################################################################
-# constructors
+    $scale = $x->{_a} unless defined $scale;
 
-sub copy {
-    my $self    = shift;
-    my $selfref = ref $self;
-    my $class   = $selfref || $self;
+    no strict 'refs';
+    my $class = ref($x);
 
-    # If called as a class method, the object to copy is the next argument.
+    $scale = ${ $class . '::accuracy' } unless defined $scale;
+    $mode = ${ $class . '::round_mode' } unless defined $mode;
 
-    $self = shift() unless $selfref;
+    if (defined $scale) {
+        $scale = $scale->can('numify') ? $scale->numify()
+                                       : "$scale" if ref($scale);
+        $scale = int($scale);
+    }
 
-    my $copy = bless {}, $class;
+    ($scale, $mode);
+}
 
-    $copy->{sign}  = $self->{sign};
-    $copy->{value} = $CALC->_copy($self->{value});
-    $copy->{_a}    = $self->{_a} if exists $self->{_a};
-    $copy->{_p}    = $self->{_p} if exists $self->{_p};
+sub _scale_p {
+    # select precision parameter based on precedence,
+    # used by bround() and bfround(), may return undef for scale (means no op)
+    my ($x, $scale, $mode) = @_;
 
-    return $copy;
+    $scale = $x->{_p} unless defined $scale;
+
+    no strict 'refs';
+    my $class = ref($x);
+
+    $scale = ${ $class . '::precision' } unless defined $scale;
+    $mode = ${ $class . '::round_mode' } unless defined $mode;
+
+    if (defined $scale) {
+        $scale = $scale->can('numify') ? $scale->numify()
+                                       : "$scale" if ref($scale);
+        $scale = int($scale);
+    }
+
+    ($scale, $mode);
 }
 
+###############################################################################
+# Constructor methods
+###############################################################################
+
 sub new {
     # Create a new Math::BigInt object from a string or another Math::BigInt
     # object. See hash keys documented at top.
@@ -524,15 +535,29 @@ sub new {
     my $selfref = ref $self;
     my $class   = $selfref || $self;
 
+    # The POD says:
+    #
+    # "Currently, Math::BigInt->new() defaults to 0, while Math::BigInt->new('')
+    # results in 'NaN'. This might change in the future, so use always the
+    # following explicit forms to get a zero or NaN:
+    #     $zero = Math::BigInt->bzero();
+    #     $nan = Math::BigInt->bnan();
+    #
+    # But although this use has been discouraged for more than 10 years, people
+    # apparently still use it, so we still support it.
+
+    return $self->bzero() unless @_;
+
     my ($wanted, $a, $p, $r) = @_;
 
-    # If called as a class method, initialize a new object.
+    # Always return a new object, so it called as an instance method, copy the
+    # invocand, and if called as a class method, initialize a new object.
 
-    $self = bless {}, $class unless $selfref;
+    $self = $selfref ? $self -> copy()
+                     : bless {}, $class;
 
     unless (defined $wanted) {
-        require Carp;
-        Carp::carp("Use of uninitialized value in new");
+        #Carp::carp("Use of uninitialized value in new()");
         return $self->bzero($a, $p, $r);
     }
 
@@ -571,7 +596,7 @@ sub new {
             || defined(${"${class}::accuracy"}))
         {
             $self->round($a, $p, $r)
-              unless @_ == 4 && !defined $a && !defined $p;
+              unless @_ >= 3 && !defined $a && !defined $p;
         }
 
         return $self;
@@ -582,28 +607,38 @@ sub new {
     if ($wanted =~ /^\s*([+-]?)inf(inity)?\s*\z/i) {
         my $sgn = $1 || '+';
         $self->{sign} = $sgn . 'inf';   # set a default sign for bstr()
-        return $self->binf($sgn);
+        return $class->binf($sgn);
     }
 
     # Handle explicit NaNs (not the ones returned due to invalid input).
 
     if ($wanted =~ /^\s*([+-]?)nan\s*\z/i) {
-        return $self->bnan();
+        $self = $class -> bnan();
+        $self->round($a, $p, $r) unless @_ >= 3 && !defined $a && !defined $p;
+        return $self;
     }
 
+    # Handle hexadecimal numbers.
+
     if ($wanted =~ /^\s*[+-]?0[Xx]/) {
-        return $class -> from_hex($wanted);
+        $self = $class -> from_hex($wanted);
+        $self->round($a, $p, $r) unless @_ >= 3 && !defined $a && !defined $p;
+        return $self;
     }
 
+    # Handle binary numbers.
+
     if ($wanted =~ /^\s*[+-]?0[Bb]/) {
-        return $class -> from_bin($wanted);
+        $self = $class -> from_bin($wanted);
+        $self->round($a, $p, $r) unless @_ >= 3 && !defined $a && !defined $p;
+        return $self;
     }
 
     # Split string into mantissa, exponent, integer, fraction, value, and sign.
     my ($mis, $miv, $mfv, $es, $ev) = _split($wanted);
     if (!ref $mis) {
         if ($_trap_nan) {
-            require Carp; Carp::croak("$wanted is not a number in $class");
+            Carp::croak("$wanted is not a number in $class");
         }
         $self->{value} = $CALC->_zero();
         $self->{sign} = $nan;
@@ -626,7 +661,7 @@ sub new {
         my $diff = $e - CORE::length($$mfv);
         if ($diff < 0) {         # Not integer
             if ($_trap_nan) {
-                require Carp; Carp::croak("$wanted not an integer in $class");
+                Carp::croak("$wanted not an integer in $class");
             }
             #print "NOI 1\n";
             return $upgrade->new($wanted, $a, $p, $r) if defined $upgrade;
@@ -642,7 +677,7 @@ sub new {
         if ($$mfv ne '') {       # e <= 0
             # fraction and negative/zero E => NOI
             if ($_trap_nan) {
-                require Carp; Carp::croak("$wanted not an integer in $class");
+                Carp::croak("$wanted not an integer in $class");
             }
             #print "NOI 2 \$\$mfv '$$mfv'\n";
             return $upgrade->new($wanted, $a, $p, $r) if defined $upgrade;
@@ -657,7 +692,7 @@ sub new {
 
             if ($frac =~ /[^0]/) {
                 if ($_trap_nan) {
-                    require Carp; Carp::croak("$wanted not an integer in $class");
+                    Carp::croak("$wanted not an integer in $class");
                 }
                 #print "NOI 3\n";
                 return $upgrade->new($wanted, $a, $p, $r) if defined $upgrade;
@@ -675,1056 +710,954 @@ sub new {
     # $self. Do not round for new($x, undef, undef) since that is used by MBF
     # to signal no rounding.
 
-    $self->round($a, $p, $r) unless @_ == 4 && !defined $a && !defined $p;
+    $self->round($a, $p, $r) unless @_ >= 3 && !defined $a && !defined $p;
     $self;
 }
 
-sub bnan
-  {
-  # create a bigint 'NaN', if given a BigInt, set it to 'NaN'
-  my $self = shift;
-  $self = $class if !defined $self;
-  if (!ref($self))
-    {
-    my $c = $self; $self = {}; bless $self, $c;
-    }
-  no strict 'refs';
-  if (${"${class}::_trap_nan"})
-    {
-    require Carp;
-    Carp::croak ("Tried to set $self to NaN in $class\::bnan()");
-    }
-  $self->import() if $IMPORT == 0;              # make require work
-  return if $self->modify('bnan');
-  if ($self->can('_bnan'))
-    {
-    # use subclass to initialize
-    $self->_bnan();
-    }
-  else
-    {
-    # otherwise do our own thing
-    $self->{value} = $CALC->_zero();
-    }
-  $self->{sign} = $nan;
-  delete $self->{_a}; delete $self->{_p};       # rounding NaN is silly
-  $self;
-  }
-
-sub binf
-  {
-  # create a bigint '+-inf', if given a BigInt, set it to '+-inf'
-  # the sign is either '+', or if given, used from there
-  my $self = shift;
-  my $sign = shift; $sign = '+' if !defined $sign || $sign !~ /^-(inf)?$/;
-  $self = $class if !defined $self;
-  if (!ref($self))
-    {
-    my $c = $self; $self = {}; bless $self, $c;
-    }
-  no strict 'refs';
-  if (${"${class}::_trap_inf"})
-    {
-    require Carp;
-    Carp::croak ("Tried to set $self to +-inf in $class\::binf()");
-    }
-  $self->import() if $IMPORT == 0;              # make require work
-  return if $self->modify('binf');
-  if ($self->can('_binf'))
+# Create a Math::BigInt from a hexadecimal string.
+
+sub from_hex {
+    my $self    = shift;
+    my $selfref = ref $self;
+    my $class   = $selfref || $self;
+
+    my $str = shift;
+
+    # If called as a class method, initialize a new object.
+
+    $self = $class -> bzero() unless $selfref;
+
+    if ($str =~ s/
+                     ^
+                     ( [+-]? )
+                     (0?x)?
+                     (
+                         [0-9a-fA-F]*
+                         ( _ [0-9a-fA-F]+ )*
+                     )
+                     $
+                 //x)
     {
-    # use subclass to initialize
-    $self->_binf();
+        # Get a "clean" version of the string, i.e., non-emtpy and with no
+        # underscores or invalid characters.
+
+        my $sign = $1;
+        my $chrs = $3;
+        $chrs =~ tr/_//d;
+        $chrs = '0' unless CORE::length $chrs;
+
+        # The library method requires a prefix.
+
+        $self->{value} = $CALC->_from_hex('0x' . $chrs);
+
+        # Place the sign.
+
+        if ($sign eq '-' && ! $CALC->_is_zero($self->{value})) {
+            $self->{sign} = '-';
+        }
+
+        return $self;
     }
-  else
+
+    # CORE::hex() parses as much as it can, and ignores any trailing garbage.
+    # For backwards compatibility, we return NaN.
+
+    return $self->bnan();
+}
+
+# Create a Math::BigInt from an octal string.
+
+sub from_oct {
+    my $self    = shift;
+    my $selfref = ref $self;
+    my $class   = $selfref || $self;
+
+    my $str = shift;
+
+    # If called as a class method, initialize a new object.
+
+    $self = $class -> bzero() unless $selfref;
+
+    if ($str =~ s/
+                     ^
+                     ( [+-]? )
+                     (
+                         [0-7]*
+                         ( _ [0-7]+ )*
+                     )
+                     $
+                 //x)
     {
-    # otherwise do our own thing
-    $self->{value} = $CALC->_zero();
+        # Get a "clean" version of the string, i.e., non-emtpy and with no
+        # underscores or invalid characters.
+
+        my $sign = $1;
+        my $chrs = $2;
+        $chrs =~ tr/_//d;
+        $chrs = '0' unless CORE::length $chrs;
+
+        # The library method requires a prefix.
+
+        $self->{value} = $CALC->_from_oct('0' . $chrs);
+
+        # Place the sign.
+
+        if ($sign eq '-' && ! $CALC->_is_zero($self->{value})) {
+            $self->{sign} = '-';
+        }
+
+        return $self;
     }
-  $sign = $sign . 'inf' if $sign !~ /inf$/;     # - => -inf
-  $self->{sign} = $sign;
-  ($self->{_a},$self->{_p}) = @_;               # take over requested rounding
-  $self;
-  }
 
-sub bzero
-  {
-  # create a bigint '+0', if given a BigInt, set it to 0
-  my $self = shift;
-  $self = __PACKAGE__ if !defined $self;
+    # CORE::oct() parses as much as it can, and ignores any trailing garbage.
+    # For backwards compatibility, we return NaN.
+
+    return $self->bnan();
+}
+
+# Create a Math::BigInt from a binary string.
+
+sub from_bin {
+    my $self    = shift;
+    my $selfref = ref $self;
+    my $class   = $selfref || $self;
+
+    my $str = shift;
 
-  if (!ref($self))
+    # If called as a class method, initialize a new object.
+
+    $self = $class -> bzero() unless $selfref;
+
+    if ($str =~ s/
+                     ^
+                     ( [+-]? )
+                     (0?b)?
+                     (
+                         [01]*
+                         ( _ [01]+ )*
+                     )
+                     $
+                 //x)
     {
-    my $c = $self; $self = {}; bless $self, $c;
+        # Get a "clean" version of the string, i.e., non-emtpy and with no
+        # underscores or invalid characters.
+
+        my $sign = $1;
+        my $chrs = $3;
+        $chrs =~ tr/_//d;
+        $chrs = '0' unless CORE::length $chrs;
+
+        # The library method requires a prefix.
+
+        $self->{value} = $CALC->_from_bin('0b' . $chrs);
+
+        # Place the sign.
+
+        if ($sign eq '-' && ! $CALC->_is_zero($self->{value})) {
+            $self->{sign} = '-';
+        }
+
+        return $self;
     }
-  $self->import() if $IMPORT == 0;              # make require work
-  return if $self->modify('bzero');
 
-  if ($self->can('_bzero'))
-    {
-    # use subclass to initialize
-    $self->_bzero();
+    # For consistency with from_hex() and from_oct(), we return NaN when the
+    # input is invalid.
+
+    return $self->bnan();
+}
+
+sub bzero {
+    # create/assign '+0'
+
+    if (@_ == 0) {
+        Carp::carp("Using bzero() as a function is deprecated;",
+                   " use bzero() as a method instead");
+        unshift @_, __PACKAGE__;
     }
-  else
-    {
-    # otherwise do our own thing
+
+    my $self    = shift;
+    my $selfref = ref $self;
+    my $class   = $selfref || $self;
+
+    $self->import() if $IMPORT == 0;            # make require work
+    return if $self->modify('bzero');
+
+    $self = bless {}, $class unless $selfref;
+
+    $self->{sign} = '+';
     $self->{value} = $CALC->_zero();
+
+    if (@_ > 0) {
+        if (@_ > 3) {
+            # call like: $x->bzero($a, $p, $r, $y, ...);
+            ($self, $self->{_a}, $self->{_p}) = $self->_find_round_parameters(@_);
+        } else {
+            # call like: $x->bzero($a, $p, $r);
+            $self->{_a} = $_[0]
+              if !defined $self->{_a} || (defined $_[0] && $_[0] > $self->{_a});
+            $self->{_p} = $_[1]
+              if !defined $self->{_p} || (defined $_[1] && $_[1] > $self->{_p});
+        }
     }
-  $self->{sign} = '+';
-  if (@_ > 0)
-    {
-    if (@_ > 3)
-      {
-      # call like: $x->bzero($a,$p,$r,$y);
-      ($self,$self->{_a},$self->{_p}) = $self->_find_round_parameters(@_);
-      }
-    else
-      {
-      $self->{_a} = $_[0]
-       if ( (!defined $self->{_a}) || (defined $_[0] && $_[0] > $self->{_a}));
-      $self->{_p} = $_[1]
-       if ( (!defined $self->{_p}) || (defined $_[1] && $_[1] > $self->{_p}));
-      }
-    }
-  $self;
-  }
-
-sub bone
-  {
-  # create a bigint '+1' (or -1 if given sign '-'),
-  # if given a BigInt, set it to +1 or -1, respectively
-  my $self = shift;
-  my $sign = shift; $sign = '+' if !defined $sign || $sign ne '-';
-  $self = $class if !defined $self;
-
-  if (!ref($self))
-    {
-    my $c = $self; $self = {}; bless $self, $c;
-    }
-  $self->import() if $IMPORT == 0;              # make require work
-  return if $self->modify('bone');
 
-  if ($self->can('_bone'))
-    {
-    # use subclass to initialize
-    $self->_bone();
+    return $self;
+}
+
+sub bone {
+    # Create or assign '+1' (or -1 if given sign '-').
+
+    if (@_ == 0 || (defined($_[0]) && ($_[0] eq '+' || $_[0] eq '-'))) {
+        Carp::carp("Using bone() as a function is deprecated;",
+                   " use bone() as a method instead");
+        unshift @_, __PACKAGE__;
     }
-  else
-    {
-    # otherwise do our own thing
+
+    my $self    = shift;
+    my $selfref = ref $self;
+    my $class   = $selfref || $self;
+
+    $self->import() if $IMPORT == 0;            # make require work
+    return if $self->modify('bzero');
+
+    my $sign = shift;
+    $sign = defined $sign && $sign =~ /^\s*-/ ? "-" : "+";
+
+    $self = bless {}, $class unless $selfref;
+
+    $self->{sign}  = $sign;
     $self->{value} = $CALC->_one();
+
+    if (@_ > 0) {
+        if (@_ > 3) {
+            # call like: $x->bone($sign, $a, $p, $r, $y, ...);
+            ($self, $self->{_a}, $self->{_p}) = $self->_find_round_parameters(@_);
+        } else {
+            # call like: $x->bone($sign, $a, $p, $r);
+            $self->{_a} = $_[0]
+              if !defined $self->{_a} || (defined $_[0] && $_[0] > $self->{_a});
+            $self->{_p} = $_[1]
+              if !defined $self->{_p} || (defined $_[1] && $_[1] > $self->{_p});
+        }
     }
-  $self->{sign} = $sign;
-  if (@_ > 0)
-    {
-    if (@_ > 3)
-      {
-      # call like: $x->bone($sign,$a,$p,$r,$y);
-      ($self,$self->{_a},$self->{_p}) = $self->_find_round_parameters(@_);
-      }
-    else
-      {
-      # call like: $x->bone($sign,$a,$p,$r);
-      $self->{_a} = $_[0]
-       if ( (!defined $self->{_a}) || (defined $_[0] && $_[0] > $self->{_a}));
-      $self->{_p} = $_[1]
-       if ( (!defined $self->{_p}) || (defined $_[1] && $_[1] > $self->{_p}));
-      }
-    }
-  $self;
-  }
 
-##############################################################################
-# string conversion
+    return $self;
+}
 
-sub bsstr
-  {
-  # (ref to BFLOAT or num_str ) return num_str
-  # Convert number from internal format to scientific string format.
-  # internal format is always normalized (no leading zeros, "-0E0" => "+0E0")
-  my ($self,$x) = ref($_[0]) ? (undef,$_[0]) : objectify(1,@_);
+sub binf {
+    # create/assign a '+inf' or '-inf'
 
-  if ($x->{sign} !~ /^[+-]$/)
+    if (@_ == 0 || (defined($_[0]) && !ref($_[0]) &&
+                    $_[0] =~ /^\s*[+-](inf(inity)?)?\s*$/))
     {
-    return $x->{sign} unless $x->{sign} eq '+inf';      # -inf, NaN
-    return 'inf';                                       # +inf
+        Carp::carp("Using binf() as a function is deprecated;",
+                   " use binf() as a method instead");
+        unshift @_, __PACKAGE__;
     }
-  my ($m,$e) = $x->parts();
-  #$m->bstr() . 'e+' . $e->bstr();      # e can only be positive in BigInt
-  # 'e+' because E can only be positive in BigInt
-  $m->bstr() . 'e+' . $CALC->_str($e->{value});
-  }
 
-sub bstr
-  {
-  # make a string from bigint object
-  my ($self,$x) = ref($_[0]) ? (undef,$_[0]) : objectify(1,@_);
+    my $self    = shift;
+    my $selfref = ref $self;
+    my $class   = $selfref || $self;
 
-  if ($x->{sign} !~ /^[+-]$/)
     {
-    return $x->{sign} unless $x->{sign} eq '+inf';      # -inf, NaN
-    return 'inf';                                       # +inf
-    }
-  my $es = ''; $es = $x->{sign} if $x->{sign} eq '-';
-  $es.$CALC->_str($x->{value});
-  }
-
-sub numify
-  {
-  # Make a Perl scalar number from a Math::BigInt object.
-  my $x = shift; $x = $class->new($x) unless ref $x;
-
-  if ($x -> is_nan()) {
-      require Math::Complex;
-      my $inf = Math::Complex::Inf();
-      return $inf - $inf;
-  }
-
-  if ($x -> is_inf()) {
-      require Math::Complex;
-      my $inf = Math::Complex::Inf();
-      return $x -> is_negative() ? -$inf : $inf;
-  }
-
-  my $num = 0 + $CALC->_num($x->{value});
-  return $x->{sign} eq '-' ? -$num : $num;
-  }
-
-##############################################################################
-# public stuff (usually prefixed with "b")
-
-sub sign
-  {
-  # return the sign of the number: +/-/-inf/+inf/NaN
-  my ($self,$x) = ref($_[0]) ? (undef,$_[0]) : objectify(1,@_);
+        no strict 'refs';
+        if (${"${class}::_trap_inf"}) {
+            Carp::croak("Tried to create +-inf in $class->binf()");
+        }
+    }
 
-  $x->{sign};
-  }
+    $self->import() if $IMPORT == 0;            # make require work
+    return if $self->modify('binf');
 
-sub _find_round_parameters {
-    # After any operation or when calling round(), the result is rounded by
-    # regarding the A & P from arguments, local parameters, or globals.
+    my $sign = shift;
+    $sign = defined $sign && $sign =~ /^\s*-/ ? "-" : "+";
 
-    # !!!!!!! If you change this, remember to change round(), too! !!!!!!!!!!
+    $self = bless {}, $class unless $selfref;
 
-    # This procedure finds the round parameters, but it is for speed reasons
-    # duplicated in round. Otherwise, it is tested by the testsuite and used
-    # by bdiv().
+    $self -> {sign}  = $sign . 'inf';
+    $self -> {value} = $CALC -> _zero();
 
-    # returns ($self) or ($self,$a,$p,$r) - sets $self to NaN of both A and P
-    # were requested/defined (locally or globally or both)
+    return $self;
+}
 
-    my ($self, $a, $p, $r, @args) = @_;
-    # $a accuracy, if given by caller
-    # $p precision, if given by caller
-    # $r round_mode, if given by caller
-    # @args all 'other' arguments (0 for unary, 1 for binary ops)
+sub bnan {
+    # create/assign a 'NaN'
 
-    my $class = ref($self);       # find out class of argument(s)
-    no strict 'refs';
+    if (@_ == 0) {
+        Carp::carp("Using bnan() as a function is deprecated;",
+                   " use bnan() as a method instead");
+        unshift @_, __PACKAGE__;
+    }
 
-    # convert to normal scalar for speed and correctness in inner parts
-    $a = $a->can('numify') ? $a->numify() : "$a" if defined $a && ref($a);
-    $p = $p->can('numify') ? $p->numify() : "$p" if defined $p && ref($p);
+    my $self    = shift;
+    my $selfref = ref($self);
+    my $class   = $selfref || $self;
 
-    # now pick $a or $p, but only if we have got "arguments"
-    if (!defined $a) {
-        foreach ($self, @args) {
-            # take the defined one, or if both defined, the one that is smaller
-            $a = $_->{_a} if (defined $_->{_a}) && (!defined $a || $_->{_a} < $a);
-        }
-    }
-    if (!defined $p) {
-        # even if $a is defined, take $p, to signal error for both defined
-        foreach ($self, @args) {
-            # take the defined one, or if both defined, the one that is bigger
-            # -2 > -3, and 3 > 2
-            $p = $_->{_p} if (defined $_->{_p}) && (!defined $p || $_->{_p} > $p);
+    {
+        no strict 'refs';
+        if (${"${class}::_trap_nan"}) {
+            Carp::croak("Tried to create NaN in $class->bnan()");
         }
     }
 
-    # if still none defined, use globals (#2)
-    $a = ${"$class\::accuracy"}  unless defined $a;
-    $p = ${"$class\::precision"} unless defined $p;
+    $self->import() if $IMPORT == 0;            # make require work
+    return if $self->modify('bnan');
 
-    # A == 0 is useless, so undef it to signal no rounding
-    $a = undef if defined $a && $a == 0;
+    $self = bless {}, $class unless $selfref;
 
-    # no rounding today?
-    return ($self) unless defined $a || defined $p; # early out
+    $self -> {sign}  = $nan;
+    $self -> {value} = $CALC -> _zero();
 
-    # set A and set P is an fatal error
-    return ($self->bnan()) if defined $a && defined $p; # error
+    return $self;
+}
 
-    $r = ${"$class\::round_mode"} unless defined $r;
-    if ($r !~ /^(even|odd|[+-]inf|zero|trunc|common)$/) {
-        require Carp; Carp::croak ("Unknown round mode '$r'");
+sub bpi {
+    # Calculate PI to N digits. Unless upgrading is in effect, returns the
+    # result truncated to an integer, that is, always returns '3'.
+    my ($self, $n) = @_;
+    if (@_ == 1) {
+        # called like Math::BigInt::bpi(10);
+        $n = $self;
+        $self = $class;
     }
+    $self = ref($self) if ref($self);
 
-    $a = int($a) if defined $a;
-    $p = int($p) if defined $p;
+    return $upgrade->new($n) if defined $upgrade;
 
-    ($self, $a, $p, $r);
+    # hard-wired to "3"
+    $self->new(3);
 }
 
-sub round {
-    # Round $self according to given parameters, or given second argument's
-    # parameters or global defaults
+sub copy {
+    my $self    = shift;
+    my $selfref = ref $self;
+    my $class   = $selfref || $self;
 
-    # for speed reasons, _find_round_parameters is embedded here:
+    # If called as a class method, the object to copy is the next argument.
 
-    my ($self, $a, $p, $r, @args) = @_;
-    # $a accuracy, if given by caller
-    # $p precision, if given by caller
-    # $r round_mode, if given by caller
-    # @args all 'other' arguments (0 for unary, 1 for binary ops)
+    $self = shift() unless $selfref;
 
-    my $class = ref($self);       # find out class of argument(s)
-    no strict 'refs';
+    my $copy = bless {}, $class;
 
-    # now pick $a or $p, but only if we have got "arguments"
-    if (!defined $a) {
-        foreach ($self, @args) {
-            # take the defined one, or if both defined, the one that is smaller
-            $a = $_->{_a} if (defined $_->{_a}) && (!defined $a || $_->{_a} < $a);
-        }
-    }
-    if (!defined $p) {
-        # even if $a is defined, take $p, to signal error for both defined
-        foreach ($self, @args) {
-            # take the defined one, or if both defined, the one that is bigger
-            # -2 > -3, and 3 > 2
-            $p = $_->{_p} if (defined $_->{_p}) && (!defined $p || $_->{_p} > $p);
-        }
-    }
+    $copy->{sign}  = $self->{sign};
+    $copy->{value} = $CALC->_copy($self->{value});
+    $copy->{_a}    = $self->{_a} if exists $self->{_a};
+    $copy->{_p}    = $self->{_p} if exists $self->{_p};
 
-    # if still none defined, use globals (#2)
-    $a = ${"$class\::accuracy"}  unless defined $a;
-    $p = ${"$class\::precision"} unless defined $p;
+    return $copy;
+}
 
-    # A == 0 is useless, so undef it to signal no rounding
-    $a = undef if defined $a && $a == 0;
+sub as_number {
+    # An object might be asked to return itself as bigint on certain overloaded
+    # operations. This does exactly this, so that sub classes can simple inherit
+    # it or override with their own integer conversion routine.
+    $_[0]->copy();
+}
 
-    # no rounding today?
-    return $self unless defined $a || defined $p; # early out
+###############################################################################
+# Boolean methods
+###############################################################################
 
-    # set A and set P is an fatal error
-    return $self->bnan() if defined $a && defined $p;
+sub is_zero {
+    # return true if arg (BINT or num_str) is zero (array '+', '0')
+    my ($class, $x) = ref($_[0]) ? (undef, $_[0]) : objectify(1, @_);
 
-    $r = ${"$class\::round_mode"} unless defined $r;
-    if ($r !~ /^(even|odd|[+-]inf|zero|trunc|common)$/) {
-        require Carp; Carp::croak ("Unknown round mode '$r'");
-    }
+    return 0 if $x->{sign} !~ /^\+$/; # -, NaN & +-inf aren't
+    $CALC->_is_zero($x->{value});
+}
 
-    # now round, by calling either bround or bfround:
-    if (defined $a) {
-        $self->bround(int($a), $r) if !defined $self->{_a} || $self->{_a} >= $a;
-    } else {                  # both can't be undefined due to early out
-        $self->bfround(int($p), $r) if !defined $self->{_p} || $self->{_p} <= $p;
-    }
+sub is_one {
+    # return true if arg (BINT or num_str) is +1, or -1 if sign is given
+    my ($class, $x, $sign) = ref($_[0]) ? (undef, @_) : objectify(1, @_);
 
-    # bround() or bfround() already called bnorm() if nec.
-    $self;
+    $sign = '+' if !defined $sign || $sign ne '-';
+
+    return 0 if $x->{sign} ne $sign; # -1 != +1, NaN, +-inf aren't either
+    $CALC->_is_one($x->{value});
 }
 
-sub bnorm
-  {
-  # (numstr or BINT) return BINT
-  # Normalize number -- no-op here
-  my ($self,$x) = ref($_[0]) ? (undef,$_[0]) : objectify(1,@_);
-  $x;
-  }
-
-sub babs
-  {
-  # (BINT or num_str) return BINT
-  # make number absolute, or return absolute BINT from string
-  my ($self,$x) = ref($_[0]) ? (undef,$_[0]) : objectify(1,@_);
-
-  return $x if $x->modify('babs');
-  # post-normalized abs for internal use (does nothing for NaN)
-  $x->{sign} =~ s/^-/+/;
-  $x;
-  }
+sub is_inf {
+    # return true if arg (BINT or num_str) is +-inf
+    my ($class, $x, $sign) = ref($_[0]) ? (undef, @_) : objectify(1, @_);
 
-sub bsgn {
-    # Signum function.
+    if (defined $sign) {
+        $sign = '[+-]inf' if $sign eq ''; # +- doesn't matter, only that's inf
+        $sign = "[$1]inf" if $sign =~ /^([+-])(inf)?$/; # extract '+' or '-'
+        return $x->{sign} =~ /^$sign$/ ? 1 : 0;
+    }
+    $x->{sign} =~ /^[+-]inf$/ ? 1 : 0; # only +-inf is infinity
+}
 
-    my $self = shift;
+sub is_nan {
+    # return true if arg (BINT or num_str) is NaN
+    my ($class, $x) = ref($_[0]) ? (undef, $_[0]) : objectify(1, @_);
 
-    return $self if $self->modify('bsgn');
+    $x->{sign} eq $nan ? 1 : 0;
+}
 
-    return $self -> bone("+") if $self -> is_pos();
-    return $self -> bone("-") if $self -> is_neg();
-    return $self;               # zero or NaN
+sub is_positive {
+    # return true when arg (BINT or num_str) is positive (> 0)
+    my ($class, $x) = ref($_[0]) ? (undef, $_[0]) : objectify(1, @_);
+
+    return 1 if $x->{sign} eq '+inf'; # +inf is positive
+
+    # 0+ is neither positive nor negative
+    ($x->{sign} eq '+' && !$x->is_zero()) ? 1 : 0;
 }
 
-sub bneg
-  {
-  # (BINT or num_str) return BINT
-  # negate number or make a negated number from string
-  my ($self,$x) = ref($_[0]) ? (undef,$_[0]) : objectify(1,@_);
+sub is_negative {
+    # return true when arg (BINT or num_str) is negative (< 0)
+    my ($class, $x) = ref($_[0]) ? (undef, $_[0]) : objectify(1, @_);
 
-  return $x if $x->modify('bneg');
+    $x->{sign} =~ /^-/ ? 1 : 0; # -inf is negative, but NaN is not
+}
 
-  # for +0 do not negate (to have always normalized +0). Does nothing for 'NaN'
-  $x->{sign} =~ tr/+-/-+/ unless ($x->{sign} eq '+' && $CALC->_is_zero($x->{value}));
-  $x;
-  }
+sub is_odd {
+    # return true when arg (BINT or num_str) is odd, false for even
+    my ($class, $x) = ref($_[0]) ? (undef, $_[0]) : objectify(1, @_);
 
-sub bcmp
-  {
-  # Compares 2 values.  Returns one of undef, <0, =0, >0. (suitable for sort)
-  # (BINT or num_str, BINT or num_str) return cond_code
+    return 0 if $x->{sign} !~ /^[+-]$/; # NaN & +-inf aren't
+    $CALC->_is_odd($x->{value});
+}
 
-  # set up parameters
-  my ($self,$x,$y) = (ref($_[0]),@_);
+sub is_even {
+    # return true when arg (BINT or num_str) is even, false for odd
+    my ($class, $x) = ref($_[0]) ? (undef, $_[0]) : objectify(1, @_);
 
-  # objectify is costly, so avoid it
-  if ((!ref($_[0])) || (ref($_[0]) ne ref($_[1])))
-    {
-    ($self,$x,$y) = objectify(2,@_);
-    }
+    return 0 if $x->{sign} !~ /^[+-]$/; # NaN & +-inf aren't
+    $CALC->_is_even($x->{value});
+}
 
-  return $upgrade->bcmp($x,$y) if defined $upgrade &&
-    ((!$x->isa($self)) || (!$y->isa($self)));
+sub is_int {
+    # return true when arg (BINT or num_str) is an integer
+    # always true for Math::BigInt, but different for Math::BigFloat objects
+    my ($class, $x) = ref($_[0]) ? (undef, $_[0]) : objectify(1, @_);
 
-  if (($x->{sign} !~ /^[+-]$/) || ($y->{sign} !~ /^[+-]$/))
-    {
-    # handle +-inf and NaN
-    return undef if (($x->{sign} eq $nan) || ($y->{sign} eq $nan));
-    return 0 if $x->{sign} eq $y->{sign} && $x->{sign} =~ /^[+-]inf$/;
-    return +1 if $x->{sign} eq '+inf';
-    return -1 if $x->{sign} eq '-inf';
-    return -1 if $y->{sign} eq '+inf';
-    return +1;
-    }
-  # check sign for speed first
-  return 1 if $x->{sign} eq '+' && $y->{sign} eq '-';   # does also 0 <=> -y
-  return -1 if $x->{sign} eq '-' && $y->{sign} eq '+';  # does also -x <=> 0
-
-  # have same sign, so compare absolute values.  Don't make tests for zero
-  # here because it's actually slower than testing in Calc (especially w/ Pari
-  # et al)
-
-  # post-normalized compare for internal use (honors signs)
-  if ($x->{sign} eq '+')
-    {
-    # $x and $y both > 0
-    return $CALC->_acmp($x->{value},$y->{value});
-    }
+    $x->{sign} =~ /^[+-]$/ ? 1 : 0; # inf/-inf/NaN aren't
+}
+
+###############################################################################
+# Comparison methods
+###############################################################################
 
-  # $x && $y both < 0
-  $CALC->_acmp($y->{value},$x->{value});        # swapped acmp (lib returns 0,1,-1)
-  }
+sub bcmp {
+    # Compares 2 values.  Returns one of undef, <0, =0, >0. (suitable for sort)
+    # (BINT or num_str, BINT or num_str) return cond_code
 
-sub bacmp
-  {
-  # Compares 2 values, ignoring their signs.
-  # Returns one of undef, <0, =0, >0. (suitable for sort)
-  # (BINT, BINT) return cond_code
+    # set up parameters
+    my ($class, $x, $y) = (ref($_[0]), @_);
 
-  # set up parameters
-  my ($self,$x,$y) = (ref($_[0]),@_);
-  # objectify is costly, so avoid it
-  if ((!ref($_[0])) || (ref($_[0]) ne ref($_[1])))
-    {
-    ($self,$x,$y) = objectify(2,@_);
+    # objectify is costly, so avoid it
+    if ((!ref($_[0])) || (ref($_[0]) ne ref($_[1]))) {
+        ($class, $x, $y) = objectify(2, @_);
     }
 
-  return $upgrade->bacmp($x,$y) if defined $upgrade &&
-    ((!$x->isa($self)) || (!$y->isa($self)));
+    return $upgrade->bcmp($x, $y) if defined $upgrade &&
+      ((!$x->isa($class)) || (!$y->isa($class)));
 
-  if (($x->{sign} !~ /^[+-]$/) || ($y->{sign} !~ /^[+-]$/))
-    {
-    # handle +-inf and NaN
-    return undef if (($x->{sign} eq $nan) || ($y->{sign} eq $nan));
-    return 0 if $x->{sign} =~ /^[+-]inf$/ && $y->{sign} =~ /^[+-]inf$/;
-    return 1 if $x->{sign} =~ /^[+-]inf$/ && $y->{sign} !~ /^[+-]inf$/;
-    return -1;
-    }
-  $CALC->_acmp($x->{value},$y->{value});        # lib does only 0,1,-1
-  }
-
-sub badd
-  {
-  # add second arg (BINT or string) to first (BINT) (modifies first)
-  # return result as BINT
-
-  # set up parameters
-  my ($self,$x,$y,@r) = (ref($_[0]),@_);
-  # objectify is costly, so avoid it
-  if ((!ref($_[0])) || (ref($_[0]) ne ref($_[1])))
-    {
-    ($self,$x,$y,@r) = objectify(2,@_);
+    if (($x->{sign} !~ /^[+-]$/) || ($y->{sign} !~ /^[+-]$/)) {
+        # handle +-inf and NaN
+        return undef if (($x->{sign} eq $nan) || ($y->{sign} eq $nan));
+        return 0 if $x->{sign} eq $y->{sign} && $x->{sign} =~ /^[+-]inf$/;
+        return +1 if $x->{sign} eq '+inf';
+        return -1 if $x->{sign} eq '-inf';
+        return -1 if $y->{sign} eq '+inf';
+        return +1;
     }
+    # check sign for speed first
+    return 1 if $x->{sign} eq '+' && $y->{sign} eq '-'; # does also 0 <=> -y
+    return -1 if $x->{sign} eq '-' && $y->{sign} eq '+'; # does also -x <=> 0
 
-  return $x if $x->modify('badd');
-  return $upgrade->badd($upgrade->new($x),$upgrade->new($y),@r) if defined $upgrade &&
-    ((!$x->isa($self)) || (!$y->isa($self)));
+    # have same sign, so compare absolute values.  Don't make tests for zero
+    # here because it's actually slower than testing in Calc (especially w/ Pari
+    # et al)
 
-  $r[3] = $y;                           # no push!
-  # inf and NaN handling
-  if (($x->{sign} !~ /^[+-]$/) || ($y->{sign} !~ /^[+-]$/))
-    {
-    # NaN first
-    return $x->bnan() if (($x->{sign} eq $nan) || ($y->{sign} eq $nan));
-    # inf handling
-    if (($x->{sign} =~ /^[+-]inf$/) && ($y->{sign} =~ /^[+-]inf$/))
-      {
-      # +inf++inf or -inf+-inf => same, rest is NaN
-      return $x if $x->{sign} eq $y->{sign};
-      return $x->bnan();
-      }
-    # +-inf + something => +inf
-    # something +-inf => +-inf
-    $x->{sign} = $y->{sign}, return $x if $y->{sign} =~ /^[+-]inf$/;
-    return $x;
+    # post-normalized compare for internal use (honors signs)
+    if ($x->{sign} eq '+') {
+        # $x and $y both > 0
+        return $CALC->_acmp($x->{value}, $y->{value});
     }
 
-  my ($sx, $sy) = ( $x->{sign}, $y->{sign} );           # get signs
+    # $x && $y both < 0
+    $CALC->_acmp($y->{value}, $x->{value}); # swapped acmp (lib returns 0, 1, -1)
+}
+
+sub bacmp {
+    # Compares 2 values, ignoring their signs.
+    # Returns one of undef, <0, =0, >0. (suitable for sort)
+    # (BINT, BINT) return cond_code
 
-  if ($sx eq $sy)
-    {
-    $x->{value} = $CALC->_add($x->{value},$y->{value}); # same sign, abs add
+    # set up parameters
+    my ($class, $x, $y) = (ref($_[0]), @_);
+    # objectify is costly, so avoid it
+    if ((!ref($_[0])) || (ref($_[0]) ne ref($_[1]))) {
+        ($class, $x, $y) = objectify(2, @_);
     }
-  else
-    {
-    my $a = $CALC->_acmp ($y->{value},$x->{value});     # absolute compare
-    if ($a > 0)
-      {
-      $x->{value} = $CALC->_sub($y->{value},$x->{value},1); # abs sub w/ swap
-      $x->{sign} = $sy;
-      }
-    elsif ($a == 0)
-      {
-      # speedup, if equal, set result to 0
-      $x->{value} = $CALC->_zero();
-      $x->{sign} = '+';
-      }
-    else # a < 0
-      {
-      $x->{value} = $CALC->_sub($x->{value}, $y->{value}); # abs sub
-      }
-    }
-  $x->round(@r);
-  }
-
-sub bsub
-  {
-  # (BINT or num_str, BINT or num_str) return BINT
-  # subtract second arg from first, modify first
-
-  # set up parameters
-  my ($self,$x,$y,@r) = (ref($_[0]),@_);
-
-  # objectify is costly, so avoid it
-  if ((!ref($_[0])) || (ref($_[0]) ne ref($_[1])))
-    {
-    ($self,$x,$y,@r) = objectify(2,@_);
+
+    return $upgrade->bacmp($x, $y) if defined $upgrade &&
+      ((!$x->isa($class)) || (!$y->isa($class)));
+
+    if (($x->{sign} !~ /^[+-]$/) || ($y->{sign} !~ /^[+-]$/)) {
+        # handle +-inf and NaN
+        return undef if (($x->{sign} eq $nan) || ($y->{sign} eq $nan));
+        return 0 if $x->{sign} =~ /^[+-]inf$/ && $y->{sign} =~ /^[+-]inf$/;
+        return 1 if $x->{sign} =~ /^[+-]inf$/ && $y->{sign} !~ /^[+-]inf$/;
+        return -1;
     }
+    $CALC->_acmp($x->{value}, $y->{value}); # lib does only 0, 1, -1
+}
 
-  return $x if $x->modify('bsub');
+sub beq {
+    my $self    = shift;
+    my $selfref = ref $self;
+    my $class   = $selfref || $self;
 
-  return $upgrade->new($x)->bsub($upgrade->new($y),@r) if defined $upgrade &&
-   ((!$x->isa($self)) || (!$y->isa($self)));
+    Carp::croak 'beq() is an instance method, not a class method' unless $selfref;
+    Carp::croak 'Wrong number of arguments for beq()' unless @_ == 1;
 
-  return $x->round(@r) if $y->is_zero();
+    my $cmp = $self -> bcmp(shift);
+    return defined($cmp) && ! $cmp;
+}
 
-  # To correctly handle the lone special case $x->bsub($x), we note the sign
-  # of $x, then flip the sign from $y, and if the sign of $x did change, too,
-  # then we caught the special case:
-  my $xsign = $x->{sign};
-  $y->{sign} =~ tr/+\-/-+/;     # does nothing for NaN
-  if ($xsign ne $x->{sign})
-    {
-    # special case of $x->bsub($x) results in 0
-    return $x->bzero(@r) if $xsign =~ /^[+-]$/;
-    return $x->bnan();          # NaN, -inf, +inf
-    }
-  $x->badd($y,@r);              # badd does not leave internal zeros
-  $y->{sign} =~ tr/+\-/-+/;     # refix $y (does nothing for NaN)
-  $x;                           # already rounded by badd() or no round nec.
-  }
-
-sub binc
-  {
-  # increment arg by one
-  my ($self,$x,$a,$p,$r) = ref($_[0]) ? (ref($_[0]),@_) : objectify(1,@_);
-  return $x if $x->modify('binc');
-
-  if ($x->{sign} eq '+')
-    {
-    $x->{value} = $CALC->_inc($x->{value});
-    return $x->round($a,$p,$r);
-    }
-  elsif ($x->{sign} eq '-')
-    {
-    $x->{value} = $CALC->_dec($x->{value});
-    $x->{sign} = '+' if $CALC->_is_zero($x->{value}); # -1 +1 => -0 => +0
-    return $x->round($a,$p,$r);
-    }
-  # inf, nan handling etc
-  $x->badd($self->bone(),$a,$p,$r);             # badd does round
-  }
+sub bne {
+    my $self    = shift;
+    my $selfref = ref $self;
+    my $class   = $selfref || $self;
 
-sub bdec
-  {
-  # decrement arg by one
-  my ($self,$x,@r) = ref($_[0]) ? (ref($_[0]),@_) : objectify(1,@_);
-  return $x if $x->modify('bdec');
+    Carp::croak 'bne() is an instance method, not a class method' unless $selfref;
+    Carp::croak 'Wrong number of arguments for bne()' unless @_ == 1;
 
-  if ($x->{sign} eq '-')
-    {
-    # x already < 0
-    $x->{value} = $CALC->_inc($x->{value});
-    }
-  else
-    {
-    return $x->badd($self->bone('-'),@r)
-        unless $x->{sign} eq '+'; # inf or NaN
-    # >= 0
-    if ($CALC->_is_zero($x->{value}))
-      {
-      # == 0
-      $x->{value} = $CALC->_one(); $x->{sign} = '-';            # 0 => -1
-      }
-    else
-      {
-      # > 0
-      $x->{value} = $CALC->_dec($x->{value});
-      }
-    }
-  $x->round(@r);
-  }
-
-sub blog
-  {
-  # Return the logarithm of the operand. If a second operand is defined, that
-  # value is used as the base, otherwise the base is assumed to be Euler's
-  # constant.
-
-  # Don't objectify the base, since an undefined base, as in $x->blog() or
-  # $x->blog(undef) signals that the base is Euler's number.
-
-  # set up parameters
-  my ($self,$x,$base,@r) = (undef,@_);
-  # objectify is costly, so avoid it
-  if ((!ref($_[0])) || (ref($_[0]) ne ref($_[1]))) {
-      ($self,$x,$base,@r) = objectify(1,@_);
-  }
-
-  return $x if $x->modify('blog');
-
-  # Handle all exception cases and all trivial cases. I have used Wolfram Alpha
-  # (http://www.wolframalpha.com) as the reference for these cases.
-
-  return $x -> bnan() if $x -> is_nan();
-
-  if (defined $base) {
-      $base = $self -> new($base) unless ref $base;
-      if ($base -> is_nan() || $base -> is_one()) {
-          return $x -> bnan();
-      } elsif ($base -> is_inf() || $base -> is_zero()) {
-          return $x -> bnan() if $x -> is_inf() || $x -> is_zero();
-          return $x -> bzero();
-      } elsif ($base -> is_negative()) {            # -inf < base < 0
-          return $x -> bzero() if $x -> is_one();   #     x = 1
-          return $x -> bone()  if $x == $base;      #     x = base
-          return $x -> bnan();                      #     otherwise
-      }
-      return $x -> bone() if $x == $base;           # 0 < base && 0 < x < inf
-  }
-
-  # We now know that the base is either undefined or >= 2 and finite.
-
-  return $x -> binf('+') if $x -> is_inf();         #   x = +/-inf
-  return $x -> bnan()    if $x -> is_neg();         #   -inf < x < 0
-  return $x -> bzero()   if $x -> is_one();         #   x = 1
-  return $x -> binf('-') if $x -> is_zero();        #   x = 0
-
-  # At this point we are done handling all exception cases and trivial cases.
-
-  return $upgrade -> blog($upgrade -> new($x), $base, @r) if defined $upgrade;
-
-  # fix for bug #24969:
-  # the default base is e (Euler's number) which is not an integer
-  if (!defined $base)
-    {
-    require Math::BigFloat;
-    my $u = Math::BigFloat->blog(Math::BigFloat->new($x))->as_int();
-    # modify $x in place
-    $x->{value} = $u->{value};
-    $x->{sign} = $u->{sign};
-    return $x;
-    }
+    my $cmp = $self -> bcmp(shift);
+    return defined($cmp) && ! $cmp ? '' : 1;
+}
 
-  my ($rc,$exact) = $CALC->_log_int($x->{value},$base->{value});
-  return $x->bnan() unless defined $rc;         # not possible to take log?
-  $x->{value} = $rc;
-  $x->round(@r);
-  }
+sub blt {
+    my $self    = shift;
+    my $selfref = ref $self;
+    my $class   = $selfref || $self;
 
-sub bnok
-  {
-  # Calculate n over k (binomial coefficient or "choose" function) as integer.
-  # set up parameters
-  my ($self,$x,$y,@r) = (ref($_[0]),@_);
+    Carp::croak 'blt() is an instance method, not a class method' unless $selfref;
+    Carp::croak 'Wrong number of arguments for blt()' unless @_ == 1;
 
-  # objectify is costly, so avoid it
-  if ((!ref($_[0])) || (ref($_[0]) ne ref($_[1])))
-    {
-    ($self,$x,$y,@r) = objectify(2,@_);
-    }
+    my $cmp = $self -> bcmp(shift);
+    return defined($cmp) && $cmp < 0;
+}
 
-  return $x if $x->modify('bnok');
-  return $x->bnan() if $x->{sign} eq 'NaN' || $y->{sign} eq 'NaN';
-  return $x->binf() if $x->{sign} eq '+inf';
+sub ble {
+    my $self    = shift;
+    my $selfref = ref $self;
+    my $class   = $selfref || $self;
 
-  # k > n or k < 0 => 0
-  my $cmp = $x->bacmp($y);
-  return $x->bzero() if $cmp < 0 || $y->{sign} =~ /^-/;
-  # k == n => 1
-  return $x->bone(@r) if $cmp == 0;
+    Carp::croak 'ble() is an instance method, not a class method' unless $selfref;
+    Carp::croak 'Wrong number of arguments for ble()' unless @_ == 1;
 
-  if ($CALC->can('_nok'))
-    {
-    $x->{value} = $CALC->_nok($x->{value},$y->{value});
-    }
-  else
-    {
-    # ( 7 )       7!       1*2*3*4 * 5*6*7   5 * 6 * 7       6   7
-    # ( - ) = --------- =  --------------- = --------- = 5 * - * -
-    # ( 3 )   (7-3)! 3!    1*2*3*4 * 1*2*3   1 * 2 * 3       2   3
-
-    if (!$y->is_zero())
-      {
-      my $z = $x - $y;
-      $z->binc();
-      my $r = $z->copy(); $z->binc();
-      my $d = $self->new(2);
-      while ($z->bacmp($x) <= 0)                # f <= x ?
-        {
-        $r->bmul($z); $r->bdiv($d);
-        $z->binc(); $d->binc();
-        }
-      $x->{value} = $r->{value}; $x->{sign} = '+';
-      }
-    else { $x->bone(); }
-    }
-  $x->round(@r);
-  }
-
-sub bexp
-  {
-  # Calculate e ** $x (Euler's number to the power of X), truncated to
-  # an integer value.
-  my ($self,$x,@r) = ref($_[0]) ? (ref($_[0]),@_) : objectify(1,@_);
-  return $x if $x->modify('bexp');
-
-  # inf, -inf, NaN, <0 => NaN
-  return $x->bnan() if $x->{sign} eq 'NaN';
-  return $x->bone() if $x->is_zero();
-  return $x if $x->{sign} eq '+inf';
-  return $x->bzero() if $x->{sign} eq '-inf';
-
-  my $u;
-  {
-    # run through Math::BigFloat unless told otherwise
-    require Math::BigFloat unless defined $upgrade;
-    local $upgrade = 'Math::BigFloat' unless defined $upgrade;
-    # calculate result, truncate it to integer
-    $u = $upgrade->bexp($upgrade->new($x),@r);
-  }
-
-  if (!defined $upgrade)
-    {
-    $u = $u->as_int();
-    # modify $x in place
-    $x->{value} = $u->{value};
-    $x->round(@r);
-    }
-  else { $x = $u; }
-  }
+    my $cmp = $self -> bcmp(shift);
+    return defined($cmp) && $cmp <= 0;
+}
 
-sub blcm
-  {
-  # (BINT or num_str, BINT or num_str) return BINT
-  # does not modify arguments, but returns new object
-  # Lowest Common Multiple
+sub bgt {
+    my $self    = shift;
+    my $selfref = ref $self;
+    my $class   = $selfref || $self;
 
-  my $y = shift; my ($x);
-  if (ref($y))
-    {
-    $x = $y->copy();
-    }
-  else
-    {
-    $x = $class->new($y);
-    }
-  my $self = ref($x);
-  while (@_)
-    {
-    my $y = shift; $y = $self->new($y) if !ref ($y);
-    $x = __lcm($x,$y);
-    }
-  $x;
-  }
+    Carp::croak 'bgt() is an instance method, not a class method' unless $selfref;
+    Carp::croak 'Wrong number of arguments for bgt()' unless @_ == 1;
 
-sub bgcd
-  {
-  # (BINT or num_str, BINT or num_str) return BINT
-  # does not modify arguments, but returns new object
-  # GCD -- Euclid's algorithm, variant C (Knuth Vol 3, pg 341 ff)
+    my $cmp = $self -> bcmp(shift);
+    return defined($cmp) && $cmp > 0;
+}
 
-  my $y = shift;
-  $y = $class->new($y) if !ref($y);
-  my $self = ref($y);
-  my $x = $y->copy()->babs();                   # keep arguments
-  return $x->bnan() if $x->{sign} !~ /^[+-]$/;  # x NaN?
+sub bge {
+    my $self    = shift;
+    my $selfref = ref $self;
+    my $class   = $selfref || $self;
 
-  while (@_)
-    {
-    $y = shift; $y = $self->new($y) if !ref($y);
-    return $x->bnan() if $y->{sign} !~ /^[+-]$/;        # y NaN?
-    $x->{value} = $CALC->_gcd($x->{value},$y->{value});
-    last if $CALC->_is_one($x->{value});
-    }
-  $x;
-  }
+    Carp::croak 'bge() is an instance method, not a class method'
+        unless $selfref;
+    Carp::croak 'Wrong number of arguments for bge()' unless @_ == 1;
 
-sub bnot
-  {
-  # (num_str or BINT) return BINT
-  # represent ~x as twos-complement number
-  # we don't need $self, so undef instead of ref($_[0]) make it slightly faster
-  my ($self,$x,$a,$p,$r) = ref($_[0]) ? (undef,@_) : objectify(1,@_);
+    my $cmp = $self -> bcmp(shift);
+    return defined($cmp) && $cmp >= 0;
+}
 
-  return $x if $x->modify('bnot');
-  $x->binc()->bneg();                   # binc already does round
-  }
+###############################################################################
+# Arithmetic methods
+###############################################################################
 
-##############################################################################
-# is_foo test routines
-# we don't need $self, so undef instead of ref($_[0]) make it slightly faster
+sub bneg {
+    # (BINT or num_str) return BINT
+    # negate number or make a negated number from string
+    my ($class, $x) = ref($_[0]) ? (undef, $_[0]) : objectify(1, @_);
 
-sub is_zero
-  {
-  # return true if arg (BINT or num_str) is zero (array '+', '0')
-  my ($self,$x) = ref($_[0]) ? (undef,$_[0]) : objectify(1,@_);
+    return $x if $x->modify('bneg');
 
-  return 0 if $x->{sign} !~ /^\+$/;                     # -, NaN & +-inf aren't
-  $CALC->_is_zero($x->{value});
-  }
+    # for +0 do not negate (to have always normalized +0). Does nothing for 'NaN'
+    $x->{sign} =~ tr/+-/-+/ unless ($x->{sign} eq '+' && $CALC->_is_zero($x->{value}));
+    $x;
+}
 
-sub is_nan
-  {
-  # return true if arg (BINT or num_str) is NaN
-  my ($self,$x) = ref($_[0]) ? (undef,$_[0]) : objectify(1,@_);
+sub babs {
+    # (BINT or num_str) return BINT
+    # make number absolute, or return absolute BINT from string
+    my ($class, $x) = ref($_[0]) ? (undef, $_[0]) : objectify(1, @_);
 
-  $x->{sign} eq $nan ? 1 : 0;
-  }
+    return $x if $x->modify('babs');
+    # post-normalized abs for internal use (does nothing for NaN)
+    $x->{sign} =~ s/^-/+/;
+    $x;
+}
 
-sub is_inf
-  {
-  # return true if arg (BINT or num_str) is +-inf
-  my ($self,$x,$sign) = ref($_[0]) ? (undef,@_) : objectify(1,@_);
+sub bsgn {
+    # Signum function.
 
-  if (defined $sign)
-    {
-    $sign = '[+-]inf' if $sign eq '';   # +- doesn't matter, only that's inf
-    $sign = "[$1]inf" if $sign =~ /^([+-])(inf)?$/;     # extract '+' or '-'
-    return $x->{sign} =~ /^$sign$/ ? 1 : 0;
-    }
-  $x->{sign} =~ /^[+-]inf$/ ? 1 : 0;            # only +-inf is infinity
-  }
+    my $self = shift;
 
-sub is_one
-  {
-  # return true if arg (BINT or num_str) is +1, or -1 if sign is given
-  my ($self,$x,$sign) = ref($_[0]) ? (undef,@_) : objectify(1,@_);
+    return $self if $self->modify('bsgn');
+
+    return $self -> bone("+") if $self -> is_pos();
+    return $self -> bone("-") if $self -> is_neg();
+    return $self;               # zero or NaN
+}
+
+sub bnorm {
+    # (numstr or BINT) return BINT
+    # Normalize number -- no-op here
+    my ($class, $x) = ref($_[0]) ? (undef, $_[0]) : objectify(1, @_);
+    $x;
+}
 
-  $sign = '+' if !defined $sign || $sign ne '-';
+sub binc {
+    # increment arg by one
+    my ($class, $x, $a, $p, $r) = ref($_[0]) ? (ref($_[0]), @_) : objectify(1, @_);
+    return $x if $x->modify('binc');
+
+    if ($x->{sign} eq '+') {
+        $x->{value} = $CALC->_inc($x->{value});
+        return $x->round($a, $p, $r);
+    } elsif ($x->{sign} eq '-') {
+        $x->{value} = $CALC->_dec($x->{value});
+        $x->{sign} = '+' if $CALC->_is_zero($x->{value}); # -1 +1 => -0 => +0
+        return $x->round($a, $p, $r);
+    }
+    # inf, nan handling etc
+    $x->badd($class->bone(), $a, $p, $r); # badd does round
+}
 
-  return 0 if $x->{sign} ne $sign;      # -1 != +1, NaN, +-inf aren't either
-  $CALC->_is_one($x->{value});
-  }
+sub bdec {
+    # decrement arg by one
+    my ($class, $x, @r) = ref($_[0]) ? (ref($_[0]), @_) : objectify(1, @_);
+    return $x if $x->modify('bdec');
 
-sub is_odd
-  {
-  # return true when arg (BINT or num_str) is odd, false for even
-  my ($self,$x) = ref($_[0]) ? (undef,$_[0]) : objectify(1,@_);
+    if ($x->{sign} eq '-') {
+        # x already < 0
+        $x->{value} = $CALC->_inc($x->{value});
+    } else {
+        return $x->badd($class->bone('-'), @r)
+          unless $x->{sign} eq '+'; # inf or NaN
+        # >= 0
+        if ($CALC->_is_zero($x->{value})) {
+            # == 0
+            $x->{value} = $CALC->_one();
+            $x->{sign} = '-'; # 0 => -1
+        } else {
+            # > 0
+            $x->{value} = $CALC->_dec($x->{value});
+        }
+    }
+    $x->round(@r);
+}
 
-  return 0 if $x->{sign} !~ /^[+-]$/;                   # NaN & +-inf aren't
-  $CALC->_is_odd($x->{value});
-  }
+#sub bstrcmp {
+#    my $self    = shift;
+#    my $selfref = ref $self;
+#    my $class   = $selfref || $self;
+#
+#    Carp::croak 'bstrcmp() is an instance method, not a class method'
+#        unless $selfref;
+#    Carp::croak 'Wrong number of arguments for bstrcmp()' unless @_ == 1;
+#
+#    return $self -> bstr() CORE::cmp shift;
+#}
+#
+#sub bstreq {
+#    my $self    = shift;
+#    my $selfref = ref $self;
+#    my $class   = $selfref || $self;
+#
+#    Carp::croak 'bstreq() is an instance method, not a class method'
+#        unless $selfref;
+#    Carp::croak 'Wrong number of arguments for bstreq()' unless @_ == 1;
+#
+#    my $cmp = $self -> bstrcmp(shift);
+#    return defined($cmp) && ! $cmp;
+#}
+#
+#sub bstrne {
+#    my $self    = shift;
+#    my $selfref = ref $self;
+#    my $class   = $selfref || $self;
+#
+#    Carp::croak 'bstrne() is an instance method, not a class method'
+#        unless $selfref;
+#    Carp::croak 'Wrong number of arguments for bstrne()' unless @_ == 1;
+#
+#    my $cmp = $self -> bstrcmp(shift);
+#    return defined($cmp) && ! $cmp ? '' : 1;
+#}
+#
+#sub bstrlt {
+#    my $self    = shift;
+#    my $selfref = ref $self;
+#    my $class   = $selfref || $self;
+#
+#    Carp::croak 'bstrlt() is an instance method, not a class method'
+#        unless $selfref;
+#    Carp::croak 'Wrong number of arguments for bstrlt()' unless @_ == 1;
+#
+#    my $cmp = $self -> bstrcmp(shift);
+#    return defined($cmp) && $cmp < 0;
+#}
+#
+#sub bstrle {
+#    my $self    = shift;
+#    my $selfref = ref $self;
+#    my $class   = $selfref || $self;
+#
+#    Carp::croak 'bstrle() is an instance method, not a class method'
+#        unless $selfref;
+#    Carp::croak 'Wrong number of arguments for bstrle()' unless @_ == 1;
+#
+#    my $cmp = $self -> bstrcmp(shift);
+#    return defined($cmp) && $cmp <= 0;
+#}
+#
+#sub bstrgt {
+#    my $self    = shift;
+#    my $selfref = ref $self;
+#    my $class   = $selfref || $self;
+#
+#    Carp::croak 'bstrgt() is an instance method, not a class method'
+#        unless $selfref;
+#    Carp::croak 'Wrong number of arguments for bstrgt()' unless @_ == 1;
+#
+#    my $cmp = $self -> bstrcmp(shift);
+#    return defined($cmp) && $cmp > 0;
+#}
+#
+#sub bstrge {
+#    my $self    = shift;
+#    my $selfref = ref $self;
+#    my $class   = $selfref || $self;
+#
+#    Carp::croak 'bstrge() is an instance method, not a class method'
+#        unless $selfref;
+#    Carp::croak 'Wrong number of arguments for bstrge()' unless @_ == 1;
+#
+#    my $cmp = $self -> bstrcmp(shift);
+#    return defined($cmp) && $cmp >= 0;
+#}
 
-sub is_even
-  {
-  # return true when arg (BINT or num_str) is even, false for odd
-  my ($self,$x) = ref($_[0]) ? (undef,$_[0]) : objectify(1,@_);
+sub badd {
+    # add second arg (BINT or string) to first (BINT) (modifies first)
+    # return result as BINT
 
-  return 0 if $x->{sign} !~ /^[+-]$/;                   # NaN & +-inf aren't
-  $CALC->_is_even($x->{value});
-  }
+    # set up parameters
+    my ($class, $x, $y, @r) = (ref($_[0]), @_);
+    # objectify is costly, so avoid it
+    if ((!ref($_[0])) || (ref($_[0]) ne ref($_[1]))) {
+        ($class, $x, $y, @r) = objectify(2, @_);
+    }
+
+    return $x if $x->modify('badd');
+    return $upgrade->badd($upgrade->new($x), $upgrade->new($y), @r) if defined $upgrade &&
+      ((!$x->isa($class)) || (!$y->isa($class)));
+
+    $r[3] = $y;                 # no push!
+    # inf and NaN handling
+    if ($x->{sign} !~ /^[+-]$/ || $y->{sign} !~ /^[+-]$/) {
+        # NaN first
+        return $x->bnan() if (($x->{sign} eq $nan) || ($y->{sign} eq $nan));
+        # inf handling
+        if (($x->{sign} =~ /^[+-]inf$/) && ($y->{sign} =~ /^[+-]inf$/)) {
+            # +inf++inf or -inf+-inf => same, rest is NaN
+            return $x if $x->{sign} eq $y->{sign};
+            return $x->bnan();
+        }
+        # +-inf + something => +inf
+        # something +-inf => +-inf
+        $x->{sign} = $y->{sign}, return $x if $y->{sign} =~ /^[+-]inf$/;
+        return $x;
+    }
 
-sub is_positive
-  {
-  # return true when arg (BINT or num_str) is positive (> 0)
-  my ($self,$x) = ref($_[0]) ? (undef,$_[0]) : objectify(1,@_);
+    my ($sx, $sy) = ($x->{sign}, $y->{sign});  # get signs
 
-  return 1 if $x->{sign} eq '+inf';                     # +inf is positive
+    if ($sx eq $sy) {
+        $x->{value} = $CALC->_add($x->{value}, $y->{value}); # same sign, abs add
+    } else {
+        my $a = $CALC->_acmp ($y->{value}, $x->{value}); # absolute compare
+        if ($a > 0) {
+            $x->{value} = $CALC->_sub($y->{value}, $x->{value}, 1); # abs sub w/ swap
+            $x->{sign} = $sy;
+        } elsif ($a == 0) {
+            # speedup, if equal, set result to 0
+            $x->{value} = $CALC->_zero();
+            $x->{sign} = '+';
+        } else                  # a < 0
+        {
+            $x->{value} = $CALC->_sub($x->{value}, $y->{value}); # abs sub
+        }
+    }
+    $x->round(@r);
+}
 
-  # 0+ is neither positive nor negative
-  ($x->{sign} eq '+' && !$x->is_zero()) ? 1 : 0;
-  }
+sub bsub {
+    # (BINT or num_str, BINT or num_str) return BINT
+    # subtract second arg from first, modify first
 
-sub is_negative
-  {
-  # return true when arg (BINT or num_str) is negative (< 0)
-  my ($self,$x) = ref($_[0]) ? (undef,$_[0]) : objectify(1,@_);
+    # set up parameters
+    my ($class, $x, $y, @r) = (ref($_[0]), @_);
 
-  $x->{sign} =~ /^-/ ? 1 : 0;           # -inf is negative, but NaN is not
-  }
+    # objectify is costly, so avoid it
+    if ((!ref($_[0])) || (ref($_[0]) ne ref($_[1]))) {
+        ($class, $x, $y, @r) = objectify(2, @_);
+    }
 
-sub is_int
-  {
-  # return true when arg (BINT or num_str) is an integer
-  # always true for BigInt, but different for BigFloats
-  my ($self,$x) = ref($_[0]) ? (undef,$_[0]) : objectify(1,@_);
+    return $x if $x -> modify('bsub');
 
-  $x->{sign} =~ /^[+-]$/ ? 1 : 0;               # inf/-inf/NaN aren't
-  }
+    return $upgrade -> new($x) -> bsub($upgrade -> new($y), @r)
+      if defined $upgrade && (!$x -> isa($class) || !$y -> isa($class));
 
-###############################################################################
+    return $x -> round(@r) if $y -> is_zero();
 
-sub bmul
-  {
-  # multiply the first number by the second number
-  # (BINT or num_str, BINT or num_str) return BINT
+    # To correctly handle the lone special case $x -> bsub($x), we note the
+    # sign of $x, then flip the sign from $y, and if the sign of $x did change,
+    # too, then we caught the special case:
 
-  # set up parameters
-  my ($self,$x,$y,@r) = (ref($_[0]),@_);
-  # objectify is costly, so avoid it
-  if ((!ref($_[0])) || (ref($_[0]) ne ref($_[1])))
-    {
-    ($self,$x,$y,@r) = objectify(2,@_);
+    my $xsign = $x -> {sign};
+    $y -> {sign} =~ tr/+-/-+/;  # does nothing for NaN
+    if ($xsign ne $x -> {sign}) {
+        # special case of $x -> bsub($x) results in 0
+        return $x -> bzero(@r) if $xsign =~ /^[+-]$/;
+        return $x -> bnan();    # NaN, -inf, +inf
     }
+    $x -> badd($y, @r);         # badd does not leave internal zeros
+    $y -> {sign} =~ tr/+-/-+/;  # refix $y (does nothing for NaN)
+    $x;                         # already rounded by badd() or no rounding
+}
 
-  return $x if $x->modify('bmul');
+sub bmul {
+    # multiply the first number by the second number
+    # (BINT or num_str, BINT or num_str) return BINT
 
-  return $x->bnan() if (($x->{sign} eq $nan) || ($y->{sign} eq $nan));
+    # set up parameters
+    my ($class, $x, $y, @r) = (ref($_[0]), @_);
+    # objectify is costly, so avoid it
+    if ((!ref($_[0])) || (ref($_[0]) ne ref($_[1]))) {
+        ($class, $x, $y, @r) = objectify(2, @_);
+    }
 
-  # inf handling
-  if (($x->{sign} =~ /^[+-]inf$/) || ($y->{sign} =~ /^[+-]inf$/))
-    {
-    return $x->bnan() if $x->is_zero() || $y->is_zero();
-    # result will always be +-inf:
-    # +inf * +/+inf => +inf, -inf * -/-inf => +inf
-    # +inf * -/-inf => -inf, -inf * +/+inf => -inf
-    return $x->binf() if ($x->{sign} =~ /^\+/ && $y->{sign} =~ /^\+/);
-    return $x->binf() if ($x->{sign} =~ /^-/ && $y->{sign} =~ /^-/);
-    return $x->binf('-');
+    return $x if $x->modify('bmul');
+
+    return $x->bnan() if (($x->{sign} eq $nan) || ($y->{sign} eq $nan));
+
+    # inf handling
+    if (($x->{sign} =~ /^[+-]inf$/) || ($y->{sign} =~ /^[+-]inf$/)) {
+        return $x->bnan() if $x->is_zero() || $y->is_zero();
+        # result will always be +-inf:
+        # +inf * +/+inf => +inf, -inf * -/-inf => +inf
+        # +inf * -/-inf => -inf, -inf * +/+inf => -inf
+        return $x->binf() if ($x->{sign} =~ /^\+/ && $y->{sign} =~ /^\+/);
+        return $x->binf() if ($x->{sign} =~ /^-/ && $y->{sign} =~ /^-/);
+        return $x->binf('-');
     }
 
-  return $upgrade->bmul($x,$upgrade->new($y),@r)
-   if defined $upgrade && !$y->isa($self);
+    return $upgrade->bmul($x, $upgrade->new($y), @r)
+      if defined $upgrade && !$y->isa($class);
 
-  $r[3] = $y;                           # no push here
+    $r[3] = $y;                 # no push here
 
-  $x->{sign} = $x->{sign} eq $y->{sign} ? '+' : '-'; # +1 * +1 or -1 * -1 => +
+    $x->{sign} = $x->{sign} eq $y->{sign} ? '+' : '-'; # +1 * +1 or -1 * -1 => +
 
-  $x->{value} = $CALC->_mul($x->{value},$y->{value});   # do actual math
-  $x->{sign} = '+' if $CALC->_is_zero($x->{value});     # no -0
+    $x->{value} = $CALC->_mul($x->{value}, $y->{value}); # do actual math
+    $x->{sign} = '+' if $CALC->_is_zero($x->{value});   # no -0
 
-  $x->round(@r);
-  }
+    $x->round(@r);
+}
 
-sub bmuladd
-  {
-  # multiply two numbers and then add the third to the result
-  # (BINT or num_str, BINT or num_str, BINT or num_str) return BINT
+sub bmuladd {
+    # multiply two numbers and then add the third to the result
+    # (BINT or num_str, BINT or num_str, BINT or num_str) return BINT
 
-  # set up parameters
-  my ($self,$x,$y,$z,@r) = objectify(3,@_);
+    # set up parameters
+    my ($class, $x, $y, $z, @r) = objectify(3, @_);
 
-  return $x if $x->modify('bmuladd');
+    return $x if $x->modify('bmuladd');
 
-  return $x->bnan() if  ($x->{sign} eq $nan) ||
-                        ($y->{sign} eq $nan) ||
-                        ($z->{sign} eq $nan);
+    return $x->bnan() if (($x->{sign} eq $nan) ||
+                          ($y->{sign} eq $nan) ||
+                          ($z->{sign} eq $nan));
 
-  # inf handling of x and y
-  if (($x->{sign} =~ /^[+-]inf$/) || ($y->{sign} =~ /^[+-]inf$/))
-    {
-    return $x->bnan() if $x->is_zero() || $y->is_zero();
-    # result will always be +-inf:
-    # +inf * +/+inf => +inf, -inf * -/-inf => +inf
-    # +inf * -/-inf => -inf, -inf * +/+inf => -inf
-    return $x->binf() if ($x->{sign} =~ /^\+/ && $y->{sign} =~ /^\+/);
-    return $x->binf() if ($x->{sign} =~ /^-/ && $y->{sign} =~ /^-/);
-    return $x->binf('-');
-    }
-  # inf handling x*y and z
-  if (($z->{sign} =~ /^[+-]inf$/))
-    {
-    # something +-inf => +-inf
-    $x->{sign} = $z->{sign}, return $x if $z->{sign} =~ /^[+-]inf$/;
+    # inf handling of x and y
+    if (($x->{sign} =~ /^[+-]inf$/) || ($y->{sign} =~ /^[+-]inf$/)) {
+        return $x->bnan() if $x->is_zero() || $y->is_zero();
+        # result will always be +-inf:
+        # +inf * +/+inf => +inf, -inf * -/-inf => +inf
+        # +inf * -/-inf => -inf, -inf * +/+inf => -inf
+        return $x->binf() if ($x->{sign} =~ /^\+/ && $y->{sign} =~ /^\+/);
+        return $x->binf() if ($x->{sign} =~ /^-/ && $y->{sign} =~ /^-/);
+        return $x->binf('-');
+    }
+    # inf handling x*y and z
+    if (($z->{sign} =~ /^[+-]inf$/)) {
+        # something +-inf => +-inf
+        $x->{sign} = $z->{sign}, return $x if $z->{sign} =~ /^[+-]inf$/;
     }
 
-  return $upgrade->bmuladd($x,$upgrade->new($y),$upgrade->new($z),@r)
-   if defined $upgrade && (!$y->isa($self) || !$z->isa($self) || !$x->isa($self));
+    return $upgrade->bmuladd($x, $upgrade->new($y), $upgrade->new($z), @r)
+      if defined $upgrade && (!$y->isa($class) || !$z->isa($class) || !$x->isa($class));
 
-  # TODO: what if $y and $z have A or P set?
-  $r[3] = $z;                           # no push here
+    # TODO: what if $y and $z have A or P set?
+    $r[3] = $z;                 # no push here
 
-  $x->{sign} = $x->{sign} eq $y->{sign} ? '+' : '-'; # +1 * +1 or -1 * -1 => +
+    $x->{sign} = $x->{sign} eq $y->{sign} ? '+' : '-'; # +1 * +1 or -1 * -1 => +
 
-  $x->{value} = $CALC->_mul($x->{value},$y->{value});   # do actual math
-  $x->{sign} = '+' if $CALC->_is_zero($x->{value});     # no -0
+    $x->{value} = $CALC->_mul($x->{value}, $y->{value}); # do actual math
+    $x->{sign} = '+' if $CALC->_is_zero($x->{value});   # no -0
 
-  my ($sx, $sz) = ( $x->{sign}, $z->{sign} );           # get signs
+    my ($sx, $sz) = ( $x->{sign}, $z->{sign} ); # get signs
 
-  if ($sx eq $sz)
-    {
-    $x->{value} = $CALC->_add($x->{value},$z->{value}); # same sign, abs add
+    if ($sx eq $sz) {
+        $x->{value} = $CALC->_add($x->{value}, $z->{value}); # same sign, abs add
+    } else {
+        my $a = $CALC->_acmp ($z->{value}, $x->{value}); # absolute compare
+        if ($a > 0) {
+            $x->{value} = $CALC->_sub($z->{value}, $x->{value}, 1); # abs sub w/ swap
+            $x->{sign} = $sz;
+        } elsif ($a == 0) {
+            # speedup, if equal, set result to 0
+            $x->{value} = $CALC->_zero();
+            $x->{sign} = '+';
+        } else                  # a < 0
+        {
+            $x->{value} = $CALC->_sub($x->{value}, $z->{value}); # abs sub
+        }
     }
-  else
-    {
-    my $a = $CALC->_acmp ($z->{value},$x->{value});     # absolute compare
-    if ($a > 0)
-      {
-      $x->{value} = $CALC->_sub($z->{value},$x->{value},1); # abs sub w/ swap
-      $x->{sign} = $sz;
-      }
-    elsif ($a == 0)
-      {
-      # speedup, if equal, set result to 0
-      $x->{value} = $CALC->_zero();
-      $x->{sign} = '+';
-      }
-    else # a < 0
-      {
-      $x->{value} = $CALC->_sub($x->{value}, $z->{value}); # abs sub
-      }
-    }
-  $x->round(@r);
-  }
-
-sub bdiv
-  {
-
-    # This does floored division, where the quotient is floored toward negative
-    # infinity and the remainder has the same sign as the divisor.
+    $x->round(@r);
+}
+
+sub bdiv {
+    # This does floored division, where the quotient is floored, i.e., rounded
+    # towards negative infinity. As a consequence, the remainder has the same
+    # sign as the divisor.
 
     # Set up parameters.
-    my ($self,$x,$y,@r) = (ref($_[0]),@_);
+    my ($class, $x, $y, @r) = (ref($_[0]), @_);
 
     # objectify() is costly, so avoid it if we can.
     if ((!ref($_[0])) || (ref($_[0]) ne ref($_[1]))) {
-        ($self,$x,$y,@r) = objectify(2,@_);
+        ($class, $x, $y, @r) = objectify(2, @_);
     }
 
-    return $x if $x->modify('bdiv');
+    return $x if $x -> modify('bdiv');
 
     my $wantarray = wantarray;          # call only once
 
@@ -1732,7 +1665,7 @@ sub bdiv
     # modulo/remainder.
 
     if ($x -> is_nan() || $y -> is_nan()) {
-        return $wantarray ? ($x -> bnan(), $self -> bnan()) : $x -> bnan();
+        return $wantarray ? ($x -> bnan(), $class -> bnan()) : $x -> bnan();
     }
 
     # Divide by zero and modulo zero.
@@ -1746,23 +1679,23 @@ sub bdiv
     # get z - x = 0 or z = x. This is also what earlier versions did, except
     # that 0 % 0 returned NaN.
     #
-    #     inf / 0 =  inf                     inf % 0 =  inf
-    #       5 / 0 =  inf                       5 % 0 =    5
-    #       0 / 0 =  NaN                       0 % 0 =    0 (before: NaN)
-    #      -5 / 0 = -inf                      -5 % 0 =   -5
-    #    -inf / 0 = -inf                    -inf % 0 = -inf
+    #     inf /    0 =  inf                  inf %    0 =  inf
+    #       5 /    0 =  inf                    5 %    0 =    5
+    #       0 /    0 =  NaN                    0 %    0 =    0
+    #      -5 /    0 = -inf                   -5 %    0 =   -5
+    #    -inf /    0 = -inf                 -inf %    0 = -inf
 
     if ($y -> is_zero()) {
-        my ($quo, $rem);
+        my $rem;
         if ($wantarray) {
-                $rem = $x -> copy();
-            }
+            $rem = $x -> copy();
+        }
         if ($x -> is_zero()) {
-            $quo = $x -> bnan();
+            $x -> bnan();
         } else {
-            $quo = $x -> binf($x -> {sign});
+            $x -> binf($x -> {sign});
         }
-        return $wantarray ? ($quo, $rem) : $quo;
+        return $wantarray ? ($x, $rem) : $x;
     }
 
     # Numerator (dividend) is +/-inf, and denominator is finite and non-zero.
@@ -1770,25 +1703,25 @@ sub bdiv
     # below we return the same as core Perl.
     #
     #     inf / -inf =  NaN                  inf % -inf =  NaN
-    #     inf /   -5 = -inf                  inf %   -5 =  NaN (before: 0)
-    #     inf /    5 =  inf                  inf %    5 =  NaN (before: 0)
+    #     inf /   -5 = -inf                  inf %   -5 =  NaN
+    #     inf /    5 =  inf                  inf %    5 =  NaN
     #     inf /  inf =  NaN                  inf %  inf =  NaN
     #
     #    -inf / -inf =  NaN                 -inf % -inf =  NaN
-    #    -inf /   -5 =  inf                 -inf %   -5 =  NaN (before: 0)
-    #    -inf /    5 = -inf                 -inf %    5 =  NaN (before: 0)
+    #    -inf /   -5 =  inf                 -inf %   -5 =  NaN
+    #    -inf /    5 = -inf                 -inf %    5 =  NaN
     #    -inf /  inf =  NaN                 -inf %  inf =  NaN
 
     if ($x -> is_inf()) {
-        my ($quo, $rem);
-        $rem = $self -> bnan() if $wantarray;
+        my $rem;
+        $rem = $class -> bnan() if $wantarray;
         if ($y -> is_inf()) {
-            $quo = $x -> bnan();
+            $x -> bnan();
         } else {
             my $sign = $x -> bcmp(0) == $y -> bcmp(0) ? '+' : '-';
-            $quo = $x -> binf($sign);
-      }
-        return $wantarray ? ($quo, $rem) : $quo;
+            $x -> binf($sign);
+        }
+        return $wantarray ? ($x, $rem) : $x;
     }
 
     # Denominator (divisor) is +/-inf. The cases when the numerator is +/-inf
@@ -1796,112 +1729,249 @@ sub bdiv
     # the same as core Perl, which does floored division, so for consistency we
     # also do floored division in the division cases (in the left column).
     #
-    #      -5 /  inf =   -1 (before: 0)       -5 %  inf =  inf (before: -5)
+    #      -5 /  inf =   -1                   -5 %  inf =  inf
     #       0 /  inf =    0                    0 %  inf =    0
     #       5 /  inf =    0                    5 %  inf =    5
     #
     #      -5 / -inf =    0                   -5 % -inf =   -5
     #       0 / -inf =    0                    0 % -inf =    0
-    #       5 / -inf =   -1 (before: 0)        5 % -inf = -inf (before: 5)
+    #       5 / -inf =   -1                    5 % -inf = -inf
 
     if ($y -> is_inf()) {
-        my ($quo, $rem);
+        my $rem;
         if ($x -> is_zero() || $x -> bcmp(0) == $y -> bcmp(0)) {
             $rem = $x -> copy() if $wantarray;
-            $quo = $x -> bzero();
+            $x -> bzero();
         } else {
-            $rem = $self -> binf($y -> {sign}) if $wantarray;
-            $quo = $x -> bone('-');
+            $rem = $class -> binf($y -> {sign}) if $wantarray;
+            $x -> bone('-');
         }
-        return $wantarray ? ($quo, $rem) : $quo;
-  }
+        return $wantarray ? ($x, $rem) : $x;
+    }
 
-  # At this point, both the numerator and denominator are finite numbers, and
-  # the denominator (divisor) is non-zero.
+    # At this point, both the numerator and denominator are finite numbers, and
+    # the denominator (divisor) is non-zero.
 
-  return $upgrade->bdiv($upgrade->new($x),$upgrade->new($y),@r)
-   if defined $upgrade;
+    return $upgrade -> bdiv($upgrade -> new($x), $upgrade -> new($y), @r)
+      if defined $upgrade;
 
-  $r[3] = $y;                                   # no push!
+    $r[3] = $y;                                   # no push!
 
     # Inialize remainder.
 
-    my $rem = $self->bzero();
+    my $rem = $class -> bzero();
 
-    # Are both operands the same object, i.e., like $x -> bdiv($x)?
-    # If so, flipping the sign of $y also flips the sign of $x.
+    # Are both operands the same object, i.e., like $x -> bdiv($x)? If so,
+    # flipping the sign of $y also flips the sign of $x.
 
-    my $xsign = $x->{sign};
-    my $ysign = $y->{sign};
+    my $xsign = $x -> {sign};
+    my $ysign = $y -> {sign};
 
-    $y->{sign} =~ tr/+-/-+/;            # Flip the sign of $y, and see ...
-    my $same = $xsign ne $x->{sign};    # ... if that changed the sign of $x.
-    $y->{sign} = $ysign;                # Re-insert the original sign.
+    $y -> {sign} =~ tr/+-/-+/;            # Flip the sign of $y, and see ...
+    my $same = $xsign ne $x -> {sign};    # ... if that changed the sign of $x.
+    $y -> {sign} = $ysign;                # Re-insert the original sign.
 
     if ($same) {
         $x -> bone();
     } else {
-    ($x->{value},$rem->{value}) = $CALC->_div($x->{value},$y->{value});
+        ($x -> {value}, $rem -> {value}) =
+          $CALC -> _div($x -> {value}, $y -> {value});
 
-        if ($CALC -> _is_zero($rem->{value})) {
-            if ($xsign eq $ysign || $CALC -> _is_zero($x->{value})) {
-                $x->{sign} = '+';
+        if ($CALC -> _is_zero($rem -> {value})) {
+            if ($xsign eq $ysign || $CALC -> _is_zero($x -> {value})) {
+                $x -> {sign} = '+';
             } else {
-                $x->{sign} = '-';
+                $x -> {sign} = '-';
             }
         } else {
             if ($xsign eq $ysign) {
-                $x->{sign} = '+';
+                $x -> {sign} = '+';
             } else {
                 if ($xsign eq '+') {
                     $x -> badd(1);
                 } else {
                     $x -> bsub(1);
                 }
-                $x->{sign} = '-';
+                $x -> {sign} = '-';
             }
         }
     }
 
-    $x->round(@r);
+    $x -> round(@r);
 
     if ($wantarray) {
-        unless ($CALC -> _is_zero($rem->{value})) {
+        unless ($CALC -> _is_zero($rem -> {value})) {
             if ($xsign ne $ysign) {
                 $rem = $y -> copy() -> babs() -> bsub($rem);
-      }
-            $rem->{sign} = $ysign;
-      }
-        $rem->{_a} = $x->{_a};
-        $rem->{_p} = $x->{_p};
-    $rem->round(@r);
-    return ($x,$rem);
+            }
+            $rem -> {sign} = $ysign;
+        }
+        $rem -> {_a} = $x -> {_a};
+        $rem -> {_p} = $x -> {_p};
+        $rem -> round(@r);
+        return ($x, $rem);
     }
 
     return $x;
-  }
+}
 
-###############################################################################
-# modulus functions
+sub btdiv {
+    # This does truncated division, where the quotient is truncted, i.e.,
+    # rounded towards zero.
+    #
+    # ($q, $r) = $x -> btdiv($y) returns $q and $r so that $q is int($x / $y)
+    # and $q * $y + $r = $x.
+
+    # Set up parameters
+    my ($class, $x, $y, @r) = (ref($_[0]), @_);
+
+    # objectify is costly, so avoid it if we can.
+    if ((!ref($_[0])) || (ref($_[0]) ne ref($_[1]))) {
+        ($class, $x, $y, @r) = objectify(2, @_);
+    }
+
+    return $x if $x -> modify('btdiv');
+
+    my $wantarray = wantarray;          # call only once
+
+    # At least one argument is NaN. Return NaN for both quotient and the
+    # modulo/remainder.
+
+    if ($x -> is_nan() || $y -> is_nan()) {
+        return $wantarray ? ($x -> bnan(), $class -> bnan()) : $x -> bnan();
+    }
+
+    # Divide by zero and modulo zero.
+    #
+    # Division: Use the common convention that x / 0 is inf with the same sign
+    # as x, except when x = 0, where we return NaN. This is also what earlier
+    # versions did.
+    #
+    # Modulo: In modular arithmetic, the congruence relation z = x (mod y)
+    # means that there is some integer k such that z - x = k y. If y = 0, we
+    # get z - x = 0 or z = x. This is also what earlier versions did, except
+    # that 0 % 0 returned NaN.
+    #
+    #     inf / 0 =  inf                     inf % 0 =  inf
+    #       5 / 0 =  inf                       5 % 0 =    5
+    #       0 / 0 =  NaN                       0 % 0 =    0
+    #      -5 / 0 = -inf                      -5 % 0 =   -5
+    #    -inf / 0 = -inf                    -inf % 0 = -inf
+
+    if ($y -> is_zero()) {
+        my $rem;
+        if ($wantarray) {
+            $rem = $x -> copy();
+        }
+        if ($x -> is_zero()) {
+            $x -> bnan();
+        } else {
+            $x -> binf($x -> {sign});
+        }
+        return $wantarray ? ($x, $rem) : $x;
+    }
 
-sub bmod
-  {
+    # Numerator (dividend) is +/-inf, and denominator is finite and non-zero.
+    # The divide by zero cases are covered above. In all of the cases listed
+    # below we return the same as core Perl.
+    #
+    #     inf / -inf =  NaN                  inf % -inf =  NaN
+    #     inf /   -5 = -inf                  inf %   -5 =  NaN
+    #     inf /    5 =  inf                  inf %    5 =  NaN
+    #     inf /  inf =  NaN                  inf %  inf =  NaN
+    #
+    #    -inf / -inf =  NaN                 -inf % -inf =  NaN
+    #    -inf /   -5 =  inf                 -inf %   -5 =  NaN
+    #    -inf /    5 = -inf                 -inf %    5 =  NaN
+    #    -inf /  inf =  NaN                 -inf %  inf =  NaN
 
-    # This is the remainder after floored division, where the quotient is
-    # floored toward negative infinity and the remainder has the same sign as
-    # the divisor.
+    if ($x -> is_inf()) {
+        my $rem;
+        $rem = $class -> bnan() if $wantarray;
+        if ($y -> is_inf()) {
+            $x -> bnan();
+        } else {
+            my $sign = $x -> bcmp(0) == $y -> bcmp(0) ? '+' : '-';
+            $x -> binf($sign);
+        }
+        return $wantarray ? ($x, $rem) : $x;
+    }
+
+    # Denominator (divisor) is +/-inf. The cases when the numerator is +/-inf
+    # are covered above. In the modulo cases (in the right column) we return
+    # the same as core Perl, which does floored division, so for consistency we
+    # also do floored division in the division cases (in the left column).
+    #
+    #      -5 /  inf =    0                   -5 %  inf =  -5
+    #       0 /  inf =    0                    0 %  inf =   0
+    #       5 /  inf =    0                    5 %  inf =   5
+    #
+    #      -5 / -inf =    0                   -5 % -inf =  -5
+    #       0 / -inf =    0                    0 % -inf =   0
+    #       5 / -inf =    0                    5 % -inf =   5
+
+    if ($y -> is_inf()) {
+        my $rem;
+        $rem = $x -> copy() if $wantarray;
+        $x -> bzero();
+        return $wantarray ? ($x, $rem) : $x;
+    }
+
+    return $upgrade -> btdiv($upgrade -> new($x), $upgrade -> new($y), @r)
+      if defined $upgrade;
+
+    $r[3] = $y;                 # no push!
+
+    # Inialize remainder.
+
+    my $rem = $class -> bzero();
+
+    # Are both operands the same object, i.e., like $x -> bdiv($x)? If so,
+    # flipping the sign of $y also flips the sign of $x.
+
+    my $xsign = $x -> {sign};
+    my $ysign = $y -> {sign};
+
+    $y -> {sign} =~ tr/+-/-+/;            # Flip the sign of $y, and see ...
+    my $same = $xsign ne $x -> {sign};    # ... if that changed the sign of $x.
+    $y -> {sign} = $ysign;                # Re-insert the original sign.
+
+    if ($same) {
+        $x -> bone();
+    } else {
+        ($x -> {value}, $rem -> {value}) =
+          $CALC -> _div($x -> {value}, $y -> {value});
+
+        $x -> {sign} = $xsign eq $ysign ? '+' : '-';
+        $x -> {sign} = '+' if $CALC -> _is_zero($x -> {value});
+        $x -> round(@r);
+    }
+
+    if (wantarray) {
+        $rem -> {sign} = $xsign;
+        $rem -> {sign} = '+' if $CALC -> _is_zero($rem -> {value});
+        $rem -> {_a} = $x -> {_a};
+        $rem -> {_p} = $x -> {_p};
+        $rem -> round(@r);
+        return ($x, $rem);
+    }
+
+    return $x;
+}
+
+sub bmod {
+    # This is the remainder after floored division.
 
     # Set up parameters.
-  my ($self,$x,$y,@r) = (ref($_[0]),@_);
+    my ($class, $x, $y, @r) = (ref($_[0]), @_);
 
-  # objectify is costly, so avoid it
-  if ((!ref($_[0])) || (ref($_[0]) ne ref($_[1])))
-    {
-    ($self,$x,$y,@r) = objectify(2,@_);
+    # objectify is costly, so avoid it
+    if ((!ref($_[0])) || (ref($_[0]) ne ref($_[1]))) {
+        ($class, $x, $y, @r) = objectify(2, @_);
     }
 
-  return $x if $x->modify('bmod');
-  $r[3] = $y;                                   # no push!
+    return $x if $x -> modify('bmod');
+    $r[3] = $y;                 # no push!
 
     # At least one argument is NaN.
 
@@ -1912,8 +1982,8 @@ sub bmod
     # Modulo zero. See documentation for bdiv().
 
     if ($y -> is_zero()) {
-            return $x;
-        }
+        return $x;
+    }
 
     # Numerator (dividend) is +/-inf.
 
@@ -1933,839 +2003,1486 @@ sub bmod
 
     # Calc new sign and in case $y == +/- 1, return $x.
 
-  $x->{value} = $CALC->_mod($x->{value},$y->{value});
-  if ($CALC -> _is_zero($x->{value}))
-    {
-        $x->{sign} = '+';       # do not leave -0
-    }
-  else
-    {
-    $x->{value} = $CALC->_sub($y->{value},$x->{value},1)        # $y-$x
-      if ($x->{sign} ne $y->{sign});
-    $x->{sign} = $y->{sign};
-    }
-
-  $x->round(@r);
-  }
-
-sub bmodinv
-  {
-  # Return modular multiplicative inverse:
-  #
-  #   z is the modular inverse of x (mod y) if and only if
-  #
-  #       x*z ≡ 1  (mod y)
-  #
-  # If the modulus y is larger than one, x and z are relative primes (i.e.,
-  # their greatest common divisor is one).
-  #
-  # If no modular multiplicative inverse exists, NaN is returned.
-
-  # set up parameters
-  my ($self,$x,$y,@r) = (undef,@_);
-  # objectify is costly, so avoid it
-  if ((!ref($_[0])) || (ref($_[0]) ne ref($_[1])))
-    {
-    ($self,$x,$y,@r) = objectify(2,@_);
+    $x -> {value} = $CALC -> _mod($x -> {value}, $y -> {value});
+    if ($CALC -> _is_zero($x -> {value})) {
+        $x -> {sign} = '+';     # do not leave -0
+    } else {
+        $x -> {value} = $CALC -> _sub($y -> {value}, $x -> {value}, 1) # $y-$x
+          if ($x -> {sign} ne $y -> {sign});
+        $x -> {sign} = $y -> {sign};
     }
 
-  return $x if $x->modify('bmodinv');
+    $x -> round(@r);
+}
 
-  # Return NaN if one or both arguments is +inf, -inf, or nan.
+sub btmod {
+    # Remainder after truncated division.
 
-  return $x->bnan() if ($y->{sign} !~ /^[+-]$/ ||
-                        $x->{sign} !~ /^[+-]$/);
+    # set up parameters
+    my ($class, $x, $y, @r) = (ref($_[0]), @_);
 
-  # Return NaN if $y is zero; 1 % 0 makes no sense.
+    # objectify is costly, so avoid it
+    if ((!ref($_[0])) || (ref($_[0]) ne ref($_[1]))) {
+        ($class, $x, $y, @r) = objectify(2, @_);
+    }
 
-  return $x->bnan() if $y->is_zero();
+    return $x if $x -> modify('btmod');
 
-  # Return 0 in the trivial case. $x % 1 or $x % -1 is zero for all finite
-  # integers $x.
+    # At least one argument is NaN.
 
-  return $x->bzero() if ($y->is_one() ||
-                         $y->is_one('-'));
+    if ($x -> is_nan() || $y -> is_nan()) {
+        return $x -> bnan();
+    }
 
-  # Return NaN if $x = 0, or $x modulo $y is zero. The only valid case when
-  # $x = 0 is when $y = 1 or $y = -1, but that was covered above.
-  #
-  # Note that computing $x modulo $y here affects the value we'll feed to
-  # $CALC->_modinv() below when $x and $y have opposite signs. E.g., if $x =
-  # 5 and $y = 7, those two values are fed to _modinv(), but if $x = -5 and
-  # $y = 7, the values fed to _modinv() are $x = 2 (= -5 % 7) and $y = 7.
-  # The value if $x is affected only when $x and $y have opposite signs.
+    # Modulo zero. See documentation for btdiv().
 
-  $x->bmod($y);
-  return $x->bnan() if $x->is_zero();
+    if ($y -> is_zero()) {
+        return $x;
+    }
 
-  # Compute the modular multiplicative inverse of the absolute values. We'll
-  # correct for the signs of $x and $y later. Return NaN if no GCD is found.
+    # Numerator (dividend) is +/-inf.
 
-  ($x->{value}, $x->{sign}) = $CALC->_modinv($x->{value}, $y->{value});
-  return $x->bnan() if !defined $x->{value};
+    if ($x -> is_inf()) {
+        return $x -> bnan();
+    }
 
-  # Library inconsistency workaround: _modinv() in Math::BigInt::GMP versions
-  # <= 1.32 return undef rather than a "+" for the sign.
+    # Denominator (divisor) is +/-inf.
 
-  $x->{sign} = '+' unless defined $x->{sign};
+    if ($y -> is_inf()) {
+        return $x;
+    }
 
-  # When one or both arguments are negative, we have the following
-  # relations.  If x and y are positive:
-  #
-  #   modinv(-x, -y) = -modinv(x, y)
-  #   modinv(-x,  y) = y - modinv(x, y)  = -modinv(x, y) (mod y)
-  #   modinv( x, -y) = modinv(x, y) - y  =  modinv(x, y) (mod -y)
+    return $upgrade -> btmod($upgrade -> new($x), $upgrade -> new($y), @r)
+      if defined $upgrade;
 
-  # We must swap the sign of the result if the original $x is negative.
-  # However, we must compensate for ignoring the signs when computing the
-  # inverse modulo. The net effect is that we must swap the sign of the
-  # result if $y is negative.
+    $r[3] = $y;                 # no push!
 
-  $x -> bneg() if $y->{sign} eq '-';
+    my $xsign = $x -> {sign};
+    my $ysign = $y -> {sign};
 
-  # Compute $x modulo $y again after correcting the sign.
+    $x -> {value} = $CALC -> _mod($x -> {value}, $y -> {value});
 
-  $x -> bmod($y) if $x->{sign} ne $y->{sign};
+    $x -> {sign} = $xsign;
+    $x -> {sign} = '+' if $CALC -> _is_zero($x -> {value});
+    $x -> round(@r);
+    return $x;
+}
 
-  return $x;
-  }
+sub bmodinv {
+    # Return modular multiplicative inverse:
+    #
+    #   z is the modular inverse of x (mod y) if and only if
+    #
+    #       x*z ≡ 1  (mod y)
+    #
+    # If the modulus y is larger than one, x and z are relative primes (i.e.,
+    # their greatest common divisor is one).
+    #
+    # If no modular multiplicative inverse exists, NaN is returned.
 
-sub bmodpow
-  {
-  # Modular exponentiation. Raises a very large number to a very large exponent
-  # in a given very large modulus quickly, thanks to binary exponentiation.
-  # Supports negative exponents.
-  my ($self,$num,$exp,$mod,@r) = objectify(3,@_);
+    # set up parameters
+    my ($class, $x, $y, @r) = (undef, @_);
+    # objectify is costly, so avoid it
+    if ((!ref($_[0])) || (ref($_[0]) ne ref($_[1]))) {
+        ($class, $x, $y, @r) = objectify(2, @_);
+    }
 
-  return $num if $num->modify('bmodpow');
+    return $x if $x->modify('bmodinv');
 
-  # When the exponent 'e' is negative, use the following relation, which is
-  # based on finding the multiplicative inverse 'd' of 'b' modulo 'm':
-  #
-  #    b^(-e) (mod m) = d^e (mod m) where b*d = 1 (mod m)
+    # Return NaN if one or both arguments is +inf, -inf, or nan.
 
-  $num->bmodinv($mod) if ($exp->{sign} eq '-');
+    return $x->bnan() if ($y->{sign} !~ /^[+-]$/ ||
+                          $x->{sign} !~ /^[+-]$/);
 
-  # Check for valid input. All operands must be finite, and the modulus must be
-  # non-zero.
+    # Return NaN if $y is zero; 1 % 0 makes no sense.
 
-  return $num->bnan() if ($num->{sign} =~ /NaN|inf/ ||  # NaN, -inf, +inf
-                          $exp->{sign} =~ /NaN|inf/ ||  # NaN, -inf, +inf
-                          $mod->{sign} =~ /NaN|inf/);   # NaN, -inf, +inf
+    return $x->bnan() if $y->is_zero();
 
-  # Modulo zero. See documentation for Math::BigInt's bmod() method.
+    # Return 0 in the trivial case. $x % 1 or $x % -1 is zero for all finite
+    # integers $x.
 
-  if ($mod -> is_zero()) {
-      if ($num -> is_zero()) {
-          return $self -> bnan();
-      } else {
-          return $num -> copy();
-      }
-  }
+    return $x->bzero() if ($y->is_one() ||
+                           $y->is_one('-'));
 
-  # Compute 'a (mod m)', ignoring the signs on 'a' and 'm'. If the resulting
-  # value is zero, the output is also zero, regardless of the signs on 'a' and
-  # 'm'.
+    # Return NaN if $x = 0, or $x modulo $y is zero. The only valid case when
+    # $x = 0 is when $y = 1 or $y = -1, but that was covered above.
+    #
+    # Note that computing $x modulo $y here affects the value we'll feed to
+    # $CALC->_modinv() below when $x and $y have opposite signs. E.g., if $x =
+    # 5 and $y = 7, those two values are fed to _modinv(), but if $x = -5 and
+    # $y = 7, the values fed to _modinv() are $x = 2 (= -5 % 7) and $y = 7.
+    # The value if $x is affected only when $x and $y have opposite signs.
 
-  my $value = $CALC->_modpow($num->{value}, $exp->{value}, $mod->{value});
-  my $sign  = '+';
+    $x->bmod($y);
+    return $x->bnan() if $x->is_zero();
 
-  # If the resulting value is non-zero, we have four special cases, depending
-  # on the signs on 'a' and 'm'.
+    # Compute the modular multiplicative inverse of the absolute values. We'll
+    # correct for the signs of $x and $y later. Return NaN if no GCD is found.
 
-  unless ($CALC->_is_zero($value)) {
+    ($x->{value}, $x->{sign}) = $CALC->_modinv($x->{value}, $y->{value});
+    return $x->bnan() if !defined $x->{value};
 
-      # There is a negative sign on 'a' (= $num**$exp) only if the number we
-      # are exponentiating ($num) is negative and the exponent ($exp) is odd.
+    # Library inconsistency workaround: _modinv() in Math::BigInt::GMP versions
+    # <= 1.32 return undef rather than a "+" for the sign.
 
-      if ($num->{sign} eq '-' && $exp->is_odd()) {
+    $x->{sign} = '+' unless defined $x->{sign};
 
-          # When both the number 'a' and the modulus 'm' have a negative sign,
-          # use this relation:
-          #
-          #    -a (mod -m) = -(a (mod m))
+    # When one or both arguments are negative, we have the following
+    # relations.  If x and y are positive:
+    #
+    #   modinv(-x, -y) = -modinv(x, y)
+    #   modinv(-x, y) = y - modinv(x, y)  = -modinv(x, y) (mod y)
+    #   modinv( x, -y) = modinv(x, y) - y  =  modinv(x, y) (mod -y)
 
-          if ($mod->{sign} eq '-') {
-              $sign = '-';
-          }
+    # We must swap the sign of the result if the original $x is negative.
+    # However, we must compensate for ignoring the signs when computing the
+    # inverse modulo. The net effect is that we must swap the sign of the
+    # result if $y is negative.
 
-          # When only the number 'a' has a negative sign, use this relation:
-          #
-          #    -a (mod m) = m - (a (mod m))
+    $x -> bneg() if $y->{sign} eq '-';
 
-          else {
-              # Use copy of $mod since _sub() modifies the first argument.
-              my $mod = $CALC->_copy($mod->{value});
-              $value = $CALC->_sub($mod, $value);
-              $sign  = '+';
-          }
+    # Compute $x modulo $y again after correcting the sign.
 
-      } else {
+    $x -> bmod($y) if $x->{sign} ne $y->{sign};
 
-          # When only the modulus 'm' has a negative sign, use this relation:
-          #
-          #    a (mod -m) = (a (mod m)) - m
-          #               = -(m - (a (mod m)))
+    return $x;
+}
 
-          if ($mod->{sign} eq '-') {
-              # Use copy of $mod since _sub() modifies the first argument.
-              my $mod = $CALC->_copy($mod->{value});
-              $value = $CALC->_sub($mod, $value);
-              $sign  = '-';
-          }
+sub bmodpow {
+    # Modular exponentiation. Raises a very large number to a very large exponent
+    # in a given very large modulus quickly, thanks to binary exponentiation.
+    # Supports negative exponents.
+    my ($class, $num, $exp, $mod, @r) = objectify(3, @_);
 
-          # When neither the number 'a' nor the modulus 'm' have a negative
-          # sign, directly return the already computed value.
-          #
-          #    (a (mod m))
+    return $num if $num->modify('bmodpow');
 
-      }
+    # When the exponent 'e' is negative, use the following relation, which is
+    # based on finding the multiplicative inverse 'd' of 'b' modulo 'm':
+    #
+    #    b^(-e) (mod m) = d^e (mod m) where b*d = 1 (mod m)
 
-  }
+    $num->bmodinv($mod) if ($exp->{sign} eq '-');
 
-  $num->{value} = $value;
-  $num->{sign}  = $sign;
+    # Check for valid input. All operands must be finite, and the modulus must be
+    # non-zero.
 
-  return $num;
-  }
+    return $num->bnan() if ($num->{sign} =~ /NaN|inf/ || # NaN, -inf, +inf
+                            $exp->{sign} =~ /NaN|inf/ || # NaN, -inf, +inf
+                            $mod->{sign} =~ /NaN|inf/);  # NaN, -inf, +inf
 
-###############################################################################
+    # Modulo zero. See documentation for Math::BigInt's bmod() method.
 
-sub bfac
-  {
-  # (BINT or num_str, BINT or num_str) return BINT
-  # compute factorial number from $x, modify $x in place
-  my ($self,$x,@r) = ref($_[0]) ? (undef,@_) : objectify(1,@_);
-
-  return $x if $x->modify('bfac') || $x->{sign} eq '+inf';      # inf => inf
-  return $x->bnan() if $x->{sign} ne '+';                       # NaN, <0 etc => NaN
-
-  $x->{value} = $CALC->_fac($x->{value});
-  $x->round(@r);
-  }
-
-sub bpow
-  {
-  # (BINT or num_str, BINT or num_str) return BINT
-  # compute power of two numbers -- stolen from Knuth Vol 2 pg 233
-  # modifies first argument
-
-  # set up parameters
-  my ($self,$x,$y,@r) = (ref($_[0]),@_);
-  # objectify is costly, so avoid it
-  if ((!ref($_[0])) || (ref($_[0]) ne ref($_[1])))
-    {
-    ($self,$x,$y,@r) = objectify(2,@_);
+    if ($mod -> is_zero()) {
+        if ($num -> is_zero()) {
+            return $class -> bnan();
+        } else {
+            return $num -> copy();
+        }
     }
 
-  return $x if $x->modify('bpow');
+    # Compute 'a (mod m)', ignoring the signs on 'a' and 'm'. If the resulting
+    # value is zero, the output is also zero, regardless of the signs on 'a' and
+    # 'm'.
 
-  return $x->bnan() if $x->{sign} eq $nan || $y->{sign} eq $nan;
+    my $value = $CALC->_modpow($num->{value}, $exp->{value}, $mod->{value});
+    my $sign  = '+';
 
-  # inf handling
-  if (($x->{sign} =~ /^[+-]inf$/) || ($y->{sign} =~ /^[+-]inf$/))
-    {
-    if (($x->{sign} =~ /^[+-]inf$/) && ($y->{sign} =~ /^[+-]inf$/))
-      {
-      # +-inf ** +-inf
-      return $x->bnan();
-      }
-    # +-inf ** Y
-    if ($x->{sign} =~ /^[+-]inf/)
-      {
-      # +inf ** 0 => NaN
-      return $x->bnan() if $y->is_zero();
-      # -inf ** -1 => 1/inf => 0
-      return $x->bzero() if $y->is_one('-') && $x->is_negative();
-
-      # +inf ** Y => inf
-      return $x if $x->{sign} eq '+inf';
-
-      # -inf ** Y => -inf if Y is odd
-      return $x if $y->is_odd();
-      return $x->babs();
-      }
-    # X ** +-inf
-
-    # 1 ** +inf => 1
-    return $x if $x->is_one();
-
-    # 0 ** inf => 0
-    return $x if $x->is_zero() && $y->{sign} =~ /^[+]/;
-
-    # 0 ** -inf => inf
-    return $x->binf() if $x->is_zero();
-
-    # -1 ** -inf => NaN
-    return $x->bnan() if $x->is_one('-') && $y->{sign} =~ /^[-]/;
-
-    # -X ** -inf => 0
-    return $x->bzero() if $x->{sign} eq '-' && $y->{sign} =~ /^[-]/;
-
-    # -1 ** inf => NaN
-    return $x->bnan() if $x->{sign} eq '-';
-
-    # X ** inf => inf
-    return $x->binf() if $y->{sign} =~ /^[+]/;
-    # X ** -inf => 0
-    return $x->bzero();
-    }
-
-  return $upgrade->bpow($upgrade->new($x),$y,@r)
-   if defined $upgrade && (!$y->isa($self) || $y->{sign} eq '-');
-
-  $r[3] = $y;                                   # no push!
-
-  # cases 0 ** Y, X ** 0, X ** 1, 1 ** Y are handled by Calc or Emu
-
-  my $new_sign = '+';
-  $new_sign = $y->is_odd() ? '-' : '+' if ($x->{sign} ne '+');
-
-  # 0 ** -7 => ( 1 / (0 ** 7)) => 1 / 0 => +inf
-  return $x->binf()
-    if $y->{sign} eq '-' && $x->{sign} eq '+' && $CALC->_is_zero($x->{value});
-  # 1 ** -y => 1 / (1 ** |y|)
-  # so do test for negative $y after above's clause
-  return $x->bnan() if $y->{sign} eq '-' && !$CALC->_is_one($x->{value});
-
-  $x->{value} = $CALC->_pow($x->{value},$y->{value});
-  $x->{sign} = $new_sign;
-  $x->{sign} = '+' if $CALC->_is_zero($y->{value});
-  $x->round(@r);
-  }
-
-sub blsft
-  {
-  # (BINT or num_str, BINT or num_str) return BINT
-  # compute x << y, base n, y >= 0
-
-  # set up parameters
-  my ($self,$x,$y,$n,@r) = (ref($_[0]),@_);
-  # objectify is costly, so avoid it
-  if ((!ref($_[0])) || (ref($_[0]) ne ref($_[1])))
-    {
-    ($self,$x,$y,$n,@r) = objectify(2,@_);
-    }
+    # If the resulting value is non-zero, we have four special cases, depending
+    # on the signs on 'a' and 'm'.
 
-  return $x if $x->modify('blsft');
-  return $x->bnan() if ($x->{sign} !~ /^[+-]$/ || $y->{sign} !~ /^[+-]$/);
-  return $x->round(@r) if $y->is_zero();
+    unless ($CALC->_is_zero($value)) {
 
-  $n = 2 if !defined $n; return $x->bnan() if $n <= 0 || $y->{sign} eq '-';
+        # There is a negative sign on 'a' (= $num**$exp) only if the number we
+        # are exponentiating ($num) is negative and the exponent ($exp) is odd.
 
-  $x->{value} = $CALC->_lsft($x->{value},$y->{value},$n);
-  $x->round(@r);
-  }
+        if ($num->{sign} eq '-' && $exp->is_odd()) {
 
-sub brsft
-  {
-  # (BINT or num_str, BINT or num_str) return BINT
-  # compute x >> y, base n, y >= 0
+            # When both the number 'a' and the modulus 'm' have a negative sign,
+            # use this relation:
+            #
+            #    -a (mod -m) = -(a (mod m))
+
+            if ($mod->{sign} eq '-') {
+                $sign = '-';
+            }
+
+            # When only the number 'a' has a negative sign, use this relation:
+            #
+            #    -a (mod m) = m - (a (mod m))
+
+            else {
+                # Use copy of $mod since _sub() modifies the first argument.
+                my $mod = $CALC->_copy($mod->{value});
+                $value = $CALC->_sub($mod, $value);
+                $sign  = '+';
+            }
+
+        } else {
+
+            # When only the modulus 'm' has a negative sign, use this relation:
+            #
+            #    a (mod -m) = (a (mod m)) - m
+            #               = -(m - (a (mod m)))
+
+            if ($mod->{sign} eq '-') {
+                # Use copy of $mod since _sub() modifies the first argument.
+                my $mod = $CALC->_copy($mod->{value});
+                $value = $CALC->_sub($mod, $value);
+                $sign  = '-';
+            }
+
+            # When neither the number 'a' nor the modulus 'm' have a negative
+            # sign, directly return the already computed value.
+            #
+            #    (a (mod m))
+
+        }
 
-  # set up parameters
-  my ($self,$x,$y,$n,@r) = (ref($_[0]),@_);
-  # objectify is costly, so avoid it
-  if ((!ref($_[0])) || (ref($_[0]) ne ref($_[1])))
-    {
-    ($self,$x,$y,$n,@r) = objectify(2,@_);
     }
 
-  return $x if $x->modify('brsft');
-  return $x->bnan() if ($x->{sign} !~ /^[+-]$/ || $y->{sign} !~ /^[+-]$/);
-  return $x->round(@r) if $y->is_zero();
-  return $x->bzero(@r) if $x->is_zero();                # 0 => 0
+    $num->{value} = $value;
+    $num->{sign}  = $sign;
 
-  $n = 2 if !defined $n; return $x->bnan() if $n <= 0 || $y->{sign} eq '-';
+    return $num;
+}
 
-   # this only works for negative numbers when shifting in base 2
-  if (($x->{sign} eq '-') && ($n == 2))
-    {
-    return $x->round(@r) if $x->is_one('-');    # -1 => -1
-    if (!$y->is_one())
-      {
-      # although this is O(N*N) in calc (as_bin!) it is O(N) in Pari et al
-      # but perhaps there is a better emulation for two's complement shift...
-      # if $y != 1, we must simulate it by doing:
-      # convert to bin, flip all bits, shift, and be done
-      $x->binc();                       # -3 => -2
-      my $bin = $x->as_bin();
-      $bin =~ s/^-0b//;                 # strip '-0b' prefix
-      $bin =~ tr/10/01/;                # flip bits
-      # now shift
-      if ($y >= CORE::length($bin))
-        {
-        $bin = '0';                     # shifting to far right creates -1
-                                        # 0, because later increment makes
-                                        # that 1, attached '-' makes it '-1'
-                                        # because -1 >> x == -1 !
+sub bpow {
+    # (BINT or num_str, BINT or num_str) return BINT
+    # compute power of two numbers -- stolen from Knuth Vol 2 pg 233
+    # modifies first argument
+
+    # set up parameters
+    my ($class, $x, $y, @r) = (ref($_[0]), @_);
+    # objectify is costly, so avoid it
+    if ((!ref($_[0])) || (ref($_[0]) ne ref($_[1]))) {
+        ($class, $x, $y, @r) = objectify(2, @_);
+    }
+
+    return $x if $x->modify('bpow');
+
+    return $x->bnan() if $x->{sign} eq $nan || $y->{sign} eq $nan;
+
+    # inf handling
+    if (($x->{sign} =~ /^[+-]inf$/) || ($y->{sign} =~ /^[+-]inf$/)) {
+        if (($x->{sign} =~ /^[+-]inf$/) && ($y->{sign} =~ /^[+-]inf$/)) {
+            # +-inf ** +-inf
+            return $x->bnan();
         }
-      else
-        {
-        $bin =~ s/.{$y}$//;             # cut off at the right side
-        $bin = '1' . $bin;              # extend left side by one dummy '1'
-        $bin =~ tr/10/01/;              # flip bits back
+        # +-inf ** Y
+        if ($x->{sign} =~ /^[+-]inf/) {
+            # +inf ** 0 => NaN
+            return $x->bnan() if $y->is_zero();
+            # -inf ** -1 => 1/inf => 0
+            return $x->bzero() if $y->is_one('-') && $x->is_negative();
+
+            # +inf ** Y => inf
+            return $x if $x->{sign} eq '+inf';
+
+            # -inf ** Y => -inf if Y is odd
+            return $x if $y->is_odd();
+            return $x->babs();
         }
-      my $res = $self->new('0b'.$bin);  # add prefix and convert back
-      $res->binc();                     # remember to increment
-      $x->{value} = $res->{value};      # take over value
-      return $x->round(@r);             # we are done now, magic, isn't?
-      }
-    # x < 0, n == 2, y == 1
-    $x->bdec();                         # n == 2, but $y == 1: this fixes it
-    }
-
-  $x->{value} = $CALC->_rsft($x->{value},$y->{value},$n);
-  $x->round(@r);
-  }
-
-sub band
-  {
-  #(BINT or num_str, BINT or num_str) return BINT
-  # compute x & y
-
-  # set up parameters
-  my ($self,$x,$y,@r) = (ref($_[0]),@_);
-  # objectify is costly, so avoid it
-  if ((!ref($_[0])) || (ref($_[0]) ne ref($_[1])))
-    {
-    ($self,$x,$y,@r) = objectify(2,@_);
-    }
+        # X ** +-inf
 
-  return $x if $x->modify('band');
+        # 1 ** +inf => 1
+        return $x if $x->is_one();
 
-  $r[3] = $y;                           # no push!
+        # 0 ** inf => 0
+        return $x if $x->is_zero() && $y->{sign} =~ /^[+]/;
 
-  return $x->bnan() if ($x->{sign} !~ /^[+-]$/ || $y->{sign} !~ /^[+-]$/);
+        # 0 ** -inf => inf
+        return $x->binf() if $x->is_zero();
 
-  my $sx = $x->{sign} eq '+' ? 1 : -1;
-  my $sy = $y->{sign} eq '+' ? 1 : -1;
+        # -1 ** -inf => NaN
+        return $x->bnan() if $x->is_one('-') && $y->{sign} =~ /^[-]/;
 
-  if ($sx == 1 && $sy == 1)
-    {
-    $x->{value} = $CALC->_and($x->{value},$y->{value});
-    return $x->round(@r);
+        # -X ** -inf => 0
+        return $x->bzero() if $x->{sign} eq '-' && $y->{sign} =~ /^[-]/;
+
+        # -1 ** inf => NaN
+        return $x->bnan() if $x->{sign} eq '-';
+
+        # X ** inf => inf
+        return $x->binf() if $y->{sign} =~ /^[+]/;
+        # X ** -inf => 0
+        return $x->bzero();
     }
 
-  if ($CAN{signed_and})
-    {
-    $x->{value} = $CALC->_signed_and($x->{value},$y->{value},$sx,$sy);
-    return $x->round(@r);
+    return $upgrade->bpow($upgrade->new($x), $y, @r)
+      if defined $upgrade && (!$y->isa($class) || $y->{sign} eq '-');
+
+    $r[3] = $y;                 # no push!
+
+    # cases 0 ** Y, X ** 0, X ** 1, 1 ** Y are handled by Calc or Emu
+
+    my $new_sign = '+';
+    $new_sign = $y->is_odd() ? '-' : '+' if ($x->{sign} ne '+');
+
+    # 0 ** -7 => ( 1 / (0 ** 7)) => 1 / 0 => +inf
+    return $x->binf()
+      if $y->{sign} eq '-' && $x->{sign} eq '+' && $CALC->_is_zero($x->{value});
+    # 1 ** -y => 1 / (1 ** |y|)
+    # so do test for negative $y after above's clause
+    return $x->bnan() if $y->{sign} eq '-' && !$CALC->_is_one($x->{value});
+
+    $x->{value} = $CALC->_pow($x->{value}, $y->{value});
+    $x->{sign} = $new_sign;
+    $x->{sign} = '+' if $CALC->_is_zero($y->{value});
+    $x->round(@r);
+}
+
+sub blog {
+    # Return the logarithm of the operand. If a second operand is defined, that
+    # value is used as the base, otherwise the base is assumed to be Euler's
+    # constant.
+
+    # Don't objectify the base, since an undefined base, as in $x->blog() or
+    # $x->blog(undef) signals that the base is Euler's number.
+
+    # set up parameters
+    my ($class, $x, $base, @r) = (undef, @_);
+    # objectify is costly, so avoid it
+    if ((!ref($_[0])) || (ref($_[0]) ne ref($_[1]))) {
+        ($class, $x, $base, @r) = objectify(1, @_);
     }
 
-  require $EMU_LIB;
-  __emu_band($self,$x,$y,$sx,$sy,@r);
-  }
+    return $x if $x->modify('blog');
 
-sub bior
-  {
-  #(BINT or num_str, BINT or num_str) return BINT
-  # compute x | y
+    # Handle all exception cases and all trivial cases. I have used Wolfram Alpha
+    # (http://www.wolframalpha.com) as the reference for these cases.
 
-  # set up parameters
-  my ($self,$x,$y,@r) = (ref($_[0]),@_);
-  # objectify is costly, so avoid it
-  if ((!ref($_[0])) || (ref($_[0]) ne ref($_[1])))
-    {
-    ($self,$x,$y,@r) = objectify(2,@_);
+    return $x -> bnan() if $x -> is_nan();
+
+    if (defined $base) {
+        $base = $class -> new($base) unless ref $base;
+        if ($base -> is_nan() || $base -> is_one()) {
+            return $x -> bnan();
+        } elsif ($base -> is_inf() || $base -> is_zero()) {
+            return $x -> bnan() if $x -> is_inf() || $x -> is_zero();
+            return $x -> bzero();
+        } elsif ($base -> is_negative()) {        # -inf < base < 0
+            return $x -> bzero() if $x -> is_one(); #     x = 1
+            return $x -> bone()  if $x == $base;    #     x = base
+            return $x -> bnan();                    #     otherwise
+        }
+        return $x -> bone() if $x == $base; # 0 < base && 0 < x < inf
     }
 
-  return $x if $x->modify('bior');
-  $r[3] = $y;                           # no push!
+    # We now know that the base is either undefined or >= 2 and finite.
 
-  return $x->bnan() if ($x->{sign} !~ /^[+-]$/ || $y->{sign} !~ /^[+-]$/);
+    return $x -> binf('+') if $x -> is_inf(); #   x = +/-inf
+    return $x -> bnan()    if $x -> is_neg(); #   -inf < x < 0
+    return $x -> bzero()   if $x -> is_one(); #   x = 1
+    return $x -> binf('-') if $x -> is_zero(); #   x = 0
 
-  my $sx = $x->{sign} eq '+' ? 1 : -1;
-  my $sy = $y->{sign} eq '+' ? 1 : -1;
+    # At this point we are done handling all exception cases and trivial cases.
 
-  # the sign of X follows the sign of X, e.g. sign of Y irrelevant for bior()
+    return $upgrade -> blog($upgrade -> new($x), $base, @r) if defined $upgrade;
 
-  # don't use lib for negative values
-  if ($sx == 1 && $sy == 1)
-    {
-    $x->{value} = $CALC->_or($x->{value},$y->{value});
-    return $x->round(@r);
+    # fix for bug #24969:
+    # the default base is e (Euler's number) which is not an integer
+    if (!defined $base) {
+        require Math::BigFloat;
+        my $u = Math::BigFloat->blog(Math::BigFloat->new($x))->as_int();
+        # modify $x in place
+        $x->{value} = $u->{value};
+        $x->{sign} = $u->{sign};
+        return $x;
     }
 
-  # if lib can do negative values, let it handle this
-  if ($CAN{signed_or})
+    my ($rc, $exact) = $CALC->_log_int($x->{value}, $base->{value});
+    return $x->bnan() unless defined $rc; # not possible to take log?
+    $x->{value} = $rc;
+    $x->round(@r);
+}
+
+sub bexp {
+    # Calculate e ** $x (Euler's number to the power of X), truncated to
+    # an integer value.
+    my ($class, $x, @r) = ref($_[0]) ? (ref($_[0]), @_) : objectify(1, @_);
+    return $x if $x->modify('bexp');
+
+    # inf, -inf, NaN, <0 => NaN
+    return $x->bnan() if $x->{sign} eq 'NaN';
+    return $x->bone() if $x->is_zero();
+    return $x if $x->{sign} eq '+inf';
+    return $x->bzero() if $x->{sign} eq '-inf';
+
+    my $u;
     {
-    $x->{value} = $CALC->_signed_or($x->{value},$y->{value},$sx,$sy);
-    return $x->round(@r);
+        # run through Math::BigFloat unless told otherwise
+        require Math::BigFloat unless defined $upgrade;
+        local $upgrade = 'Math::BigFloat' unless defined $upgrade;
+        # calculate result, truncate it to integer
+        $u = $upgrade->bexp($upgrade->new($x), @r);
+    }
+
+    if (defined $upgrade) {
+        $x = $u;
+    } else {
+        $u = $u->as_int();
+        # modify $x in place
+        $x->{value} = $u->{value};
+        $x->round(@r);
+    }
+}
+
+sub bnok {
+    # Calculate n over k (binomial coefficient or "choose" function) as integer.
+    # set up parameters
+    my ($class, $x, $y, @r) = (ref($_[0]), @_);
+
+    # objectify is costly, so avoid it
+    if ((!ref($_[0])) || (ref($_[0]) ne ref($_[1]))) {
+        ($class, $x, $y, @r) = objectify(2, @_);
     }
 
-  require $EMU_LIB;
-  __emu_bior($self,$x,$y,$sx,$sy,@r);
-  }
+    return $x if $x->modify('bnok');
+    return $x->bnan() if $x->{sign} eq 'NaN' || $y->{sign} eq 'NaN';
+    return $x->binf() if $x->{sign} eq '+inf';
 
-sub bxor
-  {
-  #(BINT or num_str, BINT or num_str) return BINT
-  # compute x ^ y
+    # k > n or k < 0 => 0
+    my $cmp = $x->bacmp($y);
+    return $x->bzero() if $cmp < 0 || $y->{sign} =~ /^-/;
+    # k == n => 1
+    return $x->bone(@r) if $cmp == 0;
 
-  # set up parameters
-  my ($self,$x,$y,@r) = (ref($_[0]),@_);
-  # objectify is costly, so avoid it
-  if ((!ref($_[0])) || (ref($_[0]) ne ref($_[1])))
-    {
-    ($self,$x,$y,@r) = objectify(2,@_);
+    if ($CALC->can('_nok')) {
+        $x->{value} = $CALC->_nok($x->{value}, $y->{value});
+    } else {
+        # ( 7 )       7!       1*2*3*4 * 5*6*7   5 * 6 * 7       6   7
+        # ( - ) = --------- =  --------------- = --------- = 5 * - * -
+        # ( 3 )   (7-3)! 3!    1*2*3*4 * 1*2*3   1 * 2 * 3       2   3
+
+        if (!$y->is_zero()) {
+            my $z = $x - $y;
+            $z->binc();
+            my $r = $z->copy();
+            $z->binc();
+            my $d = $class->new(2);
+            while ($z->bacmp($x) <= 0) {        # f <= x ?
+                $r->bmul($z);
+                $r->bdiv($d);
+                $z->binc();
+                $d->binc();
+            }
+            $x->{value} = $r->{value};
+            $x->{sign} = '+';
+        } else {
+            $x->bone();
+        }
     }
+    $x->round(@r);
+}
 
-  return $x if $x->modify('bxor');
-  $r[3] = $y;                           # no push!
+sub bsin {
+    # Calculate sinus(x) to N digits. Unless upgrading is in effect, returns the
+    # result truncated to an integer.
+    my ($class, $x, @r) = ref($_[0]) ? (undef, @_) : objectify(1, @_);
 
-  return $x->bnan() if ($x->{sign} !~ /^[+-]$/ || $y->{sign} !~ /^[+-]$/);
+    return $x if $x->modify('bsin');
 
-  my $sx = $x->{sign} eq '+' ? 1 : -1;
-  my $sy = $y->{sign} eq '+' ? 1 : -1;
+    return $x->bnan() if $x->{sign} !~ /^[+-]\z/; # -inf +inf or NaN => NaN
 
-  # don't use lib for negative values
-  if ($sx == 1 && $sy == 1)
-    {
-    $x->{value} = $CALC->_xor($x->{value},$y->{value});
-    return $x->round(@r);
+    return $upgrade->new($x)->bsin(@r) if defined $upgrade;
+
+    require Math::BigFloat;
+    # calculate the result and truncate it to integer
+    my $t = Math::BigFloat->new($x)->bsin(@r)->as_int();
+
+    $x->bone() if $t->is_one();
+    $x->bzero() if $t->is_zero();
+    $x->round(@r);
+}
+
+sub bcos {
+    # Calculate cosinus(x) to N digits. Unless upgrading is in effect, returns the
+    # result truncated to an integer.
+    my ($class, $x, @r) = ref($_[0]) ? (undef, @_) : objectify(1, @_);
+
+    return $x if $x->modify('bcos');
+
+    return $x->bnan() if $x->{sign} !~ /^[+-]\z/; # -inf +inf or NaN => NaN
+
+    return $upgrade->new($x)->bcos(@r) if defined $upgrade;
+
+    require Math::BigFloat;
+    # calculate the result and truncate it to integer
+    my $t = Math::BigFloat->new($x)->bcos(@r)->as_int();
+
+    $x->bone() if $t->is_one();
+    $x->bzero() if $t->is_zero();
+    $x->round(@r);
+}
+
+sub batan {
+    # Calculate arcus tangens of x to N digits. Unless upgrading is in effect, returns the
+    # result truncated to an integer.
+    my ($class, $x, @r) = ref($_[0]) ? (undef, @_) : objectify(1, @_);
+
+    return $x if $x->modify('batan');
+
+    return $x->bnan() if $x->{sign} !~ /^[+-]\z/; # -inf +inf or NaN => NaN
+
+    return $upgrade->new($x)->batan(@r) if defined $upgrade;
+
+    # calculate the result and truncate it to integer
+    my $t = Math::BigFloat->new($x)->batan(@r);
+
+    $x->{value} = $CALC->_new($x->as_int()->bstr());
+    $x->round(@r);
+}
+
+sub batan2 {
+    # calculate arcus tangens of ($y/$x)
+
+    # set up parameters
+    my ($class, $y, $x, @r) = (ref($_[0]), @_);
+    # objectify is costly, so avoid it
+    if ((!ref($_[0])) || (ref($_[0]) ne ref($_[1]))) {
+        ($class, $y, $x, @r) = objectify(2, @_);
+    }
+
+    return $y if $y->modify('batan2');
+
+    return $y->bnan() if ($y->{sign} eq $nan) || ($x->{sign} eq $nan);
+
+    # Y    X
+    # != 0 -inf result is +- pi
+    if ($x->is_inf() || $y->is_inf()) {
+        # upgrade to Math::BigFloat etc.
+        return $upgrade->new($y)->batan2($upgrade->new($x), @r) if defined $upgrade;
+        if ($y->is_inf()) {
+            if ($x->{sign} eq '-inf') {
+                # calculate 3 pi/4 => 2.3.. => 2
+                $y->bone(substr($y->{sign}, 0, 1));
+                $y->bmul($class->new(2));
+            } elsif ($x->{sign} eq '+inf') {
+                # calculate pi/4 => 0.7 => 0
+                $y->bzero();
+            } else {
+                # calculate pi/2 => 1.5 => 1
+                $y->bone(substr($y->{sign}, 0, 1));
+            }
+        } else {
+            if ($x->{sign} eq '+inf') {
+                # calculate pi/4 => 0.7 => 0
+                $y->bzero();
+            } else {
+                # PI => 3.1415.. => 3
+                $y->bone(substr($y->{sign}, 0, 1));
+                $y->bmul($class->new(3));
+            }
+        }
+        return $y;
     }
 
-  # if lib can do negative values, let it handle this
-  if ($CAN{signed_xor})
-    {
-    $x->{value} = $CALC->_signed_xor($x->{value},$y->{value},$sx,$sy);
-    return $x->round(@r);
+    return $upgrade->new($y)->batan2($upgrade->new($x), @r) if defined $upgrade;
+
+    require Math::BigFloat;
+    my $r = Math::BigFloat->new($y)
+      ->batan2(Math::BigFloat->new($x), @r)
+        ->as_int();
+
+    $x->{value} = $r->{value};
+    $x->{sign} = $r->{sign};
+
+    $x;
+}
+
+sub bsqrt {
+    # calculate square root of $x
+    my ($class, $x, @r) = ref($_[0]) ? (undef, @_) : objectify(1, @_);
+
+    return $x if $x->modify('bsqrt');
+
+    return $x->bnan() if $x->{sign} !~ /^\+/; # -x or -inf or NaN => NaN
+    return $x if $x->{sign} eq '+inf';        # sqrt(+inf) == inf
+
+    return $upgrade->bsqrt($x, @r) if defined $upgrade;
+
+    $x->{value} = $CALC->_sqrt($x->{value});
+    $x->round(@r);
+}
+
+sub broot {
+    # calculate $y'th root of $x
+
+    # set up parameters
+    my ($class, $x, $y, @r) = (ref($_[0]), @_);
+
+    $y = $class->new(2) unless defined $y;
+
+    # objectify is costly, so avoid it
+    if ((!ref($x)) || (ref($x) ne ref($y))) {
+        ($class, $x, $y, @r) = objectify(2, $class || $class, @_);
     }
 
-  require $EMU_LIB;
-  __emu_bxor($self,$x,$y,$sx,$sy,@r);
-  }
+    return $x if $x->modify('broot');
 
-sub length
-  {
-  my ($self,$x) = ref($_[0]) ? (undef,$_[0]) : objectify(1,@_);
+    # NaN handling: $x ** 1/0, x or y NaN, or y inf/-inf or y == 0
+    return $x->bnan() if $x->{sign} !~ /^\+/ || $y->is_zero() ||
+      $y->{sign} !~ /^\+$/;
 
-  my $e = $CALC->_len($x->{value});
-  wantarray ? ($e,0) : $e;
-  }
+    return $x->round(@r)
+      if $x->is_zero() || $x->is_one() || $x->is_inf() || $y->is_one();
 
-sub digit
-  {
-  # return the nth decimal digit, negative values count backward, 0 is right
-  my ($self,$x,$n) = ref($_[0]) ? (undef,@_) : objectify(1,@_);
+    return $upgrade->new($x)->broot($upgrade->new($y), @r) if defined $upgrade;
 
-  $n = $n->numify() if ref($n);
-  $CALC->_digit($x->{value},$n||0);
-  }
+    $x->{value} = $CALC->_root($x->{value}, $y->{value});
+    $x->round(@r);
+}
 
-sub _trailing_zeros
-  {
-  # return the amount of trailing zeros in $x (as scalar)
-  my $x = shift;
-  $x = $class->new($x) unless ref $x;
+sub bfac {
+    # (BINT or num_str, BINT or num_str) return BINT
+    # compute factorial number from $x, modify $x in place
+    my ($class, $x, @r) = ref($_[0]) ? (undef, @_) : objectify(1, @_);
 
-  return 0 if $x->{sign} !~ /^[+-]$/;   # NaN, inf, -inf etc
+    return $x if $x->modify('bfac') || $x->{sign} eq '+inf'; # inf => inf
+    return $x->bnan() if $x->{sign} ne '+'; # NaN, <0 etc => NaN
 
-  $CALC->_zeros($x->{value});           # must handle odd values, 0 etc
-  }
+    $x->{value} = $CALC->_fac($x->{value});
+    $x->round(@r);
+}
 
-sub bsqrt
-  {
-  # calculate square root of $x
-  my ($self,$x,@r) = ref($_[0]) ? (undef,@_) : objectify(1,@_);
+sub blsft {
+    # (BINT or num_str, BINT or num_str) return BINT
+    # compute x << y, base n, y >= 0
 
-  return $x if $x->modify('bsqrt');
+    # set up parameters
+    my ($class, $x, $y, $b, @r) = (ref($_[0]), @_);
 
-  return $x->bnan() if $x->{sign} !~ /^\+/;     # -x or -inf or NaN => NaN
-  return $x if $x->{sign} eq '+inf';            # sqrt(+inf) == inf
+    # objectify is costly, so avoid it
+    if ((!ref($_[0])) || (ref($_[0]) ne ref($_[1]))) {
+        ($class, $x, $y, $b, @r) = objectify(2, @_);
+    }
 
-  return $upgrade->bsqrt($x,@r) if defined $upgrade;
+    return $x if $x -> modify('blsft');
+    return $x -> bnan() if ($x -> {sign} !~ /^[+-]$/ ||
+                            $y -> {sign} !~ /^[+-]$/);
+    return $x -> round(@r) if $y -> is_zero();
 
-  $x->{value} = $CALC->_sqrt($x->{value});
-  $x->round(@r);
-  }
+    $b = 2 if !defined $b;
+    return $x -> bnan() if $b <= 0 || $y -> {sign} eq '-';
 
-sub broot
-  {
-  # calculate $y'th root of $x
+    $x -> {value} = $CALC -> _lsft($x -> {value}, $y -> {value}, $b);
+    $x -> round(@r);
+}
 
-  # set up parameters
-  my ($self,$x,$y,@r) = (ref($_[0]),@_);
+sub brsft {
+    # (BINT or num_str, BINT or num_str) return BINT
+    # compute x >> y, base n, y >= 0
 
-  $y = $self->new(2) unless defined $y;
+    # set up parameters
+    my ($class, $x, $y, $b, @r) = (ref($_[0]), @_);
 
-  # objectify is costly, so avoid it
-  if ((!ref($x)) || (ref($x) ne ref($y)))
-    {
-    ($self,$x,$y,@r) = objectify(2,$self || $class,@_);
+    # objectify is costly, so avoid it
+    if ((!ref($_[0])) || (ref($_[0]) ne ref($_[1]))) {
+        ($class, $x, $y, $b, @r) = objectify(2, @_);
+    }
+
+    return $x if $x -> modify('brsft');
+    return $x -> bnan() if ($x -> {sign} !~ /^[+-]$/ || $y -> {sign} !~ /^[+-]$/);
+    return $x -> round(@r) if $y -> is_zero();
+    return $x -> bzero(@r) if $x -> is_zero(); # 0 => 0
+
+    $b = 2 if !defined $b;
+    return $x -> bnan() if $b <= 0 || $y -> {sign} eq '-';
+
+    # this only works for negative numbers when shifting in base 2
+    if (($x -> {sign} eq '-') && ($b == 2)) {
+        return $x -> round(@r) if $x -> is_one('-'); # -1 => -1
+        if (!$y -> is_one()) {
+            # although this is O(N*N) in calc (as_bin!) it is O(N) in Pari et
+            # al but perhaps there is a better emulation for two's complement
+            # shift...
+            # if $y != 1, we must simulate it by doing:
+            # convert to bin, flip all bits, shift, and be done
+            $x -> binc();           # -3 => -2
+            my $bin = $x -> as_bin();
+            $bin =~ s/^-0b//;       # strip '-0b' prefix
+            $bin =~ tr/10/01/;      # flip bits
+            # now shift
+            if ($y >= CORE::length($bin)) {
+                $bin = '0';         # shifting to far right creates -1
+                                    # 0, because later increment makes
+                                    # that 1, attached '-' makes it '-1'
+                                    # because -1 >> x == -1 !
+            } else {
+                $bin =~ s/.{$y}$//; # cut off at the right side
+                $bin = '1' . $bin;  # extend left side by one dummy '1'
+                $bin =~ tr/10/01/;  # flip bits back
+            }
+            my $res = $class -> new('0b' . $bin); # add prefix and convert back
+            $res -> binc();                       # remember to increment
+            $x -> {value} = $res -> {value};      # take over value
+            return $x -> round(@r); # we are done now, magic, isn't?
+        }
+
+        # x < 0, n == 2, y == 1
+        $x -> bdec();           # n == 2, but $y == 1: this fixes it
     }
 
-  return $x if $x->modify('broot');
+    $x -> {value} = $CALC -> _rsft($x -> {value}, $y -> {value}, $b);
+    $x -> round(@r);
+}
+
+###############################################################################
+# Bitwise methods
+###############################################################################
 
-  # NaN handling: $x ** 1/0, x or y NaN, or y inf/-inf or y == 0
-  return $x->bnan() if $x->{sign} !~ /^\+/ || $y->is_zero() ||
-         $y->{sign} !~ /^\+$/;
+sub band {
+    #(BINT or num_str, BINT or num_str) return BINT
+    # compute x & y
 
-  return $x->round(@r)
-    if $x->is_zero() || $x->is_one() || $x->is_inf() || $y->is_one();
+    # set up parameters
+    my ($class, $x, $y, @r) = (ref($_[0]), @_);
+    # objectify is costly, so avoid it
+    if ((!ref($_[0])) || (ref($_[0]) ne ref($_[1]))) {
+        ($class, $x, $y, @r) = objectify(2, @_);
+    }
 
-  return $upgrade->new($x)->broot($upgrade->new($y),@r) if defined $upgrade;
+    return $x if $x->modify('band');
 
-  $x->{value} = $CALC->_root($x->{value},$y->{value});
-  $x->round(@r);
-  }
+    $r[3] = $y;                 # no push!
 
-sub exponent
-  {
-  # return a copy of the exponent (here always 0, NaN or 1 for $m == 0)
-  my ($self,$x) = ref($_[0]) ? (ref($_[0]),$_[0]) : objectify(1,@_);
+    return $x->bnan() if ($x->{sign} !~ /^[+-]$/ || $y->{sign} !~ /^[+-]$/);
 
-  if ($x->{sign} !~ /^[+-]$/)
-    {
-    my $s = $x->{sign}; $s =~ s/^[+-]//;  # NaN, -inf,+inf => NaN or inf
-    return $self->new($s);
+    my $sx = $x->{sign} eq '+' ? 1 : -1;
+    my $sy = $y->{sign} eq '+' ? 1 : -1;
+
+    if ($sx == 1 && $sy == 1) {
+        $x->{value} = $CALC->_and($x->{value}, $y->{value});
+        return $x->round(@r);
     }
-  return $self->bzero() if $x->is_zero();
 
-  # 12300 => 2 trailing zeros => exponent is 2
-  $self->new( $CALC->_zeros($x->{value}) );
-  }
+    if ($CAN{signed_and}) {
+        $x->{value} = $CALC->_signed_and($x->{value}, $y->{value}, $sx, $sy);
+        return $x->round(@r);
+    }
+
+    require $EMU_LIB;
+    __emu_band($class, $x, $y, $sx, $sy, @r);
+}
 
-sub mantissa
-  {
-  # return the mantissa (compatible to Math::BigFloat, e.g. reduced)
-  my ($self,$x) = ref($_[0]) ? (ref($_[0]),$_[0]) : objectify(1,@_);
+sub bior {
+    #(BINT or num_str, BINT or num_str) return BINT
+    # compute x | y
 
-  if ($x->{sign} !~ /^[+-]$/)
-    {
-    # for NaN, +inf, -inf: keep the sign
-    return $self->new($x->{sign});
+    # set up parameters
+    my ($class, $x, $y, @r) = (ref($_[0]), @_);
+    # objectify is costly, so avoid it
+    if ((!ref($_[0])) || (ref($_[0]) ne ref($_[1]))) {
+        ($class, $x, $y, @r) = objectify(2, @_);
     }
-  my $m = $x->copy(); delete $m->{_p}; delete $m->{_a};
 
-  # that's a bit inefficient:
-  my $zeros = $CALC->_zeros($m->{value});
-  $m->brsft($zeros,10) if $zeros != 0;
-  $m;
-  }
+    return $x if $x->modify('bior');
+    $r[3] = $y;                 # no push!
 
-sub parts
-  {
-  # return a copy of both the exponent and the mantissa
-  my ($self,$x) = ref($_[0]) ? (undef,$_[0]) : objectify(1,@_);
+    return $x->bnan() if ($x->{sign} !~ /^[+-]$/ || $y->{sign} !~ /^[+-]$/);
 
-  ($x->mantissa(),$x->exponent());
-  }
+    my $sx = $x->{sign} eq '+' ? 1 : -1;
+    my $sy = $y->{sign} eq '+' ? 1 : -1;
 
-##############################################################################
-# rounding functions
-
-sub bfround
-  {
-  # precision: round to the $Nth digit left (+$n) or right (-$n) from the '.'
-  # $n == 0 || $n == 1 => round to integer
-  my $x = shift; my $self = ref($x) || $x; $x = $self->new($x) unless ref $x;
-
-  my ($scale,$mode) = $x->_scale_p(@_);
-
-  return $x if !defined $scale || $x->modify('bfround');        # no-op
-
-  # no-op for BigInts if $n <= 0
-  $x->bround( $x->length()-$scale, $mode) if $scale > 0;
-
-  delete $x->{_a};      # delete to save memory
-  $x->{_p} = $scale;    # store new _p
-  $x;
-  }
-
-sub _scan_for_nonzero
-  {
-  # internal, used by bround() to scan for non-zeros after a '5'
-  my ($x,$pad,$xs,$len) = @_;
-
-  return 0 if $len == 1;                # "5" is trailed by invisible zeros
-  my $follow = $pad - 1;
-  return 0 if $follow > $len || $follow < 1;
-
-  # use the string form to check whether only '0's follow or not
-  substr ($xs,-$follow) =~ /[^0]/ ? 1 : 0;
-  }
-
-sub fround
-  {
-  # Exists to make life easier for switch between MBF and MBI (should we
-  # autoload fxxx() like MBF does for bxxx()?)
-  my $x = shift; $x = $class->new($x) unless ref $x;
-  $x->bround(@_);
-  }
-
-sub bround
-  {
-  # accuracy: +$n preserve $n digits from left,
-  #           -$n preserve $n digits from right (f.i. for 0.1234 style in MBF)
-  # no-op for $n == 0
-  # and overwrite the rest with 0's, return normalized number
-  # do not return $x->bnorm(), but $x
-
-  my $x = shift; $x = $class->new($x) unless ref $x;
-  my ($scale,$mode) = $x->_scale_a(@_);
-  return $x if !defined $scale || $x->modify('bround'); # no-op
-
-  if ($x->is_zero() || $scale == 0)
-    {
-    $x->{_a} = $scale if !defined $x->{_a} || $x->{_a} > $scale; # 3 > 2
-    return $x;
+    # the sign of X follows the sign of X, e.g. sign of Y irrelevant for bior()
+
+    # don't use lib for negative values
+    if ($sx == 1 && $sy == 1) {
+        $x->{value} = $CALC->_or($x->{value}, $y->{value});
+        return $x->round(@r);
     }
-  return $x if $x->{sign} !~ /^[+-]$/;          # inf, NaN
 
-  # we have fewer digits than we want to scale to
-  my $len = $x->length();
-  # convert $scale to a scalar in case it is an object (put's a limit on the
-  # number length, but this would already limited by memory constraints), makes
-  # it faster
-  $scale = $scale->numify() if ref ($scale);
+    # if lib can do negative values, let it handle this
+    if ($CAN{signed_or}) {
+        $x->{value} = $CALC->_signed_or($x->{value}, $y->{value}, $sx, $sy);
+        return $x->round(@r);
+    }
 
-  # scale < 0, but > -len (not >=!)
-  if (($scale < 0 && $scale < -$len-1) || ($scale >= $len))
-    {
-    $x->{_a} = $scale if !defined $x->{_a} || $x->{_a} > $scale; # 3 > 2
-    return $x;
+    require $EMU_LIB;
+    __emu_bior($class, $x, $y, $sx, $sy, @r);
+}
+
+sub bxor {
+    #(BINT or num_str, BINT or num_str) return BINT
+    # compute x ^ y
+
+    # set up parameters
+    my ($class, $x, $y, @r) = (ref($_[0]), @_);
+    # objectify is costly, so avoid it
+    if ((!ref($_[0])) || (ref($_[0]) ne ref($_[1]))) {
+        ($class, $x, $y, @r) = objectify(2, @_);
     }
 
-  # count of 0's to pad, from left (+) or right (-): 9 - +6 => 3, or |-6| => 6
-  my ($pad,$digit_round,$digit_after);
-  $pad = $len - $scale;
-  $pad = abs($scale-1) if $scale < 0;
-
-  # do not use digit(), it is very costly for binary => decimal
-  # getting the entire string is also costly, but we need to do it only once
-  my $xs = $CALC->_str($x->{value});
-  my $pl = -$pad-1;
-
-  # pad:   123: 0 => -1, at 1 => -2, at 2 => -3, at 3 => -4
-  # pad+1: 123: 0 => 0,  at 1 => -1, at 2 => -2, at 3 => -3
-  $digit_round = '0'; $digit_round = substr($xs,$pl,1) if $pad <= $len;
-  $pl++; $pl ++ if $pad >= $len;
-  $digit_after = '0'; $digit_after = substr($xs,$pl,1) if $pad > 0;
-
-  # in case of 01234 we round down, for 6789 up, and only in case 5 we look
-  # closer at the remaining digits of the original $x, remember decision
-  my $round_up = 1;                                     # default round up
-  $round_up -- if
-    ($mode eq 'trunc')                          ||      # trunc by round down
-    ($digit_after =~ /[01234]/)                 ||      # round down anyway,
-                                                        # 6789 => round up
-    ($digit_after eq '5')                       &&      # not 5000...0000
-    ($x->_scan_for_nonzero($pad,$xs,$len) == 0)         &&
-    (
-     ($mode eq 'even') && ($digit_round =~ /[24680]/) ||
-     ($mode eq 'odd')  && ($digit_round =~ /[13579]/) ||
-     ($mode eq '+inf') && ($x->{sign} eq '-')   ||
-     ($mode eq '-inf') && ($x->{sign} eq '+')   ||
-     ($mode eq 'zero')          # round down if zero, sign adjusted below
-    );
-  my $put_back = 0;                                     # not yet modified
+    return $x if $x->modify('bxor');
+    $r[3] = $y;                 # no push!
 
-  if (($pad > 0) && ($pad <= $len))
-    {
-    substr($xs,-$pad,$pad) = '0' x $pad;                # replace with '00...'
-    $put_back = 1;                                      # need to put back
+    return $x->bnan() if ($x->{sign} !~ /^[+-]$/ || $y->{sign} !~ /^[+-]$/);
+
+    my $sx = $x->{sign} eq '+' ? 1 : -1;
+    my $sy = $y->{sign} eq '+' ? 1 : -1;
+
+    # don't use lib for negative values
+    if ($sx == 1 && $sy == 1) {
+        $x->{value} = $CALC->_xor($x->{value}, $y->{value});
+        return $x->round(@r);
     }
-  elsif ($pad > $len)
-    {
-    $x->bzero();                                        # round to '0'
+
+    # if lib can do negative values, let it handle this
+    if ($CAN{signed_xor}) {
+        $x->{value} = $CALC->_signed_xor($x->{value}, $y->{value}, $sx, $sy);
+        return $x->round(@r);
     }
 
-  if ($round_up)                                        # what gave test above?
-    {
-    $put_back = 1;                                      # need to put back
-    $pad = $len, $xs = '0' x $pad if $scale < 0;        # tlr: whack 0.51=>1.0
+    require $EMU_LIB;
+    __emu_bxor($class, $x, $y, $sx, $sy, @r);
+}
+
+sub bnot {
+    # (num_str or BINT) return BINT
+    # represent ~x as twos-complement number
+    # we don't need $class, so undef instead of ref($_[0]) make it slightly faster
+    my ($class, $x, $a, $p, $r) = ref($_[0]) ? (undef, @_) : objectify(1, @_);
+
+    return $x if $x->modify('bnot');
+    $x->binc()->bneg();         # binc already does round
+}
 
-    # we modify directly the string variant instead of creating a number and
-    # adding it, since that is faster (we already have the string)
-    my $c = 0; $pad ++;                         # for $pad == $len case
-    while ($pad <= $len)
-      {
-      $c = substr($xs,-$pad,1) + 1; $c = '0' if $c eq '10';
-      substr($xs,-$pad,1) = $c; $pad++;
-      last if $c != 0;                          # no overflow => early out
-      }
-    $xs = '1'.$xs if $c == 0;
+###############################################################################
+# Rounding methods
+###############################################################################
 
+sub round {
+    # Round $self according to given parameters, or given second argument's
+    # parameters or global defaults
+
+    # for speed reasons, _find_round_parameters is embedded here:
+
+    my ($self, $a, $p, $r, @args) = @_;
+    # $a accuracy, if given by caller
+    # $p precision, if given by caller
+    # $r round_mode, if given by caller
+    # @args all 'other' arguments (0 for unary, 1 for binary ops)
+
+    my $class = ref($self);       # find out class of argument(s)
+    no strict 'refs';
+
+    # now pick $a or $p, but only if we have got "arguments"
+    if (!defined $a) {
+        foreach ($self, @args) {
+            # take the defined one, or if both defined, the one that is smaller
+            $a = $_->{_a} if (defined $_->{_a}) && (!defined $a || $_->{_a} < $a);
+        }
+    }
+    if (!defined $p) {
+        # even if $a is defined, take $p, to signal error for both defined
+        foreach ($self, @args) {
+            # take the defined one, or if both defined, the one that is bigger
+            # -2 > -3, and 3 > 2
+            $p = $_->{_p} if (defined $_->{_p}) && (!defined $p || $_->{_p} > $p);
+        }
     }
-  $x->{value} = $CALC->_new($xs) if $put_back == 1;     # put back, if needed
 
-  $x->{_a} = $scale if $scale >= 0;
-  if ($scale < 0)
-    {
-    $x->{_a} = $len+$scale;
-    $x->{_a} = 0 if $scale < -$len;
+    # if still none defined, use globals (#2)
+    $a = ${"$class\::accuracy"}  unless defined $a;
+    $p = ${"$class\::precision"} unless defined $p;
+
+    # A == 0 is useless, so undef it to signal no rounding
+    $a = undef if defined $a && $a == 0;
+
+    # no rounding today?
+    return $self unless defined $a || defined $p; # early out
+
+    # set A and set P is an fatal error
+    return $self->bnan() if defined $a && defined $p;
+
+    $r = ${"$class\::round_mode"} unless defined $r;
+    if ($r !~ /^(even|odd|[+-]inf|zero|trunc|common)$/) {
+        Carp::croak("Unknown round mode '$r'");
+    }
+
+    # now round, by calling either bround or bfround:
+    if (defined $a) {
+        $self->bround(int($a), $r) if !defined $self->{_a} || $self->{_a} >= $a;
+    } else {                  # both can't be undefined due to early out
+        $self->bfround(int($p), $r) if !defined $self->{_p} || $self->{_p} <= $p;
+    }
+
+    # bround() or bfround() already called bnorm() if nec.
+    $self;
+}
+
+sub bround {
+    # accuracy: +$n preserve $n digits from left,
+    #           -$n preserve $n digits from right (f.i. for 0.1234 style in MBF)
+    # no-op for $n == 0
+    # and overwrite the rest with 0's, return normalized number
+    # do not return $x->bnorm(), but $x
+
+    my $x = shift;
+    $x = $class->new($x) unless ref $x;
+    my ($scale, $mode) = $x->_scale_a(@_);
+    return $x if !defined $scale || $x->modify('bround'); # no-op
+
+    if ($x->is_zero() || $scale == 0) {
+        $x->{_a} = $scale if !defined $x->{_a} || $x->{_a} > $scale; # 3 > 2
+        return $x;
+    }
+    return $x if $x->{sign} !~ /^[+-]$/; # inf, NaN
+
+    # we have fewer digits than we want to scale to
+    my $len = $x->length();
+    # convert $scale to a scalar in case it is an object (put's a limit on the
+    # number length, but this would already limited by memory constraints), makes
+    # it faster
+    $scale = $scale->numify() if ref ($scale);
+
+    # scale < 0, but > -len (not >=!)
+    if (($scale < 0 && $scale < -$len-1) || ($scale >= $len)) {
+        $x->{_a} = $scale if !defined $x->{_a} || $x->{_a} > $scale; # 3 > 2
+        return $x;
+    }
+
+    # count of 0's to pad, from left (+) or right (-): 9 - +6 => 3, or |-6| => 6
+    my ($pad, $digit_round, $digit_after);
+    $pad = $len - $scale;
+    $pad = abs($scale-1) if $scale < 0;
+
+    # do not use digit(), it is very costly for binary => decimal
+    # getting the entire string is also costly, but we need to do it only once
+    my $xs = $CALC->_str($x->{value});
+    my $pl = -$pad-1;
+
+    # pad:   123: 0 => -1, at 1 => -2, at 2 => -3, at 3 => -4
+    # pad+1: 123: 0 => 0, at 1 => -1, at 2 => -2, at 3 => -3
+    $digit_round = '0';
+    $digit_round = substr($xs, $pl, 1) if $pad <= $len;
+    $pl++;
+    $pl ++ if $pad >= $len;
+    $digit_after = '0';
+    $digit_after = substr($xs, $pl, 1) if $pad > 0;
+
+    # in case of 01234 we round down, for 6789 up, and only in case 5 we look
+    # closer at the remaining digits of the original $x, remember decision
+    my $round_up = 1;           # default round up
+    $round_up -- if
+      ($mode eq 'trunc')                      ||   # trunc by round down
+        ($digit_after =~ /[01234]/)           ||   # round down anyway,
+          # 6789 => round up
+          ($digit_after eq '5')               &&   # not 5000...0000
+            ($x->_scan_for_nonzero($pad, $xs, $len) == 0)   &&
+              (
+               ($mode eq 'even') && ($digit_round =~ /[24680]/) ||
+               ($mode eq 'odd')  && ($digit_round =~ /[13579]/) ||
+               ($mode eq '+inf') && ($x->{sign} eq '-')         ||
+               ($mode eq '-inf') && ($x->{sign} eq '+')         ||
+               ($mode eq 'zero') # round down if zero, sign adjusted below
+              );
+    my $put_back = 0;           # not yet modified
+
+    if (($pad > 0) && ($pad <= $len)) {
+        substr($xs, -$pad, $pad) = '0' x $pad; # replace with '00...'
+        $put_back = 1;                         # need to put back
+    } elsif ($pad > $len) {
+        $x->bzero();            # round to '0'
+    }
+
+    if ($round_up) {            # what gave test above?
+        $put_back = 1;                               # need to put back
+        $pad = $len, $xs = '0' x $pad if $scale < 0; # tlr: whack 0.51=>1.0
+
+        # we modify directly the string variant instead of creating a number and
+        # adding it, since that is faster (we already have the string)
+        my $c = 0;
+        $pad ++;                # for $pad == $len case
+        while ($pad <= $len) {
+            $c = substr($xs, -$pad, 1) + 1;
+            $c = '0' if $c eq '10';
+            substr($xs, -$pad, 1) = $c;
+            $pad++;
+            last if $c != 0;    # no overflow => early out
+        }
+        $xs = '1'.$xs if $c == 0;
+
+    }
+    $x->{value} = $CALC->_new($xs) if $put_back == 1; # put back, if needed
+
+    $x->{_a} = $scale if $scale >= 0;
+    if ($scale < 0) {
+        $x->{_a} = $len+$scale;
+        $x->{_a} = 0 if $scale < -$len;
     }
-  $x;
-  }
+    $x;
+}
+
+sub bfround {
+    # precision: round to the $Nth digit left (+$n) or right (-$n) from the '.'
+    # $n == 0 || $n == 1 => round to integer
+    my $x = shift;
+    my $class = ref($x) || $x;
+    $x = $class->new($x) unless ref $x;
+
+    my ($scale, $mode) = $x->_scale_p(@_);
+
+    return $x if !defined $scale || $x->modify('bfround'); # no-op
+
+    # no-op for Math::BigInt objects if $n <= 0
+    $x->bround($x->length()-$scale, $mode) if $scale > 0;
+
+    delete $x->{_a};            # delete to save memory
+    $x->{_p} = $scale;          # store new _p
+    $x;
+}
 
-sub bfloor
-  {
-  # round towards minus infinity; no-op since it's already integer
-  my ($self,$x,@r) = ref($_[0]) ? (undef,@_) : objectify(1,@_);
+sub fround {
+    # Exists to make life easier for switch between MBF and MBI (should we
+    # autoload fxxx() like MBF does for bxxx()?)
+    my $x = shift;
+    $x = $class->new($x) unless ref $x;
+    $x->bround(@_);
+}
+
+sub bfloor {
+    # round towards minus infinity; no-op since it's already integer
+    my ($class, $x, @r) = ref($_[0]) ? (undef, @_) : objectify(1, @_);
 
-  $x->round(@r);
-  }
+    $x->round(@r);
+}
 
-sub bceil
-  {
-  # round towards plus infinity; no-op since it's already int
-  my ($self,$x,@r) = ref($_[0]) ? (undef,@_) : objectify(1,@_);
+sub bceil {
+    # round towards plus infinity; no-op since it's already int
+    my ($class, $x, @r) = ref($_[0]) ? (undef, @_) : objectify(1, @_);
 
-  $x->round(@r);
-  }
+    $x->round(@r);
+}
 
 sub bint {
     # round towards zero; no-op since it's already integer
-    my ($self,$x,@r) = ref($_[0]) ? (undef,@_) : objectify(1,@_);
+    my ($class, $x, @r) = ref($_[0]) ? (undef, @_) : objectify(1, @_);
 
     $x->round(@r);
 }
 
-sub as_number
-  {
-  # An object might be asked to return itself as bigint on certain overloaded
-  # operations. This does exactly this, so that sub classes can simple inherit
-  # it or override with their own integer conversion routine.
-  $_[0]->copy();
-  }
+###############################################################################
+# Other mathematical methods
+###############################################################################
+
+sub bgcd {
+    # (BINT or num_str, BINT or num_str) return BINT
+    # does not modify arguments, but returns new object
+    # GCD -- Euclid's algorithm, variant C (Knuth Vol 3, pg 341 ff)
+
+    my $y = shift;
+    $y = $class->new($y) if !ref($y);
+    my $class = ref($y);
+    my $x = $y->copy()->babs();                  # keep arguments
+    return $x->bnan() if $x->{sign} !~ /^[+-]$/; # x NaN?
+
+    while (@_) {
+        $y = shift;
+        $y = $class->new($y) if !ref($y);
+        return $x->bnan() if $y->{sign} !~ /^[+-]$/; # y NaN?
+        $x->{value} = $CALC->_gcd($x->{value}, $y->{value});
+        last if $CALC->_is_one($x->{value});
+    }
+    $x;
+}
+
+sub blcm {
+    # (BINT or num_str, BINT or num_str) return BINT
+    # does not modify arguments, but returns new object
+    # Lowest Common Multiple
+
+    my $y = shift;
+    my ($x);
+    if (ref($y)) {
+        $x = $y->copy();
+    } else {
+        $x = $class->new($y);
+    }
+    my $class = ref($x);
+    while (@_) {
+        my $y = shift;
+        $y = $class->new($y) if !ref ($y);
+        $x = __lcm($x, $y);
+    }
+    $x;
+}
+
+###############################################################################
+# Object property methods
+###############################################################################
 
-sub as_hex
-  {
-  # return as hex string, with prefixed 0x
-  my $x = shift; $x = $class->new($x) if !ref($x);
+sub sign {
+    # return the sign of the number: +/-/-inf/+inf/NaN
+    my ($class, $x) = ref($_[0]) ? (undef, $_[0]) : objectify(1, @_);
 
-  return $x->bstr() if $x->{sign} !~ /^[+-]$/;  # inf, nan etc
+    $x->{sign};
+}
 
-  my $s = '';
-  $s = $x->{sign} if $x->{sign} eq '-';
-  $s . $CALC->_as_hex($x->{value});
-  }
+sub digit {
+    # return the nth decimal digit, negative values count backward, 0 is right
+    my ($class, $x, $n) = ref($_[0]) ? (undef, @_) : objectify(1, @_);
 
-sub as_bin
-  {
-  # return as binary string, with prefixed 0b
-  my $x = shift; $x = $class->new($x) if !ref($x);
+    $n = $n->numify() if ref($n);
+    $CALC->_digit($x->{value}, $n || 0);
+}
 
-  return $x->bstr() if $x->{sign} !~ /^[+-]$/;  # inf, nan etc
+sub length {
+    my ($class, $x) = ref($_[0]) ? (undef, $_[0]) : objectify(1, @_);
 
-  my $s = ''; $s = $x->{sign} if $x->{sign} eq '-';
-  return $s . $CALC->_as_bin($x->{value});
-  }
+    my $e = $CALC->_len($x->{value});
+    wantarray ? ($e, 0) : $e;
+}
 
-sub as_oct
-  {
-  # return as octal string, with prefixed 0
-  my $x = shift; $x = $class->new($x) if !ref($x);
+sub exponent {
+    # return a copy of the exponent (here always 0, NaN or 1 for $m == 0)
+    my ($class, $x) = ref($_[0]) ? (ref($_[0]), $_[0]) : objectify(1, @_);
 
-  return $x->bstr() if $x->{sign} !~ /^[+-]$/;  # inf, nan etc
+    if ($x->{sign} !~ /^[+-]$/) {
+        my $s = $x->{sign};
+        $s =~ s/^[+-]//; # NaN, -inf, +inf => NaN or inf
+        return $class->new($s);
+    }
+    return $class->bzero() if $x->is_zero();
 
-  my $oct = $CALC->_as_oct($x->{value});
-  return $x->{sign} eq '-' ? "-$oct" : $oct;
-  }
+    # 12300 => 2 trailing zeros => exponent is 2
+    $class->new($CALC->_zeros($x->{value}));
+}
 
-##############################################################################
-# private stuff (internal use only)
+sub mantissa {
+    # return the mantissa (compatible to Math::BigFloat, e.g. reduced)
+    my ($class, $x) = ref($_[0]) ? (ref($_[0]), $_[0]) : objectify(1, @_);
+
+    if ($x->{sign} !~ /^[+-]$/) {
+        # for NaN, +inf, -inf: keep the sign
+        return $class->new($x->{sign});
+    }
+    my $m = $x->copy();
+    delete $m->{_p};
+    delete $m->{_a};
+
+    # that's a bit inefficient:
+    my $zeros = $CALC->_zeros($m->{value});
+    $m->brsft($zeros, 10) if $zeros != 0;
+    $m;
+}
+
+sub parts {
+    # return a copy of both the exponent and the mantissa
+    my ($class, $x) = ref($_[0]) ? (undef, $_[0]) : objectify(1, @_);
+
+    ($x->mantissa(), $x->exponent());
+}
+
+sub sparts {
+    my $self  = shift;
+    my $class = ref $self;
+
+    Carp::croak("sparts() is an instance method, not a class method")
+        unless $class;
+
+    # Not-a-number.
+
+    if ($self -> is_nan()) {
+        my $mant = $self -> copy();             # mantissa
+        return $mant unless wantarray;          # scalar context
+        my $expo = $class -> bnan();            # exponent
+        return ($mant, $expo);                  # list context
+    }
+
+    # Infinity.
+
+    if ($self -> is_inf()) {
+        my $mant = $self -> copy();             # mantissa
+        return $mant unless wantarray;          # scalar context
+        my $expo = $class -> binf('+');         # exponent
+        return ($mant, $expo);                  # list context
+    }
+
+    # Finite number.
+
+    my $mant   = $self -> copy();
+    my $nzeros = $CALC -> _zeros($mant -> {value});
+
+    $mant -> brsft($nzeros, 10) if $nzeros != 0;
+    return $mant unless wantarray;
+
+    my $expo = $class -> new($nzeros);
+    return ($mant, $expo);
+}
+
+sub nparts {
+    my $self  = shift;
+    my $class = ref $self;
+
+    Carp::croak("nparts() is an instance method, not a class method")
+        unless $class;
+
+    # Not-a-number.
+
+    if ($self -> is_nan()) {
+        my $mant = $self -> copy();             # mantissa
+        return $mant unless wantarray;          # scalar context
+        my $expo = $class -> bnan();            # exponent
+        return ($mant, $expo);                  # list context
+    }
+
+    # Infinity.
+
+    if ($self -> is_inf()) {
+        my $mant = $self -> copy();             # mantissa
+        return $mant unless wantarray;          # scalar context
+        my $expo = $class -> binf('+');         # exponent
+        return ($mant, $expo);                  # list context
+    }
+
+    # Finite number.
+
+    my ($mant, $expo) = $self -> sparts();
+
+    if ($mant -> bcmp(0)) {
+        my ($ndigtot, $ndigfrac) = $mant -> length();
+        my $expo10adj = $ndigtot - $ndigfrac - 1;
+
+        if ($expo10adj != 0) {
+            return $upgrade -> new($self) -> nparts() if $upgrade;
+            $mant -> bnan();
+            return $mant unless wantarray;
+            $expo -> badd($expo10adj);
+            return ($mant, $expo);
+        }
+    }
+
+    return $mant unless wantarray;
+    return ($mant, $expo);
+}
+
+sub eparts {
+    my $self  = shift;
+    my $class = ref $self;
+
+    Carp::croak("eparts() is an instance method, not a class method")
+        unless $class;
+
+    # Not-a-number and Infinity.
+
+    return $self -> sparts() if $self -> is_nan() || $self -> is_inf();
+
+    # Finite number.
+
+    my ($mant, $expo) = $self -> sparts();
+
+    if ($mant -> bcmp(0)) {
+        my $ndigmant  = $mant -> length();
+        $expo -> badd($ndigmant);
+
+        # $c is the number of digits that will be in the integer part of the
+        # final mantissa.
+
+        my $c = $expo -> copy() -> bdec() -> bmod(3) -> binc();
+        $expo -> bsub($c);
+
+        if ($ndigmant > $c) {
+            return $upgrade -> new($self) -> eparts() if $upgrade;
+            $mant -> bnan();
+            return $mant unless wantarray;
+            return ($mant, $expo);
+        }
+
+        $mant -> blsft($c - $ndigmant, 10);
+    }
+
+    return $mant unless wantarray;
+    return ($mant, $expo);
+}
+
+sub dparts {
+    my $self  = shift;
+    my $class = ref $self;
+
+    Carp::croak("dparts() is an instance method, not a class method")
+        unless $class;
+
+    my $int = $self -> copy();
+    return $int unless wantarray;
+
+    my $frc = $class -> bzero();
+    return ($int, $frc);
+}
+
+###############################################################################
+# String conversion methods
+###############################################################################
+
+sub bstr {
+    my ($class, $x) = ref($_[0]) ? (undef, $_[0]) : objectify(1, @_);
+
+    if ($x->{sign} ne '+' && $x->{sign} ne '-') {
+        return $x->{sign} unless $x->{sign} eq '+inf'; # -inf, NaN
+        return 'inf';                                  # +inf
+    }
+    my $str = $CALC->_str($x->{value});
+    return $x->{sign} eq '-' ? "-$str" : $str;
+}
+
+# Scientific notation with significand/mantissa as an integer, e.g., "12345" is
+# written as "1.2345e+4".
+
+sub bsstr {
+    my ($class, $x) = ref($_[0]) ? (undef, $_[0]) : objectify(1, @_);
+
+    if ($x->{sign} ne '+' && $x->{sign} ne '-') {
+        return $x->{sign} unless $x->{sign} eq '+inf';  # -inf, NaN
+        return 'inf';                                   # +inf
+    }
+    my ($m, $e) = $x -> parts();
+    my $str = $CALC->_str($m->{value}) . 'e+' . $CALC->_str($e->{value});
+    return $x->{sign} eq '-' ? "-$str" : $str;
+}
+
+# Normalized notation, e.g., "12345" is written as "12345e+0".
+
+sub bnstr {
+    my $x = shift;
+
+    if ($x->{sign} ne '+' && $x->{sign} ne '-') {
+        return $x->{sign} unless $x->{sign} eq '+inf';  # -inf, NaN
+        return 'inf';                                   # +inf
+    }
+
+    return $x -> bstr() if $x -> is_nan() || $x -> is_inf();
+
+    my ($mant, $expo) = $x -> parts();
+
+    # The "fraction posision" is the position (offset) for the decimal point
+    # relative to the end of the digit string.
+
+    my $fracpos = $mant -> length() - 1;
+    if ($fracpos == 0) {
+        my $str = $CALC->_str($mant->{value}) . "e+" . $CALC->_str($expo->{value});
+        return $x->{sign} eq '-' ? "-$str" : $str;
+    }
+
+    $expo += $fracpos;
+    my $mantstr = $CALC->_str($mant -> {value});
+    substr($mantstr, -$fracpos, 0) = '.';
+
+    my $str = $mantstr . 'e+' . $CALC->_str($expo -> {value});
+    return $x->{sign} eq '-' ? "-$str" : $str;
+}
+
+# Engineering notation, e.g., "12345" is written as "12.345e+3".
+
+sub bestr {
+    my $x = shift;
+
+    if ($x->{sign} ne '+' && $x->{sign} ne '-') {
+        return $x->{sign} unless $x->{sign} eq '+inf';  # -inf, NaN
+        return 'inf';                                   # +inf
+    }
+
+    my ($mant, $expo) = $x -> parts();
+
+    my $sign = $mant -> sign();
+    $mant -> babs();
+
+    my $mantstr = $CALC->_str($mant -> {value});
+    my $mantlen = CORE::length($mantstr);
+
+    my $dotidx = 1;
+    $expo += $mantlen - 1;
+
+    my $c = $expo -> copy() -> bmod(3);
+    $expo   -= $c;
+    $dotidx += $c;
+
+    if ($mantlen < $dotidx) {
+        $mantstr .= "0" x ($dotidx - $mantlen);
+    } elsif ($mantlen > $dotidx) {
+        substr($mantstr, $dotidx, 0) = ".";
+    }
+
+    my $str = $mantstr . 'e+' . $CALC->_str($expo -> {value});
+    return $sign eq "-" ? "-$str" : $str;
+}
+
+# Decimal notation, e.g., "12345".
+
+sub bdstr {
+    my $x = shift;
+
+    if ($x->{sign} ne '+' && $x->{sign} ne '-') {
+        return $x->{sign} unless $x->{sign} eq '+inf'; # -inf, NaN
+        return 'inf';                                  # +inf
+    }
+
+    my $str = $CALC->_str($x->{value});
+    return $x->{sign} eq '-' ? "-$str" : $str;
+}
+
+sub as_hex {
+    # return as hex string, with prefixed 0x
+    my $x = shift;
+    $x = $class->new($x) if !ref($x);
+
+    return $x->bstr() if $x->{sign} !~ /^[+-]$/; # inf, nan etc
+
+    my $s = '';
+    $s = $x->{sign} if $x->{sign} eq '-';
+    $s . $CALC->_as_hex($x->{value});
+}
+
+sub as_oct {
+    # return as octal string, with prefixed 0
+    my $x = shift;
+    $x = $class->new($x) if !ref($x);
+
+    return $x->bstr() if $x->{sign} !~ /^[+-]$/; # inf, nan etc
+
+    my $oct = $CALC->_as_oct($x->{value});
+    return $x->{sign} eq '-' ? "-$oct" : $oct;
+}
+
+sub as_bin {
+    # return as binary string, with prefixed 0b
+    my $x = shift;
+    $x = $class->new($x) if !ref($x);
+
+    return $x->bstr() if $x->{sign} !~ /^[+-]$/; # inf, nan etc
+
+    my $s = '';
+    $s = $x->{sign} if $x->{sign} eq '-';
+    return $s . $CALC->_as_bin($x->{value});
+}
+
+###############################################################################
+# Other conversion methods
+###############################################################################
+
+sub numify {
+    # Make a Perl scalar number from a Math::BigInt object.
+    my $x = shift;
+    $x = $class->new($x) unless ref $x;
+
+    if ($x -> is_nan()) {
+        require Math::Complex;
+        my $inf = Math::Complex::Inf();
+        return $inf - $inf;
+    }
+
+    if ($x -> is_inf()) {
+        require Math::Complex;
+        my $inf = Math::Complex::Inf();
+        return $x -> is_negative() ? -$inf : $inf;
+    }
+
+    my $num = 0 + $CALC->_num($x->{value});
+    return $x->{sign} eq '-' ? -$num : $num;
+}
+
+###############################################################################
+# Private methods and functions.
+###############################################################################
 
 sub objectify {
     # Convert strings and "foreign objects" to the objects we want.
@@ -2782,19 +3499,18 @@ sub objectify {
     # Caller:                        Gives us:
     #
     # $x->badd(1);                => ref x, scalar y
-    # Class->badd(1,2);           => classname x (scalar), scalar x, scalar y
-    # Class->badd(Class->(1),2);  => classname x (scalar), ref x, scalar y
-    # Math::BigInt::badd(1,2);    => scalar x, scalar y
+    # Class->badd(1, 2);           => classname x (scalar), scalar x, scalar y
+    # Class->badd(Class->(1), 2);  => classname x (scalar), ref x, scalar y
+    # Math::BigInt::badd(1, 2);    => scalar x, scalar y
 
     # A shortcut for the common case $x->unary_op():
 
-    return (ref($_[1]), $_[1]) if (@_ == 2) && ($_[0]||0 == 1) && ref($_[1]);
+    return (ref($_[1]), $_[1]) if @_ == 2 && ($_[0] || 0) == 1 && ref($_[1]);
 
     # Check the context.
 
     unless (wantarray) {
-        require Carp;
-        Carp::croak ("${class}::objectify() needs list context");
+        Carp::croak("${class}::objectify() needs list context");
     }
 
     # Get the number of arguments to objectify.
@@ -2827,7 +3543,7 @@ sub objectify {
 
     my $up = ${"$a[0]::upgrade"};
 
-    # Disable downgrading, because Math::BigFloat -> foo('1.0','2.0') needs
+    # Disable downgrading, because Math::BigFloat -> foo('1.0', '2.0') needs
     # floats.
 
     my $down;
@@ -2908,334 +3624,150 @@ sub objectify {
     return @a;
 }
 
-sub _register_callback
-  {
-  my ($class,$callback) = @_;
-
-  if (ref($callback) ne 'CODE')
-    {
-    require Carp;
-    Carp::croak ("$callback is not a coderef");
-    }
-  $CALLBACKS{$class} = $callback;
-  }
-
-sub import
-  {
-  my $self = shift;
-
-  $IMPORT++;                            # remember we did import()
-  my @a; my $l = scalar @_;
-  my $warn_or_die = 0;                  # 0 - no warn, 1 - warn, 2 - die
-  for ( my $i = 0; $i < $l ; $i++ )
-    {
-    if ($_[$i] eq ':constant')
-      {
-      # this causes overlord er load to step in
-      overload::constant
-        integer => sub { $self->new(shift) },
-        binary => sub { $self->new(shift) };
-      }
-    elsif ($_[$i] eq 'upgrade')
-      {
-      # this causes upgrading
-      $upgrade = $_[$i+1];              # or undef to disable
-      $i++;
-      }
-    elsif ($_[$i] =~ /^(lib|try|only)\z/)
-      {
-      # this causes a different low lib to take care...
-      $CALC = $_[$i+1] || '';
-      # lib => 1 (warn on fallback), try => 0 (no warn), only => 2 (die on fallback)
-      $warn_or_die = 1 if $_[$i] eq 'lib';
-      $warn_or_die = 2 if $_[$i] eq 'only';
-      $i++;
-      }
-    else
-      {
-      push @a, $_[$i];
-      }
-    }
-  # any non :constant stuff is handled by our parent, Exporter
-  if (@a > 0)
-    {
-    require Exporter;
-
-    $self->SUPER::import(@a);                   # need it for subclasses
-    $self->export_to_level(1,$self,@a);         # need it for MBF
-    }
-
-  # try to load core math lib
-  my @c = split /\s*,\s*/,$CALC;
-  foreach (@c)
-    {
-    $_ =~ tr/a-zA-Z0-9://cd;                    # limit to sane characters
+sub import {
+    my $class = shift;
+
+    $IMPORT++;                  # remember we did import()
+    my @a;
+    my $l = scalar @_;
+    my $warn_or_die = 0;        # 0 - no warn, 1 - warn, 2 - die
+    for (my $i = 0; $i < $l ; $i++) {
+        if ($_[$i] eq ':constant') {
+            # this causes overlord er load to step in
+            overload::constant
+                integer => sub { $class->new(shift) },
+                binary  => sub { $class->new(shift) };
+        } elsif ($_[$i] eq 'upgrade') {
+            # this causes upgrading
+            $upgrade = $_[$i+1]; # or undef to disable
+            $i++;
+        } elsif ($_[$i] =~ /^(lib|try|only)\z/) {
+            # this causes a different low lib to take care...
+            $CALC = $_[$i+1] || '';
+            # lib => 1 (warn on fallback), try => 0 (no warn), only => 2 (die on fallback)
+            $warn_or_die = 1 if $_[$i] eq 'lib';
+            $warn_or_die = 2 if $_[$i] eq 'only';
+            $i++;
+        } else {
+            push @a, $_[$i];
+        }
     }
-  push @c, \'Calc'                              # if all fail, try these
-    if $warn_or_die < 2;                        # but not for "only"
-  $CALC = '';                                   # signal error
-  foreach my $l (@c)
-    {
-    # fallback libraries are "marked" as \'string', extract string if nec.
-    my $lib = $l; $lib = $$l if ref($l);
-
-    next if ($lib || '') eq '';
-    $lib = 'Math::BigInt::'.$lib if $lib !~ /^Math::BigInt/i;
-    $lib =~ s/\.pm$//;
-    if ($] < 5.006)
-      {
-      # Perl < 5.6.0 dies with "out of memory!" when eval("") and ':constant' is
-      # used in the same script, or eval("") inside import().
-      my @parts = split /::/, $lib;             # Math::BigInt => Math BigInt
-      my $file = pop @parts; $file .= '.pm';    # BigInt => BigInt.pm
-      require File::Spec;
-      $file = File::Spec->catfile (@parts, $file);
-      eval { require "$file"; $lib->import( @c ); }
-      }
-    else
-      {
-      eval "use $lib qw/@c/;";
-      }
-    if ($@ eq '')
-      {
-      my $ok = 1;
-      # loaded it ok, see if the api_version() is high enough
-      if ($lib->can('api_version') && $lib->api_version() >= 1.0)
-        {
-        $ok = 0;
-        # api_version matches, check if it really provides anything we need
-        for my $method (qw/
-                one two ten
-                str num
-                add mul div sub dec inc
-                acmp len digit is_one is_zero is_even is_odd
-                is_two is_ten
-                zeros new copy check
-                from_hex from_oct from_bin as_hex as_bin as_oct
-                rsft lsft xor and or
-                mod sqrt root fac pow modinv modpow log_int gcd
-         /)
-          {
-          if (!$lib->can("_$method"))
-            {
-            if (($WARN{$lib}||0) < 2)
-              {
-              require Carp;
-              Carp::carp ("$lib is missing method '_$method'");
-              $WARN{$lib} = 1;          # still warn about the lib
-              }
-            $ok++; last;
+    # any non :constant stuff is handled by our parent, Exporter
+    if (@a > 0) {
+        require Exporter;
+
+        $class->SUPER::import(@a);            # need it for subclasses
+        $class->export_to_level(1, $class, @a); # need it for MBF
+    }
+
+    # try to load core math lib
+    my @c = split /\s*,\s*/, $CALC;
+    foreach (@c) {
+        $_ =~ tr/a-zA-Z0-9://cd; # limit to sane characters
+    }
+    push @c, \'Calc'            # if all fail, try these
+      if $warn_or_die < 2;      # but not for "only"
+    $CALC = '';                 # signal error
+    foreach my $l (@c) {
+        # fallback libraries are "marked" as \'string', extract string if nec.
+        my $lib = $l;
+        $lib = $$l if ref($l);
+
+        next if ($lib || '') eq '';
+        $lib = 'Math::BigInt::'.$lib if $lib !~ /^Math::BigInt/i;
+        $lib =~ s/\.pm$//;
+        if ($] < 5.006) {
+            # Perl < 5.6.0 dies with "out of memory!" when eval("") and ':constant' is
+            # used in the same script, or eval("") inside import().
+            my @parts = split /::/, $lib; # Math::BigInt => Math BigInt
+            my $file = pop @parts;
+            $file .= '.pm';     # BigInt => BigInt.pm
+            require File::Spec;
+            $file = File::Spec->catfile (@parts, $file);
+            eval {
+                require "$file";
+                $lib->import(@c);
             }
-          }
-        }
-      if ($ok == 0)
-        {
-        $CALC = $lib;
-        if ($warn_or_die > 0 && ref($l))
-          {
-          require Carp;
-          my $msg =
-        "Math::BigInt: couldn't load specified math lib(s), fallback to $lib";
-          Carp::carp ($msg) if $warn_or_die == 1;
-          Carp::croak ($msg) if $warn_or_die == 2;
-          }
-        last;                   # found a usable one, break
+        } else {
+            eval "use $lib qw/@c/;";
         }
-      else
-        {
-        if (($WARN{$lib}||0) < 2)
-          {
-          my $ver = eval "\$$lib\::VERSION" || 'unknown';
-          require Carp;
-          Carp::carp ("Cannot load outdated $lib v$ver, please upgrade");
-          $WARN{$lib} = 2;              # never warn again
-          }
+        if ($@ eq '') {
+            my $ok = 1;
+            # loaded it ok, see if the api_version() is high enough
+            if ($lib->can('api_version') && $lib->api_version() >= 1.0) {
+                $ok = 0;
+                # api_version matches, check if it really provides anything we need
+                for my $method (qw/
+                                      one two ten
+                                      str num
+                                      add mul div sub dec inc
+                                      acmp len digit is_one is_zero is_even is_odd
+                                      is_two is_ten
+                                      zeros new copy check
+                                      from_hex from_oct from_bin as_hex as_bin as_oct
+                                      rsft lsft xor and or
+                                      mod sqrt root fac pow modinv modpow log_int gcd
+                                  /) {
+                    if (!$lib->can("_$method")) {
+                        if (($WARN{$lib} || 0) < 2) {
+                            Carp::carp("$lib is missing method '_$method'");
+                            $WARN{$lib} = 1; # still warn about the lib
+                        }
+                        $ok++;
+                        last;
+                    }
+                }
+            }
+            if ($ok == 0) {
+                $CALC = $lib;
+                if ($warn_or_die > 0 && ref($l)) {
+                    my $msg = "Math::BigInt: couldn't load specified"
+                            . " math lib(s), fallback to $lib";
+                    Carp::carp($msg)  if $warn_or_die == 1;
+                    Carp::croak($msg) if $warn_or_die == 2;
+                }
+                last;           # found a usable one, break
+            } else {
+                if (($WARN{$lib} || 0) < 2) {
+                    my $ver = eval "\$$lib\::VERSION" || 'unknown';
+                    Carp::carp("Cannot load outdated $lib v$ver, please upgrade");
+                    $WARN{$lib} = 2; # never warn again
+                }
+            }
         }
-      }
     }
-  if ($CALC eq '')
-    {
-    require Carp;
-    if ($warn_or_die == 2)
-      {
-      Carp::croak(
-          "Couldn't load specified math lib(s) and fallback disallowed");
-      }
-    else
-      {
-      Carp::croak(
-          "Couldn't load any math lib(s), not even fallback to Calc.pm");
-      }
-    }
-
-  # notify callbacks
-  foreach my $class (keys %CALLBACKS)
-    {
-    &{$CALLBACKS{$class}}($CALC);
+    if ($CALC eq '') {
+        if ($warn_or_die == 2) {
+            Carp::croak("Couldn't load specified math lib(s)" .
+                        " and fallback disallowed");
+        } else {
+            Carp::croak("Couldn't load any math lib(s), not even fallback to Calc.pm");
+        }
     }
 
-  # Fill $CAN with the results of $CALC->can(...) for emulating lower math lib
-  # functions
-
-  %CAN = ();
-  for my $method (qw/ signed_and signed_or signed_xor /)
-    {
-    $CAN{$method} = $CALC->can("_$method") ? 1 : 0;
+    # notify callbacks
+    foreach my $class (keys %CALLBACKS) {
+        &{$CALLBACKS{$class}}($CALC);
     }
 
-  # import done
-  }
+    # Fill $CAN with the results of $CALC->can(...) for emulating lower math lib
+    # functions
 
-# Create a Math::BigInt from a hexadecimal string.
-
-sub from_hex {
-    my $self    = shift;
-    my $selfref = ref $self;
-    my $class   = $selfref || $self;
-
-    my $str = shift;
-
-    # If called as a class method, initialize a new object.
-
-    $self = $class -> bzero() unless $selfref;
-
-    if ($str =~ s/
-                     ^
-                     ( [+-]? )
-                     (0?x)?
-                     (
-                         [0-9a-fA-F]*
-                         ( _ [0-9a-fA-F]+ )*
-                     )
-                     $
-                 //x)
-    {
-        # Get a "clean" version of the string, i.e., non-emtpy and with no
-        # underscores or invalid characters.
-
-        my $sign = $1;
-        my $chrs = $3;
-        $chrs =~ tr/_//d;
-        $chrs = '0' unless CORE::length $chrs;
-
-        # The library method requires a prefix.
-
-        $self->{value} = $CALC->_from_hex('0x' . $chrs);
-
-        # Place the sign.
-
-        if ($sign eq '-' && ! $CALC->_is_zero($self->{value})) {
-            $self->{sign} = '-';
-        }
-
-        return $self;
+    %CAN = ();
+    for my $method (qw/ signed_and signed_or signed_xor /) {
+        $CAN{$method} = $CALC->can("_$method") ? 1 : 0;
     }
 
-    # CORE::hex() parses as much as it can, and ignores any trailing garbage.
-    # For backwards compatibility, we return NaN.
-
-    return $self->bnan();
+    # import done
 }
 
-# Create a Math::BigInt from an octal string.
-
-sub from_oct {
-    my $self    = shift;
-    my $selfref = ref $self;
-    my $class   = $selfref || $self;
-
-    my $str = shift;
-
-    # If called as a class method, initialize a new object.
-
-    $self = $class -> bzero() unless $selfref;
-
-    if ($str =~ s/
-                     ^
-                     ( [+-]? )
-                     (
-                         [0-7]*
-                         ( _ [0-7]+ )*
-                     )
-                     $
-                 //x)
-    {
-        # Get a "clean" version of the string, i.e., non-emtpy and with no
-        # underscores or invalid characters.
-
-        my $sign = $1;
-        my $chrs = $2;
-        $chrs =~ tr/_//d;
-        $chrs = '0' unless CORE::length $chrs;
-
-        # The library method requires a prefix.
-
-        $self->{value} = $CALC->_from_oct('0' . $chrs);
-
-        # Place the sign.
+sub _register_callback {
+    my ($class, $callback) = @_;
 
-        if ($sign eq '-' && ! $CALC->_is_zero($self->{value})) {
-            $self->{sign} = '-';
-        }
-
-        return $self;
+    if (ref($callback) ne 'CODE') {
+        Carp::croak("$callback is not a coderef");
     }
-
-    # CORE::oct() parses as much as it can, and ignores any trailing garbage.
-    # For backwards compatibility, we return NaN.
-
-    return $self->bnan();
-}
-
-# Create a Math::BigInt from a binary string.
-
-sub from_bin {
-    my $self    = shift;
-    my $selfref = ref $self;
-    my $class   = $selfref || $self;
-
-    my $str = shift;
-
-    # If called as a class method, initialize a new object.
-
-    $self = $class -> bzero() unless $selfref;
-
-    if ($str =~ s/
-                     ^
-                     ( [+-]? )
-                     (0?b)?
-                     (
-                         [01]*
-                         ( _ [01]+ )*
-                     )
-                     $
-                 //x)
-    {
-        # Get a "clean" version of the string, i.e., non-emtpy and with no
-        # underscores or invalid characters.
-
-        my $sign = $1;
-        my $chrs = $3;
-        $chrs =~ tr/_//d;
-        $chrs = '0' unless CORE::length $chrs;
-
-        # The library method requires a prefix.
-
-        $self->{value} = $CALC->_from_bin('0b' . $chrs);
-
-        # Place the sign.
-
-        if ($sign eq '-' && ! $CALC->_is_zero($self->{value})) {
-            $self->{sign} = '-';
-        }
-
-        return $self;
-    }
-
-    # For consistency with from_hex() and from_oct(), we return NaN when the
-    # input is invalid.
-
-    return $self->bnan();
+    $CALLBACKS{$class} = $callback;
 }
 
 sub _split_dec_string {
@@ -3273,8 +3805,7 @@ sub _split_dec_string {
                      ( \D .*? )?
 
                      \z
-                 //x)
-    {
+                 //x) {
         my $leading         = $1;
         my $significand_sgn = $2 || '+';
         my $significand_abs = $3;
@@ -3312,240 +3843,175 @@ sub _split_dec_string {
     return undef;
 }
 
-sub _split
-  {
-  # input: num_str; output: undef for invalid or
-  # (\$mantissa_sign,\$mantissa_value,\$mantissa_fraction,
-  # \$exp_sign,\$exp_value)
-  # Internal, take apart a string and return the pieces.
-  # Strip leading/trailing whitespace, leading zeros, underscore and reject
-  # invalid input.
-  my $x = shift;
-
-  # strip white space at front, also extraneous leading zeros
-  $x =~ s/^\s*([-]?)0*([0-9])/$1$2/g;   # will not strip '  .2'
-  $x =~ s/^\s+//;                       # but this will
-  $x =~ s/\s+$//g;                      # strip white space at end
-
-  # shortcut, if nothing to split, return early
-  if ($x =~ /^[+-]?[0-9]+\z/)
-    {
-    $x =~ s/^([+-])0*([0-9])/$2/; my $sign = $1 || '+';
-    return (\$sign, \$x, \'', \'', \0);
-    }
-
-  # invalid starting char?
-  return if $x !~ /^[+-]?(\.?[0-9]|0b[0-1]|0x[0-9a-fA-F])/;
-
-  return Math::BigInt->from_hex($x) if $x =~ /^[+-]?0x/;        # hex string
-  return Math::BigInt->from_bin($x) if $x =~ /^[+-]?0b/;        # binary string
-
-  # strip underscores between digits
-  $x =~ s/([0-9])_([0-9])/$1$2/g;
-  $x =~ s/([0-9])_([0-9])/$1$2/g;               # do twice for 1_2_3
-
-  # some possible inputs:
-  # 2.1234 # 0.12        # 1          # 1E1 # 2.134E1 # 434E-10 # 1.02009E-2
-  # .2     # 1_2_3.4_5_6 # 1.4E1_2_3  # 1e3 # +.2     # 0e999
-
-  my ($m,$e,$last) = split /[Ee]/,$x;
-  return if defined $last;              # last defined => 1e2E3 or others
-  $e = '0' if !defined $e || $e eq "";
-
-  # sign,value for exponent,mantint,mantfrac
-  my ($es,$ev,$mis,$miv,$mfv);
-  # valid exponent?
-  if ($e =~ /^([+-]?)0*([0-9]+)$/)      # strip leading zeros
+sub _split {
+    # input: num_str; output: undef for invalid or
+    # (\$mantissa_sign, \$mantissa_value, \$mantissa_fraction,
+    # \$exp_sign, \$exp_value)
+    # Internal, take apart a string and return the pieces.
+    # Strip leading/trailing whitespace, leading zeros, underscore and reject
+    # invalid input.
+    my $x = shift;
+
+    # strip white space at front, also extraneous leading zeros
+    $x =~ s/^\s*([-]?)0*([0-9])/$1$2/g; # will not strip '  .2'
+    $x =~ s/^\s+//;                     # but this will
+    $x =~ s/\s+$//g;                    # strip white space at end
+
+    # shortcut, if nothing to split, return early
+    if ($x =~ /^[+-]?[0-9]+\z/) {
+        $x =~ s/^([+-])0*([0-9])/$2/;
+        my $sign = $1 || '+';
+        return (\$sign, \$x, \'', \'', \0);
+    }
+
+    # invalid starting char?
+    return if $x !~ /^[+-]?(\.?[0-9]|0b[0-1]|0x[0-9a-fA-F])/;
+
+    return Math::BigInt->from_hex($x) if $x =~ /^[+-]?0x/; # hex string
+    return Math::BigInt->from_bin($x) if $x =~ /^[+-]?0b/; # binary string
+
+    # strip underscores between digits
+    $x =~ s/([0-9])_([0-9])/$1$2/g;
+    $x =~ s/([0-9])_([0-9])/$1$2/g; # do twice for 1_2_3
+
+    # some possible inputs:
+    # 2.1234 # 0.12        # 1          # 1E1 # 2.134E1 # 434E-10 # 1.02009E-2
+    # .2     # 1_2_3.4_5_6 # 1.4E1_2_3  # 1e3 # +.2     # 0e999
+
+    my ($m, $e, $last) = split /[Ee]/, $x;
+    return if defined $last;    # last defined => 1e2E3 or others
+    $e = '0' if !defined $e || $e eq "";
+
+    # sign, value for exponent, mantint, mantfrac
+    my ($es, $ev, $mis, $miv, $mfv);
+    # valid exponent?
+    if ($e =~ /^([+-]?)0*([0-9]+)$/) # strip leading zeros
     {
-    $es = $1; $ev = $2;
-    # valid mantissa?
-    return if $m eq '.' || $m eq '';
-    my ($mi,$mf,$lastf) = split /\./,$m;
-    return if defined $lastf;           # lastf defined => 1.2.3 or others
-    $mi = '0' if !defined $mi;
-    $mi .= '0' if $mi =~ /^[\-\+]?$/;
-    $mf = '0' if !defined $mf || $mf eq '';
-    if ($mi =~ /^([+-]?)0*([0-9]+)$/)           # strip leading zeros
-      {
-      $mis = $1||'+'; $miv = $2;
-      return unless ($mf =~ /^([0-9]*?)0*$/);   # strip trailing zeros
-      $mfv = $1;
-      # handle the 0e999 case here
-      $ev = 0 if $miv eq '0' && $mfv eq '';
-      return (\$mis,\$miv,\$mfv,\$es,\$ev);
-      }
-    }
-  return; # NaN, not a number
-  }
-
-##############################################################################
-# internal calculation routines (others are in Math::BigInt::Calc etc)
-
-sub __lcm
-  {
-  # (BINT or num_str, BINT or num_str) return BINT
-  # does modify first argument
-  # LCM
-
-  my ($x,$ty) = @_;
-  return $x->bnan() if ($x->{sign} eq $nan) || ($ty->{sign} eq $nan);
-  my $method = ref($x) . '::bgcd';
-  no strict 'refs';
-  $x * $ty / &$method($x,$ty);
-  }
-
-###############################################################################
-# trigonometric functions
-
-sub bpi
-  {
-  # Calculate PI to N digits. Unless upgrading is in effect, returns the
-  # result truncated to an integer, that is, always returns '3'.
-  my ($self,$n) = @_;
-  if (@_ == 1)
-    {
-    # called like Math::BigInt::bpi(10);
-    $n = $self; $self = $class;
+        $es = $1;
+        $ev = $2;
+        # valid mantissa?
+        return if $m eq '.' || $m eq '';
+        my ($mi, $mf, $lastf) = split /\./, $m;
+        return if defined $lastf; # lastf defined => 1.2.3 or others
+        $mi = '0' if !defined $mi;
+        $mi .= '0' if $mi =~ /^[\-\+]?$/;
+        $mf = '0' if !defined $mf || $mf eq '';
+        if ($mi =~ /^([+-]?)0*([0-9]+)$/) # strip leading zeros
+        {
+            $mis = $1 || '+';
+            $miv = $2;
+            return unless ($mf =~ /^([0-9]*?)0*$/); # strip trailing zeros
+            $mfv = $1;
+            # handle the 0e999 case here
+            $ev = 0 if $miv eq '0' && $mfv eq '';
+            return (\$mis, \$miv, \$mfv, \$es, \$ev);
+        }
     }
-  $self = ref($self) if ref($self);
-
-  return $upgrade->new($n) if defined $upgrade;
-
-  # hard-wired to "3"
-  $self->new(3);
-  }
-
-sub bcos
-  {
-  # Calculate cosinus(x) to N digits. Unless upgrading is in effect, returns the
-  # result truncated to an integer.
-  my ($self,$x,@r) = ref($_[0]) ? (undef,@_) : objectify(1,@_);
-
-  return $x if $x->modify('bcos');
-
-  return $x->bnan() if $x->{sign} !~ /^[+-]\z/; # -inf +inf or NaN => NaN
+    return;                     # NaN, not a number
+}
 
-  return $upgrade->new($x)->bcos(@r) if defined $upgrade;
+sub _trailing_zeros {
+    # return the amount of trailing zeros in $x (as scalar)
+    my $x = shift;
+    $x = $class->new($x) unless ref $x;
 
-  require Math::BigFloat;
-  # calculate the result and truncate it to integer
-  my $t = Math::BigFloat->new($x)->bcos(@r)->as_int();
+    return 0 if $x->{sign} !~ /^[+-]$/; # NaN, inf, -inf etc
 
-  $x->bone() if $t->is_one();
-  $x->bzero() if $t->is_zero();
-  $x->round(@r);
-  }
+    $CALC->_zeros($x->{value}); # must handle odd values, 0 etc
+}
 
-sub bsin
-  {
-  # Calculate sinus(x) to N digits. Unless upgrading is in effect, returns the
-  # result truncated to an integer.
-  my ($self,$x,@r) = ref($_[0]) ? (undef,@_) : objectify(1,@_);
+sub _scan_for_nonzero {
+    # internal, used by bround() to scan for non-zeros after a '5'
+    my ($x, $pad, $xs, $len) = @_;
 
-  return $x if $x->modify('bsin');
+    return 0 if $len == 1;      # "5" is trailed by invisible zeros
+    my $follow = $pad - 1;
+    return 0 if $follow > $len || $follow < 1;
 
-  return $x->bnan() if $x->{sign} !~ /^[+-]\z/; # -inf +inf or NaN => NaN
+    # use the string form to check whether only '0's follow or not
+    substr ($xs, -$follow) =~ /[^0]/ ? 1 : 0;
+}
 
-  return $upgrade->new($x)->bsin(@r) if defined $upgrade;
+sub _find_round_parameters {
+    # After any operation or when calling round(), the result is rounded by
+    # regarding the A & P from arguments, local parameters, or globals.
 
-  require Math::BigFloat;
-  # calculate the result and truncate it to integer
-  my $t = Math::BigFloat->new($x)->bsin(@r)->as_int();
+    # !!!!!!! If you change this, remember to change round(), too! !!!!!!!!!!
 
-  $x->bone() if $t->is_one();
-  $x->bzero() if $t->is_zero();
-  $x->round(@r);
-  }
+    # This procedure finds the round parameters, but it is for speed reasons
+    # duplicated in round. Otherwise, it is tested by the testsuite and used
+    # by bdiv().
 
-sub batan2
-  {
-  # calculate arcus tangens of ($y/$x)
+    # returns ($self) or ($self, $a, $p, $r) - sets $self to NaN of both A and P
+    # were requested/defined (locally or globally or both)
 
-  # set up parameters
-  my ($self,$y,$x,@r) = (ref($_[0]),@_);
-  # objectify is costly, so avoid it
-  if ((!ref($_[0])) || (ref($_[0]) ne ref($_[1])))
-    {
-    ($self,$y,$x,@r) = objectify(2,@_);
-    }
+    my ($self, $a, $p, $r, @args) = @_;
+    # $a accuracy, if given by caller
+    # $p precision, if given by caller
+    # $r round_mode, if given by caller
+    # @args all 'other' arguments (0 for unary, 1 for binary ops)
 
-  return $y if $y->modify('batan2');
+    my $class = ref($self);       # find out class of argument(s)
+    no strict 'refs';
 
-  return $y->bnan() if ($y->{sign} eq $nan) || ($x->{sign} eq $nan);
+    # convert to normal scalar for speed and correctness in inner parts
+    $a = $a->can('numify') ? $a->numify() : "$a" if defined $a && ref($a);
+    $p = $p->can('numify') ? $p->numify() : "$p" if defined $p && ref($p);
 
-  # Y    X
-  # != 0 -inf result is +- pi
-  if ($x->is_inf() || $y->is_inf())
-    {
-    # upgrade to BigFloat etc.
-    return $upgrade->new($y)->batan2($upgrade->new($x),@r) if defined $upgrade;
-    if ($y->is_inf())
-      {
-      if ($x->{sign} eq '-inf')
-        {
-        # calculate 3 pi/4 => 2.3.. => 2
-        $y->bone( substr($y->{sign},0,1) );
-        $y->bmul($self->new(2));
-        }
-      elsif ($x->{sign} eq '+inf')
-        {
-        # calculate pi/4 => 0.7 => 0
-        $y->bzero();
-        }
-      else
-        {
-        # calculate pi/2 => 1.5 => 1
-        $y->bone( substr($y->{sign},0,1) );
-        }
-      }
-    else
-      {
-      if ($x->{sign} eq '+inf')
-        {
-        # calculate pi/4 => 0.7 => 0
-        $y->bzero();
+    # now pick $a or $p, but only if we have got "arguments"
+    if (!defined $a) {
+        foreach ($self, @args) {
+            # take the defined one, or if both defined, the one that is smaller
+            $a = $_->{_a} if (defined $_->{_a}) && (!defined $a || $_->{_a} < $a);
         }
-      else
-        {
-        # PI => 3.1415.. => 3
-        $y->bone( substr($y->{sign},0,1) );
-        $y->bmul($self->new(3));
+    }
+    if (!defined $p) {
+        # even if $a is defined, take $p, to signal error for both defined
+        foreach ($self, @args) {
+            # take the defined one, or if both defined, the one that is bigger
+            # -2 > -3, and 3 > 2
+            $p = $_->{_p} if (defined $_->{_p}) && (!defined $p || $_->{_p} > $p);
         }
-      }
-    return $y;
     }
 
-  return $upgrade->new($y)->batan2($upgrade->new($x),@r) if defined $upgrade;
+    # if still none defined, use globals (#2)
+    $a = ${"$class\::accuracy"}  unless defined $a;
+    $p = ${"$class\::precision"} unless defined $p;
 
-  require Math::BigFloat;
-  my $r = Math::BigFloat->new($y)
-                        ->batan2(Math::BigFloat->new($x),@r)
-                        ->as_int();
+    # A == 0 is useless, so undef it to signal no rounding
+    $a = undef if defined $a && $a == 0;
 
-  $x->{value} = $r->{value};
-  $x->{sign} = $r->{sign};
+    # no rounding today?
+    return ($self) unless defined $a || defined $p; # early out
 
-  $x;
-  }
+    # set A and set P is an fatal error
+    return ($self->bnan()) if defined $a && defined $p; # error
 
-sub batan
-  {
-  # Calculate arcus tangens of x to N digits. Unless upgrading is in effect, returns the
-  # result truncated to an integer.
-  my ($self,$x,@r) = ref($_[0]) ? (undef,@_) : objectify(1,@_);
+    $r = ${"$class\::round_mode"} unless defined $r;
+    if ($r !~ /^(even|odd|[+-]inf|zero|trunc|common)$/) {
+        Carp::croak("Unknown round mode '$r'");
+    }
 
-  return $x if $x->modify('batan');
+    $a = int($a) if defined $a;
+    $p = int($p) if defined $p;
 
-  return $x->bnan() if $x->{sign} !~ /^[+-]\z/; # -inf +inf or NaN => NaN
+    ($self, $a, $p, $r);
+}
 
-  return $upgrade->new($x)->batan(@r) if defined $upgrade;
+##############################################################################
+# internal calculation routines (others are in Math::BigInt::Calc etc)
 
-  # calculate the result and truncate it to integer
-  my $t = Math::BigFloat->new($x)->batan(@r);
+sub __lcm {
+    # (BINT or num_str, BINT or num_str) return BINT
+    # does modify first argument
+    # LCM
 
-  $x->{value} = $CALC->_new( $x->as_int()->bstr() );
-  $x->round(@r);
-  }
+    my ($x, $ty) = @_;
+    return $x->bnan() if ($x->{sign} eq $nan) || ($ty->{sign} eq $nan);
+    my $method = ref($x) . '::bgcd';
+    no strict 'refs';
+    $x * $ty / &$method($x, $ty);
+}
 
 ###############################################################################
 # this method returns 0 if the object can be modified, or 1 if not.
@@ -3555,6 +4021,7 @@ sub batan
 sub modify () { 0; }
 
 1;
+
 __END__
 
 =pod
@@ -3568,11 +4035,11 @@ Math::BigInt - Arbitrary size integer/float math package
   use Math::BigInt;
 
   # or make it faster with huge numbers: install (optional)
-  # Math::BigInt::GMP and always use (it will fall back to
+  # Math::BigInt::GMP and always use (it falls back to
   # pure Perl if the GMP library is not installed):
   # (See also the L<MATH LIBRARY> section!)
 
-  # will warn if Math::BigInt::GMP cannot be found
+  # warns if Math::BigInt::GMP cannot be found
   use Math::BigInt lib => 'GMP';
 
   # to suppress the warning use this:
@@ -3582,226 +4049,362 @@ Math::BigInt - Arbitrary size integer/float math package
   # use Math::BigInt only => 'GMP';
 
   my $str = '1234567890';
-  my @values = (64,74,18);
+  my @values = (64, 74, 18);
   my $n = 1; my $sign = '-';
 
-  # Number creation
-  my $x = Math::BigInt->new($str);      # defaults to 0
-  my $y = $x->copy();                   # make a true copy
-  my $nan  = Math::BigInt->bnan();      # create a NotANumber
-  my $zero = Math::BigInt->bzero();     # create a +0
-  my $inf = Math::BigInt->binf();       # create a +inf
-  my $inf = Math::BigInt->binf('-');    # create a -inf
-  my $one = Math::BigInt->bone();       # create a +1
-  my $mone = Math::BigInt->bone('-');   # create a -1
-
-  my $pi = Math::BigInt->bpi();         # returns '3'
-                                        # see Math::BigFloat::bpi()
-
-  $h = Math::BigInt->new('0x123');      # from hexadecimal
-  $b = Math::BigInt->new('0b101');      # from binary
-  $o = Math::BigInt->from_oct('0101');  # from octal
-  $h = Math::BigInt->from_hex('cafe');  # from hexadecimal
-  $b = Math::BigInt->from_bin('0101');  # from binary
-
-  # Testing (don't modify their arguments)
-  # (return true if the condition is met, otherwise false)
-
-  $x->is_zero();        # if $x is +0
-  $x->is_nan();         # if $x is NaN
-  $x->is_one();         # if $x is +1
-  $x->is_one('-');      # if $x is -1
-  $x->is_odd();         # if $x is odd
-  $x->is_even();        # if $x is even
-  $x->is_pos();         # if $x > 0
-  $x->is_neg();         # if $x < 0
-  $x->is_inf($sign);    # if $x is +inf, or -inf (sign is default '+')
-  $x->is_int();         # if $x is an integer (not a float)
-
-  # comparing and digit/sign extraction
-  $x->bcmp($y);         # compare numbers (undef,<0,=0,>0)
-  $x->bacmp($y);        # compare absolutely (undef,<0,=0,>0)
-  $x->sign();           # return the sign, either +,- or NaN
-  $x->digit($n);        # return the nth digit, counting from right
-  $x->digit(-$n);       # return the nth digit, counting from left
-
-  # The following all modify their first argument. If you want to pre-
-  # serve $x, use $z = $x->copy()->bXXX($y); See under L<CAVEATS> for
-  # why this is necessary when mixing $a = $b assignments with non-over-
-  # loaded math.
-
-  $x->bzero();          # set $x to 0
-  $x->bnan();           # set $x to NaN
-  $x->bone();           # set $x to +1
-  $x->bone('-');        # set $x to -1
-  $x->binf();           # set $x to inf
-  $x->binf('-');        # set $x to -inf
-
-  $x->bneg();           # negation
-  $x->babs();           # absolute value
-  $x->bsgn();           # sign function (-1, 0, 1, or NaN)
-  $x->bnorm();          # normalize (no-op in BigInt)
-  $x->bnot();           # two's complement (bit wise not)
-  $x->binc();           # increment $x by 1
-  $x->bdec();           # decrement $x by 1
-
-  $x->badd($y);         # addition (add $y to $x)
-  $x->bsub($y);         # subtraction (subtract $y from $x)
-  $x->bmul($y);         # multiplication (multiply $x by $y)
-  $x->bdiv($y);         # divide, set $x to quotient
-                        # return (quo,rem) or quo if scalar
-
-  $x->bmuladd($y,$z);   # $x = $x * $y + $z
-
-  $x->bmod($y);         # modulus (x % y)
-  $x->bmodpow($y,$mod); # modular exponentiation (($x ** $y) % $mod)
-  $x->bmodinv($mod);    # modular multiplicative inverse
-  $x->bpow($y);         # power of arguments (x ** y)
-  $x->blsft($y);        # left shift in base 2
-  $x->brsft($y);        # right shift in base 2
-                        # returns (quo,rem) or quo if in sca-
-                        # lar context
-  $x->blsft($y,$n);     # left shift by $y places in base $n
-  $x->brsft($y,$n);     # right shift by $y places in base $n
-                        # returns (quo,rem) or quo if in sca-
-                        # lar context
-
-  $x->band($y);         # bitwise and
-  $x->bior($y);         # bitwise inclusive or
-  $x->bxor($y);         # bitwise exclusive or
-  $x->bnot();           # bitwise not (two's complement)
-
-  $x->bsqrt();          # calculate square-root
-  $x->broot($y);        # $y'th root of $x (e.g. $y == 3 => cubic root)
-  $x->bfac();           # factorial of $x (1*2*3*4*..$x)
-
-  $x->bnok($y);         # x over y (binomial coefficient n over k)
-
-  $x->blog();           # logarithm of $x to base e (Euler's number)
-  $x->blog($base);      # logarithm of $x to base $base (f.i. 2)
-  $x->bexp();           # calculate e ** $x where e is Euler's number
-
-  $x->round($A,$P,$mode);  # round to accuracy or precision using
-                           # mode $mode
-  $x->bround($n);          # accuracy: preserve $n digits
-  $x->bfround($n);         # $n > 0: round $nth digits,
-                           # $n < 0: round to the $nth digit after the
-                           # dot, no-op for BigInts
-
-  # The following do not modify their arguments in BigInt (are no-ops),
-  # but do so in BigFloat:
-
-  $x->bfloor();            # round towards minus infinity
-  $x->bceil();             # round towards plus infinity
-  $x->bint();              # round towards zero
-
-  # The following do not modify their arguments:
-
-  # greatest common divisor (no OO style)
-  my $gcd = Math::BigInt::bgcd(@values);
-  # lowest common multiple (no OO style)
-  my $lcm = Math::BigInt::blcm(@values);
-
+  # Configuration methods (may be used as class methods and instance methods)
+
+  Math::BigInt->accuracy();     # get class accuracy
+  Math::BigInt->accuracy($n);   # set class accuracy
+  Math::BigInt->precision();    # get class precision
+  Math::BigInt->precision($n);  # set class precision
+  Math::BigInt->round_mode();   # get class rounding mode
+  Math::BigInt->round_mode($m); # set global round mode, must be one of
+                                # 'even', 'odd', '+inf', '-inf', 'zero',
+                                # 'trunc', or 'common'
+  Math::BigInt->config();       # return hash with configuration
+
+  # Constructor methods (when the class methods below are used as instance
+  # methods, the value is assigned the invocand)
+
+  $x = Math::BigInt->new($str);         # defaults to 0
+  $x = Math::BigInt->new('0x123');      # from hexadecimal
+  $x = Math::BigInt->new('0b101');      # from binary
+  $x = Math::BigInt->from_hex('cafe');  # from hexadecimal
+  $x = Math::BigInt->from_oct('377');   # from octal
+  $x = Math::BigInt->from_bin('1101');  # from binary
+  $x = Math::BigInt->bzero();           # create a +0
+  $x = Math::BigInt->bone();            # create a +1
+  $x = Math::BigInt->bone('-');         # create a -1
+  $x = Math::BigInt->binf();            # create a +inf
+  $x = Math::BigInt->binf('-');         # create a -inf
+  $x = Math::BigInt->bnan();            # create a Not-A-Number
+  $x = Math::BigInt->bpi();             # returns pi
+
+  $y = $x->copy();         # make a copy (unlike $y = $x)
+  $y = $x->as_int();       # return as a Math::BigInt
+
+  # Boolean methods (these don't modify the invocand)
+
+  $x->is_zero();          # if $x is 0
+  $x->is_one();           # if $x is +1
+  $x->is_one("+");        # ditto
+  $x->is_one("-");        # if $x is -1
+  $x->is_inf();           # if $x is +inf or -inf
+  $x->is_inf("+");        # if $x is +inf
+  $x->is_inf("-");        # if $x is -inf
+  $x->is_nan();           # if $x is NaN
+
+  $x->is_positive();      # if $x > 0
+  $x->is_pos();           # ditto
+  $x->is_negative();      # if $x < 0
+  $x->is_neg();           # ditto
+
+  $x->is_odd();           # if $x is odd
+  $x->is_even();          # if $x is even
+  $x->is_int();           # if $x is an integer
+
+  # Comparison methods
+
+  $x->bcmp($y);           # compare numbers (undef, < 0, == 0, > 0)
+  $x->bacmp($y);          # compare absolutely (undef, < 0, == 0, > 0)
+  $x->beq($y);            # true if and only if $x == $y
+  $x->bne($y);            # true if and only if $x != $y
+  $x->blt($y);            # true if and only if $x < $y
+  $x->ble($y);            # true if and only if $x <= $y
+  $x->bgt($y);            # true if and only if $x > $y
+  $x->bge($y);            # true if and only if $x >= $y
+
+  # Arithmetic methods
+
+  $x->bneg();             # negation
+  $x->babs();             # absolute value
+  $x->bsgn();             # sign function (-1, 0, 1, or NaN)
+  $x->bnorm();            # normalize (no-op)
+  $x->binc();             # increment $x by 1
+  $x->bdec();             # decrement $x by 1
+  $x->badd($y);           # addition (add $y to $x)
+  $x->bsub($y);           # subtraction (subtract $y from $x)
+  $x->bmul($y);           # multiplication (multiply $x by $y)
+  $x->bmuladd($y,$z);     # $x = $x * $y + $z
+  $x->bdiv($y);           # division (floored), set $x to quotient
+                          # return (quo,rem) or quo if scalar
+  $x->btdiv($y);          # division (truncated), set $x to quotient
+                          # return (quo,rem) or quo if scalar
+  $x->bmod($y);           # modulus (x % y)
+  $x->btmod($y);          # modulus (truncated)
+  $x->bmodinv($mod);      # modular multiplicative inverse
+  $x->bmodpow($y,$mod);   # modular exponentiation (($x ** $y) % $mod)
+  $x->bpow($y);           # power of arguments (x ** y)
+  $x->blog();             # logarithm of $x to base e (Euler's number)
+  $x->blog($base);        # logarithm of $x to base $base (e.g., base 2)
+  $x->bexp();             # calculate e ** $x where e is Euler's number
+  $x->bnok($y);           # x over y (binomial coefficient n over k)
+  $x->bsin();             # sine
+  $x->bcos();             # cosine
+  $x->batan();            # inverse tangent
+  $x->batan2($y);         # two-argument inverse tangent
+  $x->bsqrt();            # calculate square-root
+  $x->broot($y);          # $y'th root of $x (e.g. $y == 3 => cubic root)
+  $x->bfac();             # factorial of $x (1*2*3*4*..$x)
+
+  $x->blsft($n);          # left shift $n places in base 2
+  $x->blsft($n,$b);       # left shift $n places in base $b
+                          # returns (quo,rem) or quo (scalar context)
+  $x->brsft($n);          # right shift $n places in base 2
+  $x->brsft($n,$b);       # right shift $n places in base $b
+                          # returns (quo,rem) or quo (scalar context)
+
+  # Bitwise methods
+
+  $x->band($y);           # bitwise and
+  $x->bior($y);           # bitwise inclusive or
+  $x->bxor($y);           # bitwise exclusive or
+  $x->bnot();             # bitwise not (two's complement)
+
+  # Rounding methods
+  $x->round($A,$P,$mode); # round to accuracy or precision using
+                          # rounding mode $mode
+  $x->bround($n);         # accuracy: preserve $n digits
+  $x->bfround($n);        # $n > 0: round to $nth digit left of dec. point
+                          # $n < 0: round to $nth digit right of dec. point
+  $x->bfloor();           # round towards minus infinity
+  $x->bceil();            # round towards plus infinity
+  $x->bint();             # round towards zero
+
+  # Other mathematical methods
+
+  $x->bgcd($y);            # greatest common divisor
+  $x->blcm($y);            # least common multiple
+
+  # Object property methods (do not modify the invocand)
+
+  $x->sign();              # the sign, either +, - or NaN
+  $x->digit($n);           # the nth digit, counting from the right
+  $x->digit(-$n);          # the nth digit, counting from the left
   $x->length();            # return number of digits in number
   ($xl,$f) = $x->length(); # length of number and length of fraction
                            # part, latter is always 0 digits long
-                           # for BigInts
-
-  $x->exponent();         # return exponent as BigInt
-  $x->mantissa();         # return (signed) mantissa as BigInt
-  $x->parts();            # return (mantissa,exponent) as BigInt
-  $x->copy();             # make a true copy of $x (unlike $y = $x;)
-  $x->as_int();           # return as BigInt (in BigInt: same as copy())
-  $x->numify();           # return as scalar (might overflow!)
-
-  # conversion to string (do not modify their argument)
-  $x->bstr();         # normalized string (e.g. '3')
-  $x->bsstr();        # norm. string in scientific notation (e.g. '3E0')
+                           # for Math::BigInt objects
+  $x->mantissa();          # return (signed) mantissa as a Math::BigInt
+  $x->exponent();          # return exponent as a Math::BigInt
+  $x->parts();             # return (mantissa,exponent) as a Math::BigInt
+  $x->sparts();            # mantissa and exponent (as integers)
+  $x->nparts();            # mantissa and exponent (normalised)
+  $x->eparts();            # mantissa and exponent (engineering notation)
+  $x->dparts();            # integer and fraction part
+
+  # Conversion methods (do not modify the invocand)
+
+  $x->bstr();         # decimal notation, possibly zero padded
+  $x->bsstr();        # string in scientific notation with integers
+  $x->bnstr();        # string in normalized notation
+  $x->bestr();        # string in engineering notation
+  $x->bdstr();        # string in decimal notation
   $x->as_hex();       # as signed hexadecimal string with prefixed 0x
   $x->as_bin();       # as signed binary string with prefixed 0b
   $x->as_oct();       # as signed octal string with prefixed 0
 
+  # Other conversion methods
 
-  # precision and accuracy (see section about rounding for more)
-  $x->precision();       # return P of $x (or global, if P of $x undef)
-  $x->precision($n);     # set P of $x to $n
-  $x->accuracy();        # return A of $x (or global, if A of $x undef)
-  $x->accuracy($n);      # set A $x to $n
-
-  # Global methods
-  Math::BigInt->precision();   # get/set global P for all BigInt objects
-  Math::BigInt->accuracy();    # get/set global A for all BigInt objects
-  Math::BigInt->round_mode();  # get/set global round mode, one of
-                               # 'even', 'odd', '+inf', '-inf', 'zero',
-                               # 'trunc' or 'common'
-  Math::BigInt->config();      # return hash containing configuration
+  $x->numify();           # return as scalar (might overflow or underflow)
 
 =head1 DESCRIPTION
 
-All operators (including basic math operations) are overloaded if you
-declare your big integers as
+Math::BigInt provides support for arbitrary precision integers. Overloading is
+also provided for Perl operators.
 
-  $i = Math::BigInt -> new('123_456_789_123_456_789');
+=head2 Input
 
-Operations with overloaded operators preserve the arguments which is
-exactly what you expect.
+Input values to these routines may be any scalar number or string that looks
+like a number and represents an integer.
 
-=head2 Input
+=over
 
-Input values to these routines may be any string, that looks like a number
-and results in an integer, including hexadecimal and binary numbers.
+=item *
 
-Scalars holding numbers may also be passed, but note that non-integer numbers
-may already have lost precision due to the conversion to float. Quote
-your input if you want BigInt to see all the digits:
+Leading and trailing whitespace is ignored.
 
-        $x = Math::BigInt->new(12345678890123456789);   # bad
-        $x = Math::BigInt->new('12345678901234567890'); # good
+=item *
 
-You can include one underscore between any two digits.
+Leading and trailing zeros are ignored.
 
-This means integer values like 1.01E2 or even 1000E-2 are also accepted.
-Non-integer values result in NaN.
+=item *
+
+If the string has a "0x" prefix, it is interpreted as a hexadecimal number.
+
+=item *
 
-Hexadecimal (prefixed with "0x") and binary numbers (prefixed with "0b")
-are accepted, too. Please note that octal numbers are not recognized
-by new(), so the following will print "123":
+If the string has a "0b" prefix, it is interpreted as a binary number.
 
-        perl -MMath::BigInt -le 'print Math::BigInt->new("0123")'
+=item *
+
+One underline is allowed between any two digits.
 
-To convert an octal number, use from_oct();
+=item *
 
-        perl -MMath::BigInt -le 'print Math::BigInt->from_oct("0123")'
+If the string can not be interpreted, NaN is returned.
 
-Currently, Math::BigInt::new() defaults to 0, while Math::BigInt::new('')
+=back
+
+Octal numbers are typically prefixed by "0", but since leading zeros are
+stripped, these methods can not automatically recognize octal numbers, so use
+the constructor from_oct() to intepret octal strings.
+
+Some examples of valid string input
+
+    Input string                Resulting value
+    123                         123
+    1.23e2                      123
+    12300e-2                    123
+    0xcafe                      51966
+    0b1101                      13
+    67_538_754                  67538754
+    -4_5_6.7_8_9e+0_1_0         -4567890000000
+
+Input given as scalar numbers might lose precision. Quote your input to ensure
+that no digits are lost:
+
+    $x = Math::BigInt->new( 56789012345678901234 );   # bad
+    $x = Math::BigInt->new('56789012345678901234');   # good
+
+Currently, Math::BigInt->new() defaults to 0, while Math::BigInt->new('')
 results in 'NaN'. This might change in the future, so use always the following
 explicit forms to get a zero or NaN:
 
-        $zero = Math::BigInt->bzero();
-        $nan = Math::BigInt->bnan();
-
-C<bnorm()> on a BigInt object is now effectively a no-op, since the numbers
-are always stored in normalized form. If passed a string, creates a BigInt
-object from the input.
+    $zero = Math::BigInt->bzero();
+    $nan  = Math::BigInt->bnan();
 
 =head2 Output
 
-Output values are BigInt objects (normalized), except for the methods which
-return a string (see L</SYNOPSIS>).
+Output values are usually Math::BigInt objects.
 
-Some routines (C<is_odd()>, C<is_even()>, C<is_zero()>, C<is_one()>,
-C<is_nan()>, etc.) return true or false, while others (C<bcmp()>, C<bacmp()>)
-return either undef (if NaN is involved), <0, 0 or >0 and are suited for sort.
+Boolean operators C<is_zero()>, C<is_one()>, C<is_inf()>, etc. return true or
+false.
+
+Comparison operators C<bcmp()> and C<bacmp()>) return -1, 0, 1, or
+undef.
 
 =head1 METHODS
 
-Each of the methods below (except config(), accuracy() and precision())
-accepts three additional parameters. These arguments C<$A>, C<$P> and C<$R>
-are C<accuracy>, C<precision> and C<round_mode>. Please see the section about
+=head2 Configuration methods
+
+Each of the methods below (except config(), accuracy() and precision()) accepts
+three additional parameters. These arguments C<$A>, C<$P> and C<$R> are
+C<accuracy>, C<precision> and C<round_mode>. Please see the section about
 L</ACCURACY and PRECISION> for more information.
 
+Setting a class variable effects all object instance that are created
+afterwards.
+
 =over
 
+=item accuracy()
+
+    Math::BigInt->accuracy(5);      # set class accuracy
+    $x->accuracy(5);                # set instance accuracy
+
+    $A = Math::BigInt->accuracy();  # get class accuracy
+    $A = $x->accuracy();            # get instance accuracy
+
+Set or get the accuracy, i.e., the number of significant digits. The accuracy
+must be an integer. If the accuracy is set to C<undef>, no rounding is done.
+
+Alternatively, one can round the results explicitly using one of L</round()>,
+L</bround()> or L</bfround()> or by passing the desired accuracy to the method
+as an additional parameter:
+
+    my $x = Math::BigInt->new(30000);
+    my $y = Math::BigInt->new(7);
+    print scalar $x->copy()->bdiv($y, 2);               # prints 4300
+    print scalar $x->copy()->bdiv($y)->bround(2);       # prints 4300
+
+Please see the section about L</ACCURACY and PRECISION> for further details.
+
+    $y = Math::BigInt->new(1234567);    # $y is not rounded
+    Math::BigInt->accuracy(4);          # set class accuracy to 4
+    $x = Math::BigInt->new(1234567);    # $x is rounded automatically
+    print "$x $y";                      # prints "1235000 1234567"
+
+    print $x->accuracy();       # prints "4"
+    print $y->accuracy();       # also prints "4", since
+                                #   class accuracy is 4
+
+    Math::BigInt->accuracy(5);  # set class accuracy to 5
+    print $x->accuracy();       # prints "4", since instance
+                                #   accuracy is 4
+    print $y->accuracy();       # prints "5", since no instance
+                                #   accuracy, and class accuracy is 5
+
+Note: Each class has it's own globals separated from Math::BigInt, but it is
+possible to subclass Math::BigInt and make the globals of the subclass aliases
+to the ones from Math::BigInt.
+
+=item precision()
+
+    Math::BigInt->precision(-2);     # set class precision
+    $x->precision(-2);               # set instance precision
+
+    $P = Math::BigInt->precision();  # get class precision
+    $P = $x->precision();            # get instance precision
+
+Set or get the precision, i.e., the place to round relative to the decimal
+point. The precision must be a integer. Setting the precision to $P means that
+each number is rounded up or down, depending on the rounding mode, to the
+nearest multiple of 10**$P. If the precision is set to C<undef>, no rounding is
+done.
+
+You might want to use L</accuracy()> instead. With L</accuracy()> you set the
+number of digits each result should have, with L</precision()> you set the
+place where to round.
+
+Please see the section about L</ACCURACY and PRECISION> for further details.
+
+    $y = Math::BigInt->new(1234567);    # $y is not rounded
+    Math::BigInt->precision(4);         # set class precision to 4
+    $x = Math::BigInt->new(1234567);    # $x is rounded automatically
+    print $x;                           # prints "1230000"
+
+Note: Each class has its own globals separated from Math::BigInt, but it is
+possible to subclass Math::BigInt and make the globals of the subclass aliases
+to the ones from Math::BigInt.
+
+=item div_scale()
+
+Set/get the fallback accuracy. This is the accuracy used when neither accuracy
+nor precision is set explicitly. It is used when a computation might otherwise
+attempt to return an infinite number of digits.
+
+=item round_mode()
+
+Set/get the rounding mode.
+
+=item upgrade()
+
+Set/get the class for upgrading. When a computation might result in a
+non-integer, the operands are upgraded to this class. This is used for instance
+by L<bignum>. The default is C<undef>, thus the following operation creates
+a Math::BigInt, not a Math::BigFloat:
+
+    my $i = Math::BigInt->new(123);
+    my $f = Math::BigFloat->new('123.1');
+
+    print $i + $f, "\n";                # prints 246
+
+=item downgrade()
+
+Set/get the class for downgrading. The default is C<undef>. Downgrading is not
+done by Math::BigInt.
+
+=item modify()
+
+    $x->modify('bpowd');
+
+This method returns 0 if the object can be modified with the given operation,
+or 1 if not.
+
+This is used for instance by L<Math::BigInt::Constant>.
+
 =item config()
 
     use Data::Dumper;
@@ -3843,289 +4446,286 @@ appropriate information.
 
 The following values can be set by passing C<config()> a reference to a hash:
 
-        trap_inf trap_nan
-        upgrade downgrade precision accuracy round_mode div_scale
+        accuracy precision round_mode div_scale
+        upgrade downgrade trap_inf trap_nan
 
 Example:
 
-        $new_cfg = Math::BigInt->config(
-            { trap_inf => 1, precision => 5 }
-        );
+    $new_cfg = Math::BigInt->config(
+        { trap_inf => 1, precision => 5 }
+    );
 
-=item accuracy()
+=back
 
-    $x->accuracy(5);         # local for $x
-    CLASS->accuracy(5);      # global for all members of CLASS
-                             # Note: This also applies to new()!
+=head2 Constructor methods
 
-    $A = $x->accuracy();     # read out accuracy that affects $x
-    $A = CLASS->accuracy();  # read out global accuracy
+=over
 
-Set or get the global or local accuracy, aka how many significant digits the
-results have. If you set a global accuracy, then this also applies to new()!
+=item new()
 
-Warning! The accuracy I<sticks>, e.g. once you created a number under the
-influence of C<< CLASS->accuracy($A) >>, all results from math operations with
-that number will also be rounded.
+    $x = Math::BigInt->new($str,$A,$P,$R);
 
-In most cases, you should probably round the results explicitly using one of
-L</round()>, L</bround()> or L</bfround()> or by passing the desired accuracy
-to the math operation as additional parameter:
+Creates a new Math::BigInt object from a scalar or another Math::BigInt object.
+The input is accepted as decimal, hexadecimal (with leading '0x') or binary
+(with leading '0b').
 
-    my $x = Math::BigInt->new(30000);
-    my $y = Math::BigInt->new(7);
-    print scalar $x->copy()->bdiv($y, 2);               # print 4300
-    print scalar $x->copy()->bdiv($y)->bround(2);       # print 4300
+See L</Input> for more info on accepted input formats.
 
-Please see the section about L</ACCURACY and PRECISION> for further details.
+=item from_hex()
 
-Value must be greater than zero. Pass an undef value to disable it:
-
-    $x->accuracy(undef);
-    Math::BigInt->accuracy(undef);
-
-Returns the current accuracy. For C<< $x->accuracy() >> it will return either
-the local accuracy, or if not defined, the global. This means the return value
-represents the accuracy that will be in effect for $x:
-
-    $y = Math::BigInt->new(1234567);       # unrounded
-    print Math::BigInt->accuracy(4),"\n";  # set 4, print 4
-    $x = Math::BigInt->new(123456);        # $x will be automatic-
-                                           # ally rounded!
-    print "$x $y\n";                       # '123500 1234567'
-    print $x->accuracy(),"\n";             # will be 4
-    print $y->accuracy(),"\n";             # also 4, since
-                                           # global is 4
-    print Math::BigInt->accuracy(5),"\n";  # set to 5, print 5
-    print $x->accuracy(),"\n";             # still 4
-    print $y->accuracy(),"\n";             # 5, since global is 5
-
-Note: Works also for subclasses like Math::BigFloat. Each class has it's own
-globals separated from Math::BigInt, but it is possible to subclass
-Math::BigInt and make the globals of the subclass aliases to the ones from
-Math::BigInt.
+    $x = Math::BigInt->from_hex("0xcafe");    # input is hexadecimal
 
-=item precision()
+Interpret input as a hexadecimal string. A "0x" or "x" prefix is optional. A
+single underscore character may be placed right after the prefix, if present,
+or between any two digits. If the input is invalid, a NaN is returned.
 
-    $x->precision(-2);          # local for $x, round at the second
-                                # digit right of the dot
-    $x->precision(2);           # ditto, round at the second digit
-                                # left of the dot
+=item from_oct()
 
-    CLASS->precision(5);        # Global for all members of CLASS
-                                # This also applies to new()!
-    CLASS->precision(-5);       # ditto
+    $x = Math::BigInt->from_oct("0775");      # input is octal
 
-    $P = CLASS->precision();    # read out global precision
-    $P = $x->precision();       # read out precision that affects $x
+Interpret the input as an octal string and return the corresponding value. A
+"0" (zero) prefix is optional. A single underscore character may be placed
+right after the prefix, if present, or between any two digits. If the input is
+invalid, a NaN is returned.
 
-Note: You probably want to use L</accuracy()> instead. With L</accuracy()> you
-set the number of digits each result should have, with L</precision()> you
-set the place where to round!
+=item from_bin()
 
-C<precision()> sets or gets the global or local precision, aka at which digit
-before or after the dot to round all results. A set global precision also
-applies to all newly created numbers!
+    $x = Math::BigInt->from_bin("0b10011");   # input is binary
 
-In Math::BigInt, passing a negative number precision has no effect since no
-numbers have digits after the dot. In L<Math::BigFloat>, it will round all
-results to P digits after the dot.
+Interpret the input as a binary string. A "0b" or "b" prefix is optional. A
+single underscore character may be placed right after the prefix, if present,
+or between any two digits. If the input is invalid, a NaN is returned.
 
-Please see the section about L</ACCURACY and PRECISION> for further details.
+=item bzero()
 
-Pass an undef value to disable it:
+    $x = Math::BigInt->bzero();
+    $x->bzero();
 
-    $x->precision(undef);
-    Math::BigInt->precision(undef);
+Returns a new Math::BigInt object representing zero. If used as an instance
+method, assigns the value to the invocand.
 
-Returns the current precision. For C<< $x->precision() >> it will return either
-the local precision of $x, or if not defined, the global. This means the return
-value represents the prevision that will be in effect for $x:
+=item bone()
 
-    $y = Math::BigInt->new(1234567);        # unrounded
-    print Math::BigInt->precision(4),"\n";  # set 4, print 4
-    $x = Math::BigInt->new(123456);  # will be automatically rounded
-    print $x;                               # print "120000"!
+    $x = Math::BigInt->bone();          # +1
+    $x = Math::BigInt->bone("+");       # +1
+    $x = Math::BigInt->bone("-");       # -1
+    $x->bone();                         # +1
+    $x->bone("+");                      # +1
+    $x->bone('-');                      # -1
 
-Note: Works also for subclasses like L<Math::BigFloat>. Each class has its
-own globals separated from Math::BigInt, but it is possible to subclass
-Math::BigInt and make the globals of the subclass aliases to the ones from
-Math::BigInt.
+Creates a new Math::BigInt object representing one. The optional argument is
+either '-' or '+', indicating whether you want plus one or minus one. If used
+as an instance method, assigns the value to the invocand.
 
-=item brsft()
+=item binf()
 
-    $x->brsft($y,$n);
+    $x = Math::BigInt->binf($sign);
 
-Shifts $x right by $y in base $n. Default is base 2, used are usually 10 and
-2, but others work, too.
+Creates a new Math::BigInt object representing infinity. The optional argument
+is either '-' or '+', indicating whether you want infinity or minus infinity.
+If used as an instance method, assigns the value to the invocand.
 
-Right shifting usually amounts to dividing $x by $n ** $y and truncating the
-result:
+    $x->binf();
+    $x->binf('-');
 
+=item bnan()
 
-    $x = Math::BigInt->new(10);
-    $x->brsft(1);                       # same as $x >> 1: 5
-    $x = Math::BigInt->new(1234);
-    $x->brsft(2,10);                    # result 12
+    $x = Math::BigInt->bnan();
 
-There is one exception, and that is base 2 with negative $x:
+Creates a new Math::BigInt object representing NaN (Not A Number). If used as
+an instance method, assigns the value to the invocand.
 
+    $x->bnan();
 
-    $x = Math::BigInt->new(-5);
-    print $x->brsft(1);
+=item bpi()
 
-This will print -3, not -2 (as it would if you divide -5 by 2 and truncate the
-result).
+    $x = Math::BigInt->bpi(100);        # 3
+    $x->bpi(100);                       # 3
 
-=item new()
+Creates a new Math::BigInt object representing PI. If used as an instance
+method, assigns the value to the invocand. With Math::BigInt this always
+returns 3.
 
-    $x = Math::BigInt->new($str,$A,$P,$R);
+If upgrading is in effect, returns PI, rounded to N digits with the current
+rounding mode:
 
-Creates a new BigInt object from a scalar or another BigInt object. The
-input is accepted as decimal, hex (with leading '0x') or binary (with leading
-'0b').
+    use Math::BigFloat;
+    use Math::BigInt upgrade => "Math::BigFloat";
+    print Math::BigInt->bpi(3), "\n";           # 3.14
+    print Math::BigInt->bpi(100), "\n";         # 3.1415....
 
-See L</Input> for more info on accepted input formats.
+=item copy()
 
-=item from_oct()
+    $x->copy();         # make a true copy of $x (unlike $y = $x)
 
-    $x = Math::BigInt->from_oct("0775");      # input is octal
+=item as_int()
 
-Interpret the input as an octal string and return the corresponding value. A
-"0" (zero) prefix is optional. A single underscore character may be placed
-right after the prefix, if present, or between any two digits. If the input is
-invalid, a NaN is returned.
+=item as_number()
 
-=item from_hex()
+These methods are called when Math::BigInt encounters an object it doesn't know
+how to handle. For instance, assume $x is a Math::BigInt, or subclass thereof,
+and $y is defined, but not a Math::BigInt, or subclass thereof. If you do
 
-    $x = Math::BigInt->from_hex("0xcafe");    # input is hexadecimal
+    $x -> badd($y);
 
-Interpret input as a hexadecimal string. A "0x" or "x" prefix is optional. A
-single underscore character may be placed right after the prefix, if present,
-or between any two digits. If the input is invalid, a NaN is returned.
+$y needs to be converted into an object that $x can deal with. This is done by
+first checking if $y is something that $x might be upgraded to. If that is the
+case, no further attempts are made. The next is to see if $y supports the
+method C<as_int()>. If it does, C<as_int()> is called, but if it doesn't, the
+next thing is to see if $y supports the method C<as_number()>. If it does,
+C<as_number()> is called. The method C<as_int()> (and C<as_number()>) is
+expected to return either an object that has the same class as $x, a subclass
+thereof, or a string that C<ref($x)-E<gt>new()> can parse to create an object.
 
-=item from_bin()
+C<as_number()> is an alias to C<as_int()>. C<as_number> was introduced in
+v1.22, while C<as_int()> was introduced in v1.68.
 
-    $x = Math::BigInt->from_bin("0b10011");   # input is binary
+In Math::BigInt, C<as_int()> has the same effect as C<copy()>.
 
-Interpret the input as a binary string. A "0b" or "b" prefix is optional. A
-single underscore character may be placed right after the prefix, if present,
-or between any two digits. If the input is invalid, a NaN is returned.
+=back
 
-=item bnan()
+=head2 Boolean methods
 
-    $x = Math::BigInt->bnan();
+None of these methods modify the invocand object.
 
-Creates a new BigInt object representing NaN (Not A Number).
-If used on an object, it will set it to NaN:
+=over
 
-    $x->bnan();
+=item is_zero()
 
-=item bzero()
+    $x->is_zero();              # true if $x is 0
 
-    $x = Math::BigInt->bzero();
+Returns true if the invocand is zero and false otherwise.
 
-Creates a new BigInt object representing zero.
-If used on an object, it will set it to zero:
+=item is_one( [ SIGN ])
 
-    $x->bzero();
+    $x->is_one();               # true if $x is +1
+    $x->is_one("+");            # ditto
+    $x->is_one("-");            # true if $x is -1
 
-=item binf()
+Returns true if the invocand is one and false otherwise.
 
-    $x = Math::BigInt->binf($sign);
+=item is_inf( [ SIGN ] )
 
-Creates a new BigInt object representing infinity. The optional argument is
-either '-' or '+', indicating whether you want infinity or minus infinity.
-If used on an object, it will set it to infinity:
+    $x->is_inf();               # true if $x is +inf
+    $x->is_inf("+");            # ditto
+    $x->is_inf("-");            # true if $x is -inf
 
-    $x->binf();
-    $x->binf('-');
+Returns true if the invocand is infinite and false otherwise.
 
-=item bone()
+=item is_nan()
 
-    $x = Math::BigInt->binf($sign);
+    $x->is_nan();               # true if $x is NaN
 
-Creates a new BigInt object representing one. The optional argument is
-either '-' or '+', indicating whether you want one or minus one.
-If used on an object, it will set it to one:
+=item is_positive()
 
-    $x->bone();         # +1
-    $x->bone('-');              # -1
+=item is_pos()
 
-=item is_one()/is_zero()/is_nan()/is_inf()
+    $x->is_positive();          # true if > 0
+    $x->is_pos();               # ditto
 
-    $x->is_zero();              # true if arg is +0
-    $x->is_nan();               # true if arg is NaN
-    $x->is_one();               # true if arg is +1
-    $x->is_one('-');            # true if arg is -1
-    $x->is_inf();               # true if +inf
-    $x->is_inf('-');            # true if -inf (sign is default '+')
+Returns true if the invocand is positive and false otherwise. A C<NaN> is
+neither positive nor negative.
 
-These methods all test the BigInt for being one specific value and return
-true or false depending on the input. These are faster than doing something
-like:
+=item is_negative()
 
-    if ($x == 0)
+=item is_neg()
 
-=item is_pos()/is_neg()/is_positive()/is_negative()
+    $x->is_negative();          # true if < 0
+    $x->is_neg();               # ditto
 
-    $x->is_pos();                       # true if > 0
-    $x->is_neg();                       # true if < 0
+Returns true if the invocand is negative and false otherwise. A C<NaN> is
+neither positive nor negative.
 
-The methods return true if the argument is positive or negative, respectively.
-C<NaN> is neither positive nor negative, while C<+inf> counts as positive, and
-C<-inf> is negative. A C<zero> is neither positive nor negative.
+=item is_odd()
 
-These methods are only testing the sign, and not the value.
+    $x->is_odd();               # true if odd, false for even
 
-C<is_positive()> and C<is_negative()> are aliases to C<is_pos()> and
-C<is_neg()>, respectively. C<is_positive()> and C<is_negative()> were
-introduced in v1.36, while C<is_pos()> and C<is_neg()> were only introduced
-in v1.68.
+Returns true if the invocand is odd and false otherwise. C<NaN>, C<+inf>, and
+C<-inf> are neither odd nor even.
 
-=item is_odd()/is_even()/is_int()
+=item is_even()
 
-    $x->is_odd();               # true if odd, false for even
-    $x->is_even();              # true if even, false for odd
-    $x->is_int();               # true if $x is an integer
+    $x->is_even();              # true if $x is even
 
-The return true when the argument satisfies the condition. C<NaN>, C<+inf>,
+Returns true if the invocand is even and false otherwise. C<NaN>, C<+inf>,
 C<-inf> are not integers and are neither odd nor even.
 
-In BigInt, all numbers except C<NaN>, C<+inf> and C<-inf> are integers.
+=item is_int()
+
+    $x->is_int();               # true if $x is an integer
+
+Returns true if the invocand is an integer and false otherwise. C<NaN>,
+C<+inf>, C<-inf> are not integers.
+
+=back
+
+=head2 Comparison methods
+
+None of these methods modify the invocand object. Note that a C<NaN> is neither
+less than, greater than, or equal to anything else, even a C<NaN>.
+
+=over
 
 =item bcmp()
 
     $x->bcmp($y);
 
-Compares $x with $y and takes the sign into account.
-Returns -1, 0, 1 or undef.
+Returns -1, 0, 1 depending on whether $x is less than, equal to, or grater than
+$y. Returns undef if any operand is a NaN.
 
 =item bacmp()
 
     $x->bacmp($y);
 
-Compares $x with $y while ignoring their sign. Returns -1, 0, 1 or undef.
+Returns -1, 0, 1 depending on whether the absolute value of $x is less than,
+equal to, or grater than the absolute value of $y. Returns undef if any operand
+is a NaN.
 
-=item sign()
+=item beq()
 
-    $x->sign();
+    $x -> beq($y);
 
-Return the sign, of $x, meaning either C<+>, C<->, C<-inf>, C<+inf> or NaN.
+Returns true if and only if $x is equal to $y, and false otherwise.
 
-If you want $x to have a certain sign, use one of the following methods:
+=item bne()
 
-    $x->babs();                 # '+'
-    $x->babs()->bneg();         # '-'
-    $x->bnan();                 # 'NaN'
-    $x->binf();                 # '+inf'
-    $x->binf('-');              # '-inf'
+    $x -> bne($y);
 
-=item digit()
+Returns true if and only if $x is not equal to $y, and false otherwise.
 
-    $x->digit($n);       # return the nth digit, counting from right
+=item blt()
 
-If C<$n> is negative, returns the digit counting from left.
+    $x -> blt($y);
+
+Returns true if and only if $x is equal to $y, and false otherwise.
+
+=item ble()
+
+    $x -> ble($y);
+
+Returns true if and only if $x is less than or equal to $y, and false
+otherwise.
+
+=item bgt()
+
+    $x -> bgt($y);
+
+Returns true if and only if $x is greater than $y, and false otherwise.
+
+=item bge()
+
+    $x -> bge($y);
+
+Returns true if and only if $x is greater than or equal to $y, and false
+otherwise.
+
+=back
+
+=head2 Arithmetic methods
+
+These methods modify the invocand object and returns it.
+
+=over
 
 =item bneg()
 
@@ -4153,15 +4753,8 @@ number is negative, zero, or positive, respectively. Does not modify NaNs.
 
     $x->bnorm();                        # normalize (no-op)
 
-=item bnot()
-
-    $x->bnot();
-
-Two's complement (bitwise not). This is equivalent to
-
-    $x->binc()->bneg();
-
-but faster.
+Normalize the number. This is a no-op and is provided only for backwards
+compatibility.
 
 =item binc()
 
@@ -4195,18 +4788,57 @@ This method was added in v1.87 of Math::BigInt (June 2007).
 
     $x->bdiv($y);               # divide, set $x to quotient
 
-Returns $x divided by $y. In list context, does floored division (F-division),
-where the quotient is the greatest integer less than or equal to the quotient
-of the two operands. Consequently, the remainder is either zero or has the same
-sign as the second operand. In scalar context, only the quotient is returned.
+Divides $x by $y by doing floored division (F-division), where the quotient is
+the floored (rounded towards negative infinity) quotient of the two operands.
+In list context, returns the quotient and the remainder. The remainder is
+either zero or has the same sign as the second operand. In scalar context, only
+the quotient is returned.
+
+The quotient is always the greatest integer less than or equal to the
+real-valued quotient of the two operands, and the remainder (when it is
+non-zero) always has the same sign as the second operand; so, for example,
+
+      1 /  4  => ( 0,  1)
+      1 / -4  => (-1, -3)
+     -3 /  4  => (-1,  1)
+     -3 / -4  => ( 0, -3)
+    -11 /  2  => (-5,  1)
+     11 / -2  => (-5, -1)
+
+The behavior of the overloaded operator % agrees with the behavior of Perl's
+built-in % operator (as documented in the perlop manpage), and the equation
+
+    $x == ($x / $y) * $y + ($x % $y)
+
+holds true for any finite $x and finite, non-zero $y.
+
+Perl's "use integer" might change the behaviour of % and / for scalars. This is
+because under 'use integer' Perl does what the underlying C library thinks is
+right, and this varies. However, "use integer" does not change the way things
+are done with Math::BigInt objects.
+
+=item btdiv()
+
+    $x->btdiv($y);              # divide, set $x to quotient
+
+Divides $x by $y by doing truncated division (T-division), where quotient is
+the truncated (rouneded towards zero) quotient of the two operands. In list
+context, returns the quotient and the remainder. The remainder is either zero
+or has the same sign as the first operand. In scalar context, only the quotient
+is returned.
 
 =item bmod()
 
     $x->bmod($y);               # modulus (x % y)
 
-Returns $x modulo $y. When $x is finite, and $y is finite and non-zero, the
-result is identical to the remainder after floored division (F-division), i.e.,
-identical to the result from Perl's % operator.
+Returns $x modulo $y, i.e., the remainder after floored division (F-division).
+This method is like Perl's % operator. See L</bdiv()>.
+
+=item btmod()
+
+    $x->btmod($y);              # modulus
+
+Returns the remainer after truncated division (T-division). See L</btdiv()>.
 
 =item bmodinv()
 
@@ -4249,19 +4881,31 @@ is exactly equivalent to
 
 =item bpow()
 
-    $x->bpow($y);                     # power of arguments (x ** y)
+    $x->bpow($y);               # power of arguments (x ** y)
+
+C<bpow()> (and the rounding functions) now modifies the first argument and
+returns it, unlike the old code which left it alone and only returned the
+result. This is to be consistent with C<badd()> etc. The first three modifies
+$x, the last one won't:
+
+    print bpow($x,$i),"\n";         # modify $x
+    print $x->bpow($i),"\n";        # ditto
+    print $x **= $i,"\n";           # the same
+    print $x ** $i,"\n";            # leave $x alone
+
+The form C<$x **= $y> is faster than C<$x = $x ** $y;>, though.
 
 =item blog()
 
-    $x->blog($base, $accuracy);   # logarithm of x to the base $base
+    $x->blog($base, $accuracy);         # logarithm of x to the base $base
 
 If C<$base> is not defined, Euler's number (e) is used:
 
-    print $x->blog(undef, 100);       # log(x) to 100 digits
+    print $x->blog(undef, 100);         # log(x) to 100 digits
 
 =item bexp()
 
-    $x->bexp($accuracy);              # calculate e ** X
+    $x->bexp($accuracy);                # calculate e ** X
 
 Calculates the expression C<e ** $x> where C<e> is Euler's number.
 
@@ -4271,31 +4915,26 @@ See also L</blog()>.
 
 =item bnok()
 
-    $x->bnok($y);         # x over y (binomial coefficient n over k)
+    $x->bnok($y);               # x over y (binomial coefficient n over k)
 
 Calculates the binomial coefficient n over k, also called the "choose"
 function. The result is equivalent to:
 
-        ( n )      n!
-        | - |  = -------
-        ( k )    k!(n-k)!
+    ( n )      n!
+    | - |  = -------
+    ( k )    k!(n-k)!
 
 This method was added in v1.84 of Math::BigInt (April 2007).
 
-=item bpi()
-
-    print Math::BigInt->bpi(100), "\n";         # 3
+=item bsin()
 
-Returns PI truncated to an integer, with the argument being ignored. This means
-under BigInt this always returns C<3>.
+    my $x = Math::BigInt->new(1);
+    print $x->bsin(100), "\n";
 
-If upgrading is in effect, returns PI, rounded to N digits with the
-current rounding mode:
+Calculate the sine of $x, modifying $x in place.
 
-    use Math::BigFloat;
-    use Math::BigInt upgrade => Math::BigFloat;
-    print Math::BigInt->bpi(3), "\n";           # 3.14
-    print Math::BigInt->bpi(100), "\n";         # 3.1415....
+In Math::BigInt, unless upgrading is in effect, the result is truncated to an
+integer.
 
 This method was added in v1.87 of Math::BigInt (June 2007).
 
@@ -4304,21 +4943,21 @@ This method was added in v1.87 of Math::BigInt (June 2007).
     my $x = Math::BigInt->new(1);
     print $x->bcos(100), "\n";
 
-Calculate the cosinus of $x, modifying $x in place.
+Calculate the cosine of $x, modifying $x in place.
 
-In BigInt, unless upgrading is in effect, the result is truncated to an
+In Math::BigInt, unless upgrading is in effect, the result is truncated to an
 integer.
 
 This method was added in v1.87 of Math::BigInt (June 2007).
 
-=item bsin()
+=item batan()
 
-    my $x = Math::BigInt->new(1);
-    print $x->bsin(100), "\n";
+    my $x = Math::BigFloat->new(0.5);
+    print $x->batan(100), "\n";
 
-Calculate the sinus of $x, modifying $x in place.
+Calculate the arcus tangens of $x, modifying $x in place.
 
-In BigInt, unless upgrading is in effect, the result is truncated to an
+In Math::BigInt, unless upgrading is in effect, the result is truncated to an
 integer.
 
 This method was added in v1.87 of Math::BigInt (June 2007).
@@ -4331,32 +4970,61 @@ This method was added in v1.87 of Math::BigInt (June 2007).
 
 Calculate the arcus tangens of C<$y> divided by C<$x>, modifying $y in place.
 
-In BigInt, unless upgrading is in effect, the result is truncated to an
+In Math::BigInt, unless upgrading is in effect, the result is truncated to an
 integer.
 
 This method was added in v1.87 of Math::BigInt (June 2007).
 
-=item batan()
+=item bsqrt()
 
-    my $x = Math::BigFloat->new(0.5);
-    print $x->batan(100), "\n";
+    $x->bsqrt();                # calculate square-root
 
-Calculate the arcus tangens of $x, modifying $x in place.
+C<bsqrt()> returns the square root truncated to an integer.
 
-In BigInt, unless upgrading is in effect, the result is truncated to an
-integer.
+If you want a better approximation of the square root, then use:
 
-This method was added in v1.87 of Math::BigInt (June 2007).
+    $x = Math::BigFloat->new(12);
+    Math::BigFloat->precision(0);
+    Math::BigFloat->round_mode('even');
+    print $x->copy->bsqrt(),"\n";           # 4
 
-=item blsft()
+    Math::BigFloat->precision(2);
+    print $x->bsqrt(),"\n";                 # 3.46
+    print $x->bsqrt(3),"\n";                # 3.464
+
+=item broot()
+
+    $x->broot($N);
+
+Calculates the N'th root of C<$x>.
+
+=item bfac()
 
-    $x->blsft($y);              # left shift in base 2
-    $x->blsft($y,$n);           # left shift, in base $n (like 10)
+    $x->bfac();                 # factorial of $x (1*2*3*4*..*$x)
 
 =item brsft()
 
-    $x->brsft($y);              # right shift in base 2
-    $x->brsft($y,$n);           # right shift, in base $n (like 10)
+    $x->brsft($n);              # right shift $n places in base 2
+    $x->brsft($n, $b);          # right shift $n places in base $b
+
+The latter is equivalent to
+
+    $x -> bdiv($b -> copy() -> bpow($n))
+
+=item blsft()
+
+    $x->blsft($n);              # left shift $n places in base 2
+    $x->blsft($n, $b);          # left shift $n places in base $b
+
+The latter is equivalent to
+
+    $x -> bmul($b -> copy() -> bpow($n))
+
+=back
+
+=head2 Bitwise methods
+
+=over
 
 =item band()
 
@@ -4374,19 +5042,15 @@ This method was added in v1.87 of Math::BigInt (June 2007).
 
     $x->bnot();                 # bitwise not (two's complement)
 
-=item bsqrt()
-
-    $x->bsqrt();                # calculate square-root
-
-=item broot()
+Two's complement (bitwise not). This is equivalent to, but faster than,
 
-    $x->broot($N);
+    $x->binc()->bneg();
 
-Calculates the N'th root of C<$x>.
+=back
 
-=item bfac()
+=head2 Rounding methods
 
-    $x->bfac();                 # factorial of $x (1*2*3*4*..$x)
+=over
 
 =item round()
 
@@ -4399,178 +5063,264 @@ C<$round_mode>.
 
     $x->bround($N);               # accuracy: preserve $N digits
 
+Rounds $x to an accuracy of $N digits.
+
 =item bfround()
 
     $x->bfround($N);
 
-If N is > 0, rounds to the Nth digit from the left. If N < 0, rounds to
-the Nth digit after the dot. Since BigInts are integers, the case N < 0
-is a no-op for them.
+Rounds to a multiple of 10**$N. Examples:
 
-Examples:
+    Input            N          Result
 
-        Input           N               Result
-        ===================================================
-        123456.123456   3               123500
-        123456.123456   2               123450
-        123456.123456   -2              123456.12
-        123456.123456   -3              123456.123
+    123456.123456    3          123500
+    123456.123456    2          123450
+    123456.123456   -2          123456.12
+    123456.123456   -3          123456.123
 
 =item bfloor()
 
     $x->bfloor();
 
-Round $x towards minus infinity (i.e., set $x to the largest integer less than
-or equal to $x). This is a no-op in BigInt, but changes $x in BigFloat, if $x
-is not an integer.
+Round $x towards minus infinity, i.e., set $x to the largest integer less than
+or equal to $x.
 
 =item bceil()
 
     $x->bceil();
 
-Round $x towards plus infinity (i.e., set $x to the smallest integer greater
-than or equal to $x). This is a no-op in BigInt, but changes $x in BigFloat, if
-$x is not an integer.
+Round $x towards plus infinity, i.e., set $x to the smallest integer greater
+than or equal to $x).
 
 =item bint()
 
     $x->bint();
 
-Round $x towards zero. This is a no-op in BigInt, but changes $x in BigFloat,
-if $x is not an integer.
+Round $x towards zero.
+
+=back
+
+=head2 Other mathematical methods
+
+=over
 
 =item bgcd()
 
-    bgcd(@values);           # greatest common divisor (no OO style)
+    $x -> bgcd($y);             # GCD of $x and $y
+    $x -> bgcd($y, $z, ...);    # GCD of $x, $y, $z, ...
+
+Returns the greatest common divisor (GCD).
 
 =item blcm()
 
-    blcm(@values);           # lowest common multiple (no OO style)
+    $x -> blcm($y);             # LCM of $x and $y
+    $x -> blcm($y, $z, ...);    # LCM of $x, $y, $z, ...
+
+Returns the least common multiple (LCM).
+
+=back
+
+=head2 Object property methods
+
+=over
+
+=item sign()
+
+    $x->sign();
+
+Return the sign, of $x, meaning either C<+>, C<->, C<-inf>, C<+inf> or NaN.
+
+If you want $x to have a certain sign, use one of the following methods:
+
+    $x->babs();                 # '+'
+    $x->babs()->bneg();         # '-'
+    $x->bnan();                 # 'NaN'
+    $x->binf();                 # '+inf'
+    $x->binf('-');              # '-inf'
+
+=item digit()
+
+    $x->digit($n);       # return the nth digit, counting from right
+
+If C<$n> is negative, returns the digit counting from left.
 
 =item length()
 
     $x->length();
-    ($xl,$fl) = $x->length();
+    ($xl, $fl) = $x->length();
 
-Returns the number of digits in the decimal representation of the number.
-In list context, returns the length of the integer and fraction part. For
-BigInt's, the length of the fraction part will always be 0.
+Returns the number of digits in the decimal representation of the number. In
+list context, returns the length of the integer and fraction part. For
+Math::BigInt objects, the length of the fraction part is always 0.
 
-=item exponent()
+The following probably doesn't do what you expect:
 
-    $x->exponent();
+    $c = Math::BigInt->new(123);
+    print $c->length(),"\n";                # prints 30
+
+It prints both the number of digits in the number and in the fraction part
+since print calls C<length()> in list context. Use something like:
 
-Return the exponent of $x as BigInt.
+    print scalar $c->length(),"\n";         # prints 3
 
 =item mantissa()
 
     $x->mantissa();
 
-Return the signed mantissa of $x as BigInt.
+Return the signed mantissa of $x as a Math::BigInt.
+
+=item exponent()
+
+    $x->exponent();
+
+Return the exponent of $x as a Math::BigInt.
 
 =item parts()
 
-    $x->parts();        # return (mantissa,exponent) as BigInt
+    $x->parts();
 
-=item copy()
+Returns the significand (mantissa) and the exponent as integers. In
+Math::BigFloat, both are returned as Math::BigInt objects.
 
-    $x->copy();         # make a true copy of $x (unlike $y = $x;)
+=item sparts()
 
-=item as_int()
+Returns the significand (mantissa) and the exponent as integers. In scalar
+context, only the significand is returned. The significand is the integer with
+the smallest absolute value. The output of C<sparts()> corresponds to the
+output from C<bsstr()>.
 
-=item as_number()
+In Math::BigInt, this method is identical to C<parts()>.
 
-These methods are called when Math::BigInt encounters an object it doesn't know
-how to handle. For instance, assume $x is a Math::BigInt, or subclass thereof,
-and $y is defined, but not a Math::BigInt, or subclass thereof. If you do
+=item nparts()
 
-    $x -> badd($y);
+Returns the significand (mantissa) and exponent corresponding to normalized
+notation. In scalar context, only the significand is returned. For finite
+non-zero numbers, the significand's absolute value is greater than or equal to
+1 and less than 10. The output of C<nparts()> corresponds to the output from
+C<bnstr()>. In Math::BigInt, if the significand can not be represented as an
+integer, upgrading is performed or NaN is returned.
 
-$y needs to be converted into an object that $x can deal with. This is done by
-first checking if $y is something that $x might be upgraded to. If that is the
-case, no further attempts are made. The next is to see if $y supports the
-method C<as_int()>. If it does, C<as_int()> is called, but if it doesn't, the
-next thing is to see if $y supports the method C<as_number()>. If it does,
-C<as_number()> is called. The method C<as_int()> (and C<as_number()>) is
-expected to return either an object that has the same class as $x, a subclass
-thereof, or a string that C<ref($x)-E<gt>new()> can parse to create an object.
+=item eparts()
 
-C<as_number()> is an alias to C<as_int()>. C<as_number> was introduced in
-v1.22, while C<as_int()> was introduced in v1.68.
+Returns the significand (mantissa) and exponent corresponding to engineering
+notation. In scalar context, only the significand is returned. For finite
+non-zero numbers, the significand's absolute value is greater than or equal to
+1 and less than 1000, and the exponent is a multiple of 3. The output of
+C<eparts()> corresponds to the output from C<bestr()>. In Math::BigInt, if the
+significand can not be represented as an integer, upgrading is performed or NaN
+is returned.
 
-In Math::BigInt, C<as_int()> has the same effect as C<copy()>.
+=item dparts()
 
-=item bstr()
+Returns the integer part and the fraction part. If the fraction part can not be
+represented as an integer, upgrading is performed or NaN is returned. The
+output of C<dparts()> corresponds to the output from C<bdstr()>.
+
+=back
 
-    $x->bstr();
+=head2 String conversion methods
 
-Returns a normalized string representation of C<$x>.
+=over
+
+=item bstr()
+
+Returns a string representing the number using decimal notation. In
+Math::BigFloat, the output is zero padded according to the current accuracy or
+precision, if any of those are defined.
 
 =item bsstr()
 
-    $x->bsstr();     # normalized string in scientific notation
+Returns a string representing the number using scientific notation where both
+the significand (mantissa) and the exponent are integers. The output
+corresponds to the output from C<sparts()>.
 
-=item as_hex()
+      123 is returned as "123e+0"
+     1230 is returned as "123e+1"
+    12300 is returned as "123e+2"
+    12000 is returned as "12e+3"
+    10000 is returned as "1e+4"
 
-    $x->as_hex();    # as signed hexadecimal string with prefixed 0x
+=item bnstr()
 
-=item as_bin()
+Returns a string representing the number using normalized notation, the most
+common variant of scientific notation. For finite non-zero numbers, the
+absolute value of the significand is less than or equal to 1 and less than 10.
+The output corresponds to the output from C<nparts()>.
 
-    $x->as_bin();    # as signed binary string with prefixed 0b
+      123 is returned as "1.23e+2"
+     1230 is returned as "1.23e+3"
+    12300 is returned as "1.23e+4"
+    12000 is returned as "1.2e+4"
+    10000 is returned as "1e+4"
 
-=item as_oct()
+=item bestr()
 
-    $x->as_oct();    # as signed octal string with prefixed 0
+Returns a string representing the number using engineering notation. For finite
+non-zero numbers, the absolute value of the significand is less than or equal
+to 1 and less than 1000, and the exponent is a multiple of 3. The output
+corresponds to the output from C<eparts()>.
 
-=item numify()
+      123 is returned as "123e+0"
+     1230 is returned as "1.23e+3"
+    12300 is returned as "12.3e+3"
+    12000 is returned as "12e+3"
+    10000 is returned as "10e+3"
 
-        print $x->numify();
+=item bdstr()
 
-This returns a normal Perl scalar from $x. It is used automatically
-whenever a scalar is needed, for instance in array index operations.
+Returns a string representing the number using decimal notation. The output
+corresponds to the output from C<dparts()>.
 
-This loses precision, to avoid this use L</as_int()> instead.
+      123 is returned as "123"
+     1230 is returned as "1230"
+    12300 is returned as "12300"
+    12000 is returned as "12000"
+    10000 is returned as "10000"
 
-=item modify()
+=item as_hex()
 
-    $x->modify('bpowd');
+    $x->as_hex();
 
-This method returns 0 if the object can be modified with the given
-operation, or 1 if not.
+Returns a string representing the number using hexadecimal notation. The output
+is prefixed by "0x".
 
-This is used for instance by L<Math::BigInt::Constant>.
+=item as_bin()
 
-=item upgrade()/downgrade()
+    $x->as_bin();
 
-Set/get the class for downgrade/upgrade operations. Thuis is used
-for instance by L<bignum>. The defaults are '', thus the following
-operation will create a BigInt, not a BigFloat:
+Returns a string representing the number using binary notation. The output is
+prefixed by "0b".
 
-        my $i = Math::BigInt->new(123);
-        my $f = Math::BigFloat->new('123.1');
+=item as_oct()
 
-        print $i + $f,"\n";                     # print 246
+    $x->as_oct();
 
-=item div_scale()
+Returns a string representing the number using octal notation. The output is
+prefixed by "0".
 
-Set/get the number of digits for the default precision in divide
-operations.
+=back
 
-=item round_mode()
+=head2 Other conversion methods
+
+=over
 
-Set/get the current round mode.
+=item numify()
+
+    print $x->numify();
+
+Returns a Perl scalar from $x. It is used automatically whenever a scalar is
+needed, for instance in array index operations.
 
 =back
 
 =head1 ACCURACY and PRECISION
 
-Since version v1.33, Math::BigInt and Math::BigFloat have full support for
-accuracy and precision based rounding, both automatically after every
-operation, as well as manually.
+Math::BigInt and Math::BigFloat have full support for accuracy and precision
+based rounding, both automatically after every operation, as well as manually.
 
-This section describes the accuracy/precision handling in Math::Big* as it
-used to be and as it is now, complete with an explanation of all terms and
-abbreviations.
+This section describes the accuracy/precision handling in Math::BigInt and
+Math::BigFloat as it used to be and as it is now, complete with an explanation
+of all terms and abbreviations.
 
 Not yet implemented things (but with correct description) are marked with '!',
 things that need to be answered are marked with '?'.
@@ -4579,49 +5329,48 @@ In the next paragraph follows a short description of terms used here (because
 these may differ from terms used by others people or documentation).
 
 During the rest of this document, the shortcuts A (for accuracy), P (for
-precision), F (fallback) and R (rounding mode) will be used.
+precision), F (fallback) and R (rounding mode) are be used.
 
 =head2 Precision P
 
-A fixed number of digits before (positive) or after (negative)
-the decimal point. For example, 123.45 has a precision of -2. 0 means an
-integer like 123 (or 120). A precision of 2 means two digits to the left
-of the decimal point are zero, so 123 with P = 1 becomes 120. Note that
-numbers with zeros before the decimal point may have different precisions,
-because 1200 can have p = 0, 1 or 2 (depending on what the initial value
-was). It could also have p < 0, when the digits after the decimal point
-are zero.
-
-The string output (of floating point numbers) will be padded with zeros:
-
-        Initial value   P       A       Result          String
-        ------------------------------------------------------------
-        1234.01         -3              1000            1000
-        1234            -2              1200            1200
-        1234.5          -1              1230            1230
-        1234.001        1               1234            1234.0
-        1234.01         0               1234            1234
-        1234.01         2               1234.01         1234.01
-        1234.01         5               1234.01         1234.01000
-
-For BigInts, no padding occurs.
+Precision is a fixed number of digits before (positive) or after (negative) the
+decimal point. For example, 123.45 has a precision of -2. 0 means an integer
+like 123 (or 120). A precision of 2 means at least two digits to the left of
+the decimal point are zero, so 123 with P = 1 becomes 120. Note that numbers
+with zeros before the decimal point may have different precisions, because 1200
+can have P = 0, 1 or 2 (depending on what the initial value was). It could also
+have p < 0, when the digits after the decimal point are zero.
+
+The string output (of floating point numbers) is padded with zeros:
+
+    Initial value    P      A       Result          String
+    ------------------------------------------------------------
+    1234.01         -3              1000            1000
+    1234            -2              1200            1200
+    1234.5          -1              1230            1230
+    1234.001         1              1234            1234.0
+    1234.01          0              1234            1234
+    1234.01          2              1234.01         1234.01
+    1234.01          5              1234.01         1234.01000
+
+For Math::BigInt objects, no padding occurs.
 
 =head2 Accuracy A
 
-Number of significant digits. Leading zeros are not counted. A
-number may have an accuracy greater than the non-zero digits
-when there are zeros in it or trailing zeros. For example, 123.456 has
-A of 6, 10203 has 5, 123.0506 has 7, 123.450000 has 8 and 0.000123 has 3.
+Number of significant digits. Leading zeros are not counted. A number may have
+an accuracy greater than the non-zero digits when there are zeros in it or
+trailing zeros. For example, 123.456 has A of 6, 10203 has 5, 123.0506 has 7,
+123.45000 has 8 and 0.000123 has 3.
 
-The string output (of floating point numbers) will be padded with zeros:
+The string output (of floating point numbers) is padded with zeros:
 
-        Initial value   P       A       Result          String
-        ------------------------------------------------------------
-        1234.01                 3       1230            1230
-        1234.01                 6       1234.01         1234.01
-        1234.1                  8       1234.1          1234.1000
+    Initial value    P      A       Result          String
+    ------------------------------------------------------------
+    1234.01                 3       1230            1230
+    1234.01                 6       1234.01         1234.01
+    1234.1                  8       1234.1          1234.1000
 
-For BigInts, no padding occurs.
+For Math::BigInt objects, no padding occurs.
 
 =head2 Fallback F
 
@@ -4630,74 +5379,67 @@ dividing numbers.
 
 =head2 Rounding mode R
 
-When rounding a number, different 'styles' or 'kinds'
-of rounding are possible. (Note that random rounding, as in
-Math::Round, is not implemented.)
+When rounding a number, different 'styles' or 'kinds' of rounding are possible.
+(Note that random rounding, as in Math::Round, is not implemented.)
 
 =over
 
 =item 'trunc'
 
-truncation invariably removes all digits following the
-rounding place, replacing them with zeros. Thus, 987.65 rounded
-to tens (P=1) becomes 980, and rounded to the fourth sigdig
-becomes 987.6 (A=4). 123.456 rounded to the second place after the
-decimal point (P=-2) becomes 123.46.
-
-All other implemented styles of rounding attempt to round to the
-"nearest digit." If the digit D immediately to the right of the
-rounding place (skipping the decimal point) is greater than 5, the
-number is incremented at the rounding place (possibly causing a
-cascade of incrementation): e.g. when rounding to units, 0.9 rounds
-to 1, and -19.9 rounds to -20. If D < 5, the number is similarly
-truncated at the rounding place: e.g. when rounding to units, 0.4
+truncation invariably removes all digits following the rounding place,
+replacing them with zeros. Thus, 987.65 rounded to tens (P = 1) becomes 980,
+and rounded to the fourth sigdig becomes 987.6 (A = 4). 123.456 rounded to the
+second place after the decimal point (P = -2) becomes 123.46.
+
+All other implemented styles of rounding attempt to round to the "nearest
+digit." If the digit D immediately to the right of the rounding place (skipping
+the decimal point) is greater than 5, the number is incremented at the rounding
+place (possibly causing a cascade of incrementation): e.g. when rounding to
+units, 0.9 rounds to 1, and -19.9 rounds to -20. If D < 5, the number is
+similarly truncated at the rounding place: e.g. when rounding to units, 0.4
 rounds to 0, and -19.4 rounds to -19.
 
-However the results of other styles of rounding differ if the
-digit immediately to the right of the rounding place (skipping the
-decimal point) is 5 and if there are no digits, or no digits other
-than 0, after that 5. In such cases:
+However the results of other styles of rounding differ if the digit immediately
+to the right of the rounding place (skipping the decimal point) is 5 and if
+there are no digits, or no digits other than 0, after that 5. In such cases:
 
 =item 'even'
 
-rounds the digit at the rounding place to 0, 2, 4, 6, or 8
-if it is not already. E.g., when rounding to the first sigdig, 0.45
-becomes 0.4, -0.55 becomes -0.6, but 0.4501 becomes 0.5.
+rounds the digit at the rounding place to 0, 2, 4, 6, or 8 if it is not
+already. E.g., when rounding to the first sigdig, 0.45 becomes 0.4, -0.55
+becomes -0.6, but 0.4501 becomes 0.5.
 
 =item 'odd'
 
-rounds the digit at the rounding place to 1, 3, 5, 7, or 9 if
-it is not already. E.g., when rounding to the first sigdig, 0.45
-becomes 0.5, -0.55 becomes -0.5, but 0.5501 becomes 0.6.
+rounds the digit at the rounding place to 1, 3, 5, 7, or 9 if it is not
+already. E.g., when rounding to the first sigdig, 0.45 becomes 0.5, -0.55
+becomes -0.5, but 0.5501 becomes 0.6.
 
 =item '+inf'
 
-round to plus infinity, i.e. always round up. E.g., when
-rounding to the first sigdig, 0.45 becomes 0.5, -0.55 becomes -0.5,
-and 0.4501 also becomes 0.5.
+round to plus infinity, i.e. always round up. E.g., when rounding to the first
+sigdig, 0.45 becomes 0.5, -0.55 becomes -0.5, and 0.4501 also becomes 0.5.
 
 =item '-inf'
 
-round to minus infinity, i.e. always round down. E.g., when
-rounding to the first sigdig, 0.45 becomes 0.4, -0.55 becomes -0.6,
-but 0.4501 becomes 0.5.
+round to minus infinity, i.e. always round down. E.g., when rounding to the
+first sigdig, 0.45 becomes 0.4, -0.55 becomes -0.6, but 0.4501 becomes 0.5.
 
 =item 'zero'
 
-round to zero, i.e. positive numbers down, negative ones up.
-E.g., when rounding to the first sigdig, 0.45 becomes 0.4, -0.55
-becomes -0.5, but 0.4501 becomes 0.5.
+round to zero, i.e. positive numbers down, negative ones up. E.g., when
+rounding to the first sigdig, 0.45 becomes 0.4, -0.55 becomes -0.5, but 0.4501
+becomes 0.5.
 
 =item 'common'
 
-round up if the digit immediately to the right of the rounding place
-is 5 or greater, otherwise round down. E.g., 0.15 becomes 0.2 and
-0.149 becomes 0.1.
+round up if the digit immediately to the right of the rounding place is 5 or
+greater, otherwise round down. E.g., 0.15 becomes 0.2 and 0.149 becomes 0.1.
 
 =back
 
-The handling of A & P in MBI/MBF (the old core code shipped with Perl
-versions <= 5.7.2) is like this:
+The handling of A & P in MBI/MBF (the old core code shipped with Perl versions
+<= 5.7.2) is like this:
 
 =over
 
@@ -4714,7 +5456,7 @@ versions <= 5.7.2) is like this:
     + other operations simply create the same number (bneg etc), or
       more (bmul) of digits
     + rounding/truncating is only done when explicitly calling one
-      of bround or bfround, and never for BigInt (not implemented)
+      of bround or bfround, and never for Math::BigInt (not implemented)
   * bsqrt() simply hands its accuracy argument over to bdiv.
   * the documentation and the comment in the code indicate two
     different ways on how bdiv() determines the maximum number
@@ -4800,10 +5542,10 @@ This is how it works now:
 
   * If A or P are enabled/defined, they are used to round the result of each
     operation according to the rules below
-  * Negative P is ignored in Math::BigInt, since BigInts never have digits
-    after the decimal point
+  * Negative P is ignored in Math::BigInt, since Math::BigInt objects never
+    have digits after the decimal point
   * Math::BigFloat uses Math::BigInt internally, but setting A or P inside
-    Math::BigInt as globals does not tamper with the parts of a BigFloat.
+    Math::BigInt as globals does not tamper with the parts of a Math::BigFloat.
     A flag is used to mark all Math::BigFloat numbers as 'never round'.
 
 =item Precedence
@@ -4925,53 +5667,33 @@ This is how it works now:
 
 =head1 Infinity and Not a Number
 
-While BigInt has extensive handling of inf and NaN, certain quirks remain.
+While Math::BigInt has extensive handling of inf and NaN, certain quirks
+remain.
 
 =over
 
 =item oct()/hex()
 
-These perl routines currently (as of Perl v.5.8.6) cannot handle passed
-inf.
+These perl routines currently (as of Perl v.5.8.6) cannot handle passed inf.
 
-        te@linux:~> perl -wle 'print 2 ** 3333'
-        Inf
-        te@linux:~> perl -wle 'print 2 ** 3333 == 2 ** 3333'
-        1
-        te@linux:~> perl -wle 'print oct(2 ** 3333)'
-        0
-        te@linux:~> perl -wle 'print hex(2 ** 3333)'
-        Illegal hexadecimal digit 'I' ignored at -e line 1.
-        0
+    te@linux:~> perl -wle 'print 2 ** 3333'
+    Inf
+    te@linux:~> perl -wle 'print 2 ** 3333 == 2 ** 3333'
+    1
+    te@linux:~> perl -wle 'print oct(2 ** 3333)'
+    0
+    te@linux:~> perl -wle 'print hex(2 ** 3333)'
+    Illegal hexadecimal digit 'I' ignored at -e line 1.
+    0
 
 The same problems occur if you pass them Math::BigInt->binf() objects. Since
-overloading these routines is not possible, this cannot be fixed from BigInt.
-
-=item ==, !=, <, >, <=, >= with NaNs
-
-BigInt's bcmp() routine currently returns undef to signal that a NaN was
-involved in a comparison. However, the overload code turns that into
-either 1 or '' and thus operations like C<< NaN != NaN >> might return
-wrong values.
-
-=item log(-inf)
-
-C<< log(-inf) >> is highly weird. Since log(-x)=pi*i+log(x), then
-log(-inf)=pi*i+inf. However, since the imaginary part is finite, the real
-infinity "overshadows" it, so the number might as well just be infinity.
-However, the result is a complex number, and since BigInt/BigFloat can only
-have real numbers as results, the result is NaN.
-
-=item exp(), cos(), sin(), atan2()
-
-These all might have problems handling infinity right.
+overloading these routines is not possible, this cannot be fixed from
+Math::BigInt.
 
 =back
 
 =head1 INTERNALS
 
-The actual numbers are stored as unsigned big integers (with separate sign).
-
 You should neither care about nor depend on the internal representation; it
 might change without notice. Use B<ONLY> method calls like C<< $x->sign(); >>
 instead relying on the internal representation.
@@ -4981,35 +5703,34 @@ instead relying on the internal representation.
 Math with the numbers is done (by default) by a module called
 C<Math::BigInt::Calc>. This is equivalent to saying:
 
-        use Math::BigInt try => 'Calc';
+    use Math::BigInt try => 'Calc';
 
 You can change this backend library by using:
 
-        use Math::BigInt try => 'GMP';
+    use Math::BigInt try => 'GMP';
 
-B<Note>: General purpose packages should not be explicit about the library
-to use; let the script author decide which is best.
+B<Note>: General purpose packages should not be explicit about the library to
+use; let the script author decide which is best.
 
-If your script works with huge numbers and Calc is too slow for them,
-you can also for the loading of one of these libraries and if none
-of them can be used, the code will die:
+If your script works with huge numbers and Calc is too slow for them, you can
+also for the loading of one of these libraries and if none of them can be used,
+the code dies:
 
-        use Math::BigInt only => 'GMP,Pari';
+    use Math::BigInt only => 'GMP,Pari';
 
 The following would first try to find Math::BigInt::Foo, then
 Math::BigInt::Bar, and when this also fails, revert to Math::BigInt::Calc:
 
-        use Math::BigInt try => 'Foo,Math::BigInt::Bar';
+    use Math::BigInt try => 'Foo,Math::BigInt::Bar';
 
-The library that is loaded last will be used. Note that this can be
-overwritten at any time by loading a different library, and numbers
-constructed with different libraries cannot be used in math operations
-together.
+The library that is loaded last is used. Note that this can be overwritten at
+any time by loading a different library, and numbers constructed with different
+libraries cannot be used in math operations together.
 
 =head3 What library to use?
 
-B<Note>: General purpose packages should not be explicit about the library
-to use; let the script author decide which is best.
+B<Note>: General purpose packages should not be explicit about the library to
+use; let the script author decide which is best.
 
 L<Math::BigInt::GMP> and L<Math::BigInt::Pari> are in cases involving big
 numbers much faster than Calc, however it is slower when dealing with very
@@ -5031,30 +5752,8 @@ The sign is either '+', '-', 'NaN', '+inf' or '-inf'.
 
 A sign of 'NaN' is used to represent the result when input arguments are not
 numbers or as a result of 0/0. '+inf' and '-inf' represent plus respectively
-minus infinity. You will get '+inf' when dividing a positive number by 0, and
-'-inf' when dividing any negative number by 0.
-
-=head2 mantissa(), exponent() and parts()
-
-C<mantissa()> and C<exponent()> return the said parts of the BigInt such
-that:
-
-        $m = $x->mantissa();
-        $e = $x->exponent();
-        $y = $m * ( 10 ** $e );
-        print "ok\n" if $x == $y;
-
-C<< ($m,$e) = $x->parts() >> is just a shortcut that gives you both of them
-in one go. Both the returned mantissa and exponent have a sign.
-
-Currently, for BigInts C<$e> is always 0, except +inf and -inf, where it is
-C<+inf>; and for NaN, where it is C<NaN>; and for C<$x == 0>, where it is C<1>
-(to be compatible with Math::BigFloat's internal representation of a zero as
-C<0E1>).
-
-C<$m> is currently just a copy of the original number. The relation between
-C<$e> and C<$m> will stay always the same, though their real values might
-change.
+minus infinity. You get '+inf' when dividing a positive number by 0, and '-inf'
+when dividing any negative number by 0.
 
 =head1 EXAMPLES
 
@@ -5064,18 +5763,18 @@ change.
 
   $x = Math::BigInt->bstr("1234")       # string "1234"
   $x = "$x";                            # same as bstr()
-  $x = Math::BigInt->bneg("1234");      # BigInt "-1234"
-  $x = Math::BigInt->babs("-12345");    # BigInt "12345"
-  $x = Math::BigInt->bnorm("-0.00");    # BigInt "0"
-  $x = bigint(1) + bigint(2);           # BigInt "3"
-  $x = bigint(1) + "2";                 # ditto (auto-BigIntify of "2")
-  $x = bigint(1);                       # BigInt "1"
-  $x = $x + 5 / 2;                      # BigInt "3"
-  $x = $x ** 3;                         # BigInt "27"
-  $x *= 2;                              # BigInt "54"
-  $x = Math::BigInt->new(0);            # BigInt "0"
-  $x--;                                 # BigInt "-1"
-  $x = Math::BigInt->badd(4,5)          # BigInt "9"
+  $x = Math::BigInt->bneg("1234");      # Math::BigInt "-1234"
+  $x = Math::BigInt->babs("-12345");    # Math::BigInt "12345"
+  $x = Math::BigInt->bnorm("-0.00");    # Math::BigInt "0"
+  $x = bigint(1) + bigint(2);           # Math::BigInt "3"
+  $x = bigint(1) + "2";                 # ditto (auto-Math::BigIntify of "2")
+  $x = bigint(1);                       # Math::BigInt "1"
+  $x = $x + 5 / 2;                      # Math::BigInt "3"
+  $x = $x ** 3;                         # Math::BigInt "27"
+  $x *= 2;                              # Math::BigInt "54"
+  $x = Math::BigInt->new(0);            # Math::BigInt "0"
+  $x--;                                 # Math::BigInt "-1"
+  $x = Math::BigInt->badd(4,5)          # Math::BigInt "9"
   print $x->bsstr();                    # 9e+0
 
 Examples for rounding:
@@ -5110,67 +5809,67 @@ Examples for converting:
 =head1 Autocreating constants
 
 After C<use Math::BigInt ':constant'> all the B<integer> decimal, hexadecimal
-and binary constants in the given scope are converted to C<Math::BigInt>.
-This conversion happens at compile time.
+and binary constants in the given scope are converted to C<Math::BigInt>. This
+conversion happens at compile time.
 
 In particular,
 
   perl -MMath::BigInt=:constant -e 'print 2**100,"\n"'
 
 prints the integer value of C<2**100>. Note that without conversion of
-constants the expression 2**100 will be calculated as perl scalar.
+constants the expression 2**100 is calculated using Perl scalars.
 
-Please note that strings and floating point constants are not affected,
-so that
+Please note that strings and floating point constants are not affected, so that
 
-        use Math::BigInt qw/:constant/;
+    use Math::BigInt qw/:constant/;
 
-        $x = 1234567890123456789012345678901234567890
-                + 123456789123456789;
-        $y = '1234567890123456789012345678901234567890'
-                + '123456789123456789';
+    $x = 1234567890123456789012345678901234567890
+            + 123456789123456789;
+    $y = '1234567890123456789012345678901234567890'
+            + '123456789123456789';
 
-do not work. You need an explicit Math::BigInt->new() around one of the
-operands. You should also quote large constants to protect loss of precision:
+does not give you what you expect. You need an explicit Math::BigInt->new()
+around one of the operands. You should also quote large constants to protect
+loss of precision:
 
-        use Math::BigInt;
+    use Math::BigInt;
 
-        $x = Math::BigInt->new('1234567889123456789123456789123456789');
+    $x = Math::BigInt->new('1234567889123456789123456789123456789');
 
 Without the quotes Perl would convert the large number to a floating point
-constant at compile time and then hand the result to BigInt, which results in
-an truncated result or a NaN.
+constant at compile time and then hand the result to Math::BigInt, which
+results in an truncated result or a NaN.
 
 This also applies to integers that look like floating point constants:
 
-        use Math::BigInt ':constant';
+    use Math::BigInt ':constant';
 
-        print ref(123e2),"\n";
-        print ref(123.2e2),"\n";
+    print ref(123e2),"\n";
+    print ref(123.2e2),"\n";
 
-will print nothing but newlines. Use either L<bignum> or L<Math::BigFloat>
-to get this to work.
+prints nothing but newlines. Use either L<bignum> or L<Math::BigFloat> to get
+this to work.
 
 =head1 PERFORMANCE
 
 Using the form $x += $y; etc over $x = $x + $y is faster, since a copy of $x
 must be made in the second case. For long numbers, the copy can eat up to 20%
 of the work (in the case of addition/subtraction, less for
-multiplication/division). If $y is very small compared to $x, the form
-$x += $y is MUCH faster than $x = $x + $y since making the copy of $x takes
-more time then the actual addition.
+multiplication/division). If $y is very small compared to $x, the form $x += $y
+is MUCH faster than $x = $x + $y since making the copy of $x takes more time
+then the actual addition.
 
 With a technique called copy-on-write, the cost of copying with overload could
 be minimized or even completely avoided. A test implementation of COW did show
-performance gains for overloaded math, but introduced a performance loss due
-to a constant overhead for all other operations. So Math::BigInt does currently
+performance gains for overloaded math, but introduced a performance loss due to
+a constant overhead for all other operations. So Math::BigInt does currently
 not COW.
 
 The rewritten version of this module (vs. v0.01) is slower on certain
 operations, like C<new()>, C<bstr()> and C<numify()>. The reason are that it
 does now more work and handles much more cases. The time spent in these
-operations is usually gained in the other math operations so that code on
-the average should get (much) faster. If they don't, please contact the author.
+operations is usually gained in the other math operations so that code on the
+average should get (much) faster. If they don't, please contact the author.
 
 Some operations may be slower for small numbers, but are significantly faster
 for big numbers. Other operations are now constant (O(1), like C<bneg()>,
@@ -5199,9 +5898,8 @@ work, as long as a few simple rules are followed:
 =item *
 
 The public API must remain consistent, i.e. if a sub-class is overloading
-addition, the sub-class must use the same name, in this case badd(). The
-reason for this is that Math::BigInt is optimized to call the object methods
-directly.
+addition, the sub-class must use the same name, in this case badd(). The reason
+for this is that Math::BigInt is optimized to call the object methods directly.
 
 =item *
 
@@ -5212,41 +5910,41 @@ additional keys can be added, like C<< $x->{_custom} >>.
 
 Accessor functions are available for all existing object hash keys and should
 be used instead of directly accessing the internal hash keys. The reason for
-this is that Math::BigInt itself has a pluggable interface which permits it
-to support different storage methods.
+this is that Math::BigInt itself has a pluggable interface which permits it to
+support different storage methods.
 
 =back
 
 More complex sub-classes may have to replicate more of the logic internal of
-Math::BigInt if they need to change more basic behaviors. A subclass that
-needs to merely change the output only needs to overload C<bstr()>.
+Math::BigInt if they need to change more basic behaviors. A subclass that needs
+to merely change the output only needs to overload C<bstr()>.
 
 All other object methods and overloaded functions can be directly inherited
 from the parent class.
 
-At the very minimum, any subclass will need to provide its own C<new()> and can
+At the very minimum, any subclass needs to provide its own C<new()> and can
 store additional hash keys in the object. There are also some package globals
 that must be defined, e.g.:
 
-  # Globals
-  $accuracy = undef;
-  $precision = -2;       # round to 2 decimal places
-  $round_mode = 'even';
-  $div_scale = 40;
+    # Globals
+    $accuracy = undef;
+    $precision = -2;       # round to 2 decimal places
+    $round_mode = 'even';
+    $div_scale = 40;
 
 Additionally, you might want to provide the following two globals to allow
 auto-upgrading and auto-downgrading to work correctly:
 
-  $upgrade = undef;
-  $downgrade = undef;
+    $upgrade = undef;
+    $downgrade = undef;
 
 This allows Math::BigInt to correctly retrieve package globals from the
-subclass, like C<$SubClass::precision>.  See t/Math/BigInt/Subclass.pm or
+subclass, like C<$SubClass::precision>. See t/Math/BigInt/Subclass.pm or
 t/Math/BigFloat/SubClass.pm completely functional subclass examples.
 
 Don't forget to
 
-        use overload;
+    use overload;
 
 in your subclass to automatically inherit the overloading from the parent. If
 you like, you can change part of the overloading, look at Math::String for an
@@ -5256,62 +5954,43 @@ example.
 
 When used like this:
 
-        use Math::BigInt upgrade => 'Foo::Bar';
+    use Math::BigInt upgrade => 'Foo::Bar';
 
-certain operations will 'upgrade' their calculation and thus the result to
-the class Foo::Bar. Usually this is used in conjunction with Math::BigFloat:
+certain operations 'upgrade' their calculation and thus the result to the class
+Foo::Bar. Usually this is used in conjunction with Math::BigFloat:
 
-        use Math::BigInt upgrade => 'Math::BigFloat';
+    use Math::BigInt upgrade => 'Math::BigFloat';
 
 As a shortcut, you can use the module L<bignum>:
 
-        use bignum;
+    use bignum;
 
 Also good for one-liners:
 
-        perl -Mbignum -le 'print 2 ** 255'
+    perl -Mbignum -le 'print 2 ** 255'
 
-This makes it possible to mix arguments of different classes (as in 2.5 + 2)
-as well es preserve accuracy (as in sqrt(3)).
+This makes it possible to mix arguments of different classes (as in 2.5 + 2) as
+well es preserve accuracy (as in sqrt(3)).
 
 Beware: This feature is not fully implemented yet.
 
 =head2 Auto-upgrade
 
-The following methods upgrade themselves unconditionally; that is if upgrade
-is in effect, they will always hand up their work:
-
-=over
-
-=item bsqrt()
-
-=item div()
+The following methods upgrade themselves unconditionally; that is if upgrade is
+in effect, they always hands up their work:
 
-=item blog()
-
-=item bexp()
-
-=item bpi()
-
-=item bcos()
-
-=item bsin()
-
-=item batan2()
-
-=item batan()
-
-=back
+    div bsqrt blog bexp bpi bsin bcos batan batan2
 
-All other methods upgrade themselves only when one (or all) of their
-arguments are of the class mentioned in $upgrade.
+All other methods upgrade themselves only when one (or all) of their arguments
+are of the class mentioned in $upgrade.
 
 =head1 EXPORTS
 
-C<Math::BigInt> exports nothing by default, but can export the following methods:
+C<Math::BigInt> exports nothing by default, but can export the following
+methods:
 
-        bgcd
-        blcm
+    bgcd
+    blcm
 
 =head1 CAVEATS
 
@@ -5320,242 +5999,120 @@ known to be troublesome:
 
 =over
 
-=item bstr(), bsstr() and 'cmp'
+=item Comparing numbers as strings
 
-Both C<bstr()> and C<bsstr()> as well as automated stringify via overload now
-drop the leading '+'. The old code would return '+3', the new returns '3'.
-This is to be consistent with Perl and to make C<cmp> (especially with
-overloading) to work as you expect. It also solves problems with C<Test.pm>
-and L<Test::More>, which stringify arguments before comparing them.
+Both C<bstr()> and C<bsstr()> as well as stringify via overload drop the
+leading '+'. This is to be consistent with Perl and to make C<cmp> (especially
+with overloading) to work as you expect. It also solves problems with
+C<Test.pm> and L<Test::More>, which stringify arguments before comparing them.
 
 Mark Biggar said, when asked about to drop the '+' altogether, or make only
 C<cmp> work:
 
-        I agree (with the first alternative), don't add the '+' on positive
-        numbers.  It's not as important anymore with the new internal
-        form for numbers.  It made doing things like abs and neg easier,
-        but those have to be done differently now anyway.
+    I agree (with the first alternative), don't add the '+' on positive
+    numbers.  It's not as important anymore with the new internal form
+    for numbers.  It made doing things like abs and neg easier, but
+    those have to be done differently now anyway.
 
-So, the following examples will now work all as expected:
+So, the following examples now works as expected:
 
-        use Test::More tests => 1;
-        use Math::BigInt;
+    use Test::More tests => 1;
+    use Math::BigInt;
 
-        my $x = Math::BigInt -> new(3*3);
-        my $y = Math::BigInt -> new(3*3);
+    my $x = Math::BigInt -> new(3*3);
+    my $y = Math::BigInt -> new(3*3);
 
-        is ($x,3*3, 'multiplication');
-        print "$x eq 9" if $x eq $y;
-        print "$x eq 9" if $x eq '9';
-        print "$x eq 9" if $x eq 3*3;
+    is($x,3*3, 'multiplication');
+    print "$x eq 9" if $x eq $y;
+    print "$x eq 9" if $x eq '9';
+    print "$x eq 9" if $x eq 3*3;
 
 Additionally, the following still works:
 
-        print "$x == 9" if $x == $y;
-        print "$x == 9" if $x == 9;
-        print "$x == 9" if $x == 3*3;
+    print "$x == 9" if $x == $y;
+    print "$x == 9" if $x == 9;
+    print "$x == 9" if $x == 3*3;
 
 There is now a C<bsstr()> method to get the string in scientific notation aka
 C<1e+2> instead of C<100>. Be advised that overloaded 'eq' always uses bstr()
-for comparison, but Perl will represent some numbers as 100 and others
-as 1e+308. If in doubt, convert both arguments to Math::BigInt before
-comparing them as strings:
+for comparison, but Perl represents some numbers as 100 and others as 1e+308.
+If in doubt, convert both arguments to Math::BigInt before comparing them as
+strings:
 
-        use Test::More tests => 3;
-        use Math::BigInt;
+    use Test::More tests => 3;
+    use Math::BigInt;
 
-        $x = Math::BigInt->new('1e56'); $y = 1e56;
-        is ($x,$y);                     # will fail
-        is ($x->bsstr(),$y);            # okay
-        $y = Math::BigInt->new($y);
-        is ($x,$y);                     # okay
+    $x = Math::BigInt->new('1e56'); $y = 1e56;
+    is($x,$y);                     # fails
+    is($x->bsstr(),$y);            # okay
+    $y = Math::BigInt->new($y);
+    is($x,$y);                     # okay
 
-Alternatively, simply use C<< <=> >> for comparisons, this will get it
-always right. There is not yet a way to get a number automatically represented
-as a string that matches exactly the way Perl represents it.
+Alternatively, simply use C<< <=> >> for comparisons, this always gets it
+right. There is not yet a way to get a number automatically represented as a
+string that matches exactly the way Perl represents it.
 
 See also the section about L<Infinity and Not a Number> for problems in
 comparing NaNs.
 
 =item int()
 
-C<int()> will return (at least for Perl v5.7.1 and up) another BigInt, not a
+C<int()> returns (at least for Perl v5.7.1 and up) another Math::BigInt, not a
 Perl scalar:
 
-        $x = Math::BigInt->new(123);
-        $y = int($x);                           # BigInt 123
-        $x = Math::BigFloat->new(123.45);
-        $y = int($x);                           # BigInt 123
-
-In all Perl versions you can use C<as_number()> or C<as_int> for the same
-effect:
-
-        $x = Math::BigFloat->new(123.45);
-        $y = $x->as_number();                   # BigInt 123
-        $y = $x->as_int();                      # ditto
-
-This also works for other subclasses, like Math::String.
+    $x = Math::BigInt->new(123);
+    $y = int($x);                           # 123 as a Math::BigInt
+    $x = Math::BigFloat->new(123.45);
+    $y = int($x);                           # 123 as a Math::BigFloat
 
 If you want a real Perl scalar, use C<numify()>:
 
-        $y = $x->numify();                      # 123 as scalar
-
-This is seldom necessary, though, because this is done automatically, like
-when you access an array:
-
-        $z = $array[$x];                        # does work automatically
-
-=item length()
-
-The following will probably not do what you expect:
-
-        $c = Math::BigInt->new(123);
-        print $c->length(),"\n";                # prints 30
-
-It prints both the number of digits in the number and in the fraction part
-since print calls C<length()> in list context. Use something like:
-
-        print scalar $c->length(),"\n";         # prints 3
+    $y = $x->numify();                      # 123 as a scalar
 
-=item bdiv()
-
-The following will probably not do what you expect:
-
-        print $c->bdiv(10000),"\n";
-
-It prints both quotient and remainder since print calls C<bdiv()> in list
-context. Also, C<bdiv()> will modify $c, so be careful. You probably want
-to use
+This is seldom necessary, though, because this is done automatically, like when
+you access an array:
 
-        print $c / 10000,"\n";
-
-or, if you want to  modify $c instead,
-
-        print scalar $c->bdiv(10000),"\n";
-
-The quotient is always the greatest integer less than or equal to the
-real-valued quotient of the two operands, and the remainder (when it is
-non-zero) always has the same sign as the second operand; so, for
-example,
-
-          1 / 4  => ( 0, 1)
-          1 / -4 => (-1,-3)
-         -3 / 4  => (-1, 1)
-         -3 / -4 => ( 0,-3)
-        -11 / 2  => (-5,1)
-         11 /-2  => (-5,-1)
-
-As a consequence, the behavior of the operator % agrees with the
-behavior of Perl's built-in % operator (as documented in the perlop
-manpage), and the equation
-
-        $x == ($x / $y) * $y + ($x % $y)
-
-holds true for any $x and $y, which justifies calling the two return
-values of bdiv() the quotient and remainder. The only exception to this rule
-are when $y == 0 and $x is negative, then the remainder will also be
-negative. See below under "infinity handling" for the reasoning behind this.
-
-Perl's 'use integer;' changes the behaviour of % and / for scalars, but will
-not change BigInt's way to do things. This is because under 'use integer' Perl
-will do what the underlying C thinks is right and this is different for each
-system. If you need BigInt's behaving exactly like Perl's 'use integer', bug
-the author to implement it ;)
-
-=item infinity handling
-
-Here are some examples that explain the reasons why certain results occur while
-handling infinity:
-
-The following table shows the result of the division and the remainder, so that
-the equation above holds true. Some "ordinary" cases are strewn in to show more
-clearly the reasoning:
-
-        A /  B  =   C,     R so that C *    B +    R =    A
-     =========================================================
-        5 /   8 =   0,     5         0 *    8 +    5 =    5
-        0 /   8 =   0,     0         0 *    8 +    0 =    0
-        0 / inf =   0,     0         0 *  inf +    0 =    0
-        0 /-inf =   0,     0         0 * -inf +    0 =    0
-        5 / inf =   0,     5         0 *  inf +    5 =    5
-        5 /-inf =   0,     5         0 * -inf +    5 =    5
-        -5/ inf =   0,    -5         0 *  inf +   -5 =   -5
-        -5/-inf =   0,    -5         0 * -inf +   -5 =   -5
-       inf/   5 =  inf,    0       inf *    5 +    0 =  inf
-      -inf/   5 = -inf,    0      -inf *    5 +    0 = -inf
-       inf/  -5 = -inf,    0      -inf *   -5 +    0 =  inf
-      -inf/  -5 =  inf,    0       inf *   -5 +    0 = -inf
-         5/   5 =    1,    0         1 *    5 +    0 =    5
-        -5/  -5 =    1,    0         1 *   -5 +    0 =   -5
-       inf/ inf =    1,    0         1 *  inf +    0 =  inf
-      -inf/-inf =    1,    0         1 * -inf +    0 = -inf
-       inf/-inf =   -1,    0        -1 * -inf +    0 =  inf
-      -inf/ inf =   -1,    0         1 * -inf +    0 = -inf
-         8/   0 =  inf,    8       inf *    0 +    8 =    8
-       inf/   0 =  inf,  inf       inf *    0 +  inf =  inf
-         0/   0 =  NaN
-
-These cases below violate the "remainder has the sign of the second of the two
-arguments", since they wouldn't match up otherwise.
-
-        A /  B  =   C,     R so that C *    B +    R =    A
-     ========================================================
-      -inf/   0 = -inf, -inf      -inf *    0 +  inf = -inf
-        -8/   0 = -inf,   -8      -inf *    0 +    8 = -8
+    $z = $array[$x];                        # does work automatically
 
 =item Modifying and =
 
 Beware of:
 
-        $x = Math::BigFloat->new(5);
-        $y = $x;
+    $x = Math::BigFloat->new(5);
+    $y = $x;
 
-It will not do what you think, e.g. making a copy of $x. Instead it just makes
-a second reference to the B<same> object and stores it in $y. Thus anything
-that modifies $x (except overloaded operators) will modify $y, and vice versa.
-Or in other words, C<=> is only safe if you modify your BigInts only via
-overloaded math. As soon as you use a method call it breaks:
+This makes a second reference to the B<same> object and stores it in $y. Thus
+anything that modifies $x (except overloaded operators) also modifies $y, and
+vice versa. Or in other words, C<=> is only safe if you modify your
+Math::BigInt objects only via overloaded math. As soon as you use a method call
+it breaks:
 
-        $x->bmul(2);
-        print "$x, $y\n";       # prints '10, 10'
+    $x->bmul(2);
+    print "$x, $y\n";       # prints '10, 10'
 
 If you want a true copy of $x, use:
 
-        $y = $x->copy();
+    $y = $x->copy();
 
-You can also chain the calls like this, this will make first a copy and then
+You can also chain the calls like this, this first makes a copy and then
 multiply it by 2:
 
-        $y = $x->copy()->bmul(2);
+    $y = $x->copy()->bmul(2);
 
 See also the documentation for overload.pm regarding C<=>.
 
-=item bpow
-
-C<bpow()> (and the rounding functions) now modifies the first argument and
-returns it, unlike the old code which left it alone and only returned the
-result. This is to be consistent with C<badd()> etc. The first three will
-modify $x, the last one won't:
-
-        print bpow($x,$i),"\n";         # modify $x
-        print $x->bpow($i),"\n";        # ditto
-        print $x **= $i,"\n";           # the same
-        print $x ** $i,"\n";            # leave $x alone
-
-The form C<$x **= $y> is faster than C<$x = $x ** $y;>, though.
-
 =item Overloading -$x
 
 The following:
 
-        $x = -$x;
+    $x = -$x;
 
 is slower than
 
-        $x->bneg();
+    $x->bneg();
 
 since overload calls C<sub($x,0,1);> instead of C<neg($x)>. The first variant
-needs to preserve $x since it does not know that it later will get overwritten.
+needs to preserve $x since it does not know that it later gets overwritten.
 This makes a copy of $x and takes O(N), but $x->bneg() is O(1).
 
 =item Mixing different object types
@@ -5564,80 +6121,58 @@ With overloaded operators, it is the first (dominating) operand that determines
 which method is called. Here are some examples showing what actually gets
 called in various cases.
 
-        use Math::BigInt;
-        use Math::BigFloat;
-
-        $mbf  = Math::BigFloat->new(5);
-        $mbi2 = Math::BigInt->new(5);
-        $mbi  = Math::BigInt->new(2);
-                                        # what actually gets called:
-        $float = $mbf + $mbi;           # $mbf->badd($mbi)
-        $float = $mbf / $mbi;           # $mbf->bdiv($mbi)
-        $integer = $mbi + $mbf;         # $mbi->badd($mbf)
-        $integer = $mbi2 / $mbi;        # $mbi2->bdiv($mbi)
-        $integer = $mbi2 / $mbf;        # $mbi2->bdiv($mbf)
-
-For instance, Math::BigInt->bdiv() will always return a Math::BigInt, regardless of
+    use Math::BigInt;
+    use Math::BigFloat;
+
+    $mbf  = Math::BigFloat->new(5);
+    $mbi2 = Math::BigInt->new(5);
+    $mbi  = Math::BigInt->new(2);
+                                    # what actually gets called:
+    $float = $mbf + $mbi;           # $mbf->badd($mbi)
+    $float = $mbf / $mbi;           # $mbf->bdiv($mbi)
+    $integer = $mbi + $mbf;         # $mbi->badd($mbf)
+    $integer = $mbi2 / $mbi;        # $mbi2->bdiv($mbi)
+    $integer = $mbi2 / $mbf;        # $mbi2->bdiv($mbf)
+
+For instance, Math::BigInt->bdiv() always returns a Math::BigInt, regardless of
 whether the second operant is a Math::BigFloat. To get a Math::BigFloat you
 either need to call the operation manually, make sure each operand already is a
 Math::BigFloat, or cast to that type via Math::BigFloat->new():
 
-        $float = Math::BigFloat->new($mbi2) / $mbi;     # = 2.5
+    $float = Math::BigFloat->new($mbi2) / $mbi;     # = 2.5
 
 Beware of casting the entire expression, as this would cast the
 result, at which point it is too late:
 
-        $float = Math::BigFloat->new($mbi2 / $mbi);     # = 2
+    $float = Math::BigFloat->new($mbi2 / $mbi);     # = 2
 
 Beware also of the order of more complicated expressions like:
 
-        $integer = ($mbi2 + $mbi) / $mbf;               # int / float => int
-        $integer = $mbi2 / Math::BigFloat->new($mbi);   # ditto
+    $integer = ($mbi2 + $mbi) / $mbf;               # int / float => int
+    $integer = $mbi2 / Math::BigFloat->new($mbi);   # ditto
 
 If in doubt, break the expression into simpler terms, or cast all operands
 to the desired resulting type.
 
 Scalar values are a bit different, since:
 
-        $float = 2 + $mbf;
-        $float = $mbf + 2;
+    $float = 2 + $mbf;
+    $float = $mbf + 2;
 
-will both result in the proper type due to the way the overloaded math works.
+both result in the proper type due to the way the overloaded math works.
 
 This section also applies to other overloaded math packages, like Math::String.
 
 One solution to you problem might be autoupgrading|upgrading. See the
 pragmas L<bignum>, L<bigint> and L<bigrat> for an easy way to do this.
 
-=item bsqrt()
-
-C<bsqrt()> works only good if the result is a big integer, e.g. the square
-root of 144 is 12, but from 12 the square root is 3, regardless of rounding
-mode. The reason is that the result is always truncated to an integer.
-
-If you want a better approximation of the square root, then use:
-
-        $x = Math::BigFloat->new(12);
-        Math::BigFloat->precision(0);
-        Math::BigFloat->round_mode('even');
-        print $x->copy->bsqrt(),"\n";           # 4
-
-        Math::BigFloat->precision(2);
-        print $x->bsqrt(),"\n";                 # 3.46
-        print $x->bsqrt(3),"\n";                # 3.464
-
-=item brsft()
-
-For negative numbers in base see also L<brsft|/brsft()>.
-
 =back
 
 =head1 BUGS
 
 Please report any bugs or feature requests to
 C<bug-math-bigint at rt.cpan.org>, or through the web interface at
-L<https://rt.cpan.org/Ticket/Create.html?Queue=Math-BigInt>
-(requires login).
+L<https://rt.cpan.org/Ticket/Create.html?Queue=Math-BigInt> (requires login).
 We will be notified, and then you'll automatically be notified of progress on
 your bug as I make changes.
 
diff --git a/cpan/Math-BigInt/lib/Math/BigInt/Calc.pm b/cpan/Math-BigInt/lib/Math/BigInt/Calc.pm
index 1a7e4af9e9..f81fe24bc2 100644
--- a/cpan/Math-BigInt/lib/Math/BigInt/Calc.pm
+++ b/cpan/Math-BigInt/lib/Math/BigInt/Calc.pm
@@ -4,7 +4,7 @@ use 5.006001;
 use strict;
 use warnings;
 
-our $VERSION = '1.999715';
+our $VERSION = '1.999724';
 $VERSION = eval $VERSION;
 
 # Package to store unsigned big integers in decimal and do math with them
@@ -33,71 +33,66 @@ $VERSION = eval $VERSION;
 
 # announce that we are compatible with MBI v1.83 and up
 sub api_version () { 2; }
- 
+
 # constants for easier life
-my ($BASE,$BASE_LEN,$RBASE,$MAX_VAL);
-my ($AND_BITS,$XOR_BITS,$OR_BITS);
-my ($AND_MASK,$XOR_MASK,$OR_MASK);
-
-sub _base_len 
-  {
-  # Set/get the BASE_LEN and assorted other, connected values.
-  # Used only by the testsuite, the set variant is used only by the BEGIN
-  # block below:
-  shift;
-
-  my ($b, $int) = @_;
-  if (defined $b)
-    {
-    # avoid redefinitions
-    undef &_mul;
-    undef &_div;
-
-    if ($] >= 5.008 && $int && $b > 7)
-      {
-      $BASE_LEN = $b;
-      *_mul = \&_mul_use_div_64;
-      *_div = \&_div_use_div_64;
-      $BASE = int("1e".$BASE_LEN);
-      $MAX_VAL = $BASE-1;
-      return $BASE_LEN unless wantarray;
-      return ($BASE_LEN, $BASE, $AND_BITS, $XOR_BITS, $OR_BITS, $BASE_LEN, $MAX_VAL,);
-      }
-
-    # find whether we can use mul or div in mul()/div()
-    $BASE_LEN = $b+1;
-    my $caught = 0;
-    while (--$BASE_LEN > 5)
-      {
-      $BASE = int("1e".$BASE_LEN);
-      $RBASE = abs('1e-'.$BASE_LEN);			# see USE_MUL
-      $caught = 0;
-      $caught += 1 if (int($BASE * $RBASE) != 1);	# should be 1
-      $caught += 2 if (int($BASE / $BASE) != 1);	# should be 1
-      last if $caught != 3;
-      }
-    $BASE = int("1e".$BASE_LEN);
-    $RBASE = abs('1e-'.$BASE_LEN);			# see USE_MUL
-    $MAX_VAL = $BASE-1;
-   
-    # ($caught & 1) != 0 => cannot use MUL
-    # ($caught & 2) != 0 => cannot use DIV
-    if ($caught == 2)				# 2
-      {
-      # must USE_MUL since we cannot use DIV
-      *_mul = \&_mul_use_mul;
-      *_div = \&_div_use_mul;
-      }
-    else					# 0 or 1
-      {
-      # can USE_DIV instead
-      *_mul = \&_mul_use_div;
-      *_div = \&_div_use_div;
-      }
-    }
-  return $BASE_LEN unless wantarray;
-  return ($BASE_LEN, $BASE, $AND_BITS, $XOR_BITS, $OR_BITS, $BASE_LEN, $MAX_VAL);
-  }
+my ($BASE, $BASE_LEN, $RBASE, $MAX_VAL);
+my ($AND_BITS, $XOR_BITS, $OR_BITS);
+my ($AND_MASK, $XOR_MASK, $OR_MASK);
+
+sub _base_len {
+    # Set/get the BASE_LEN and assorted other, related values.
+    # Used only by the testsuite, the set variant is used only by the BEGIN
+    # block below:
+    shift;
+
+    my ($b, $int) = @_;
+    if (defined $b) {
+        # avoid redefinitions
+        undef &_mul;
+        undef &_div;
+
+        if ($] >= 5.008 && $int && $b > 7) {
+            $BASE_LEN = $b;
+            *_mul = \&_mul_use_div_64;
+            *_div = \&_div_use_div_64;
+            $BASE = int("1e" . $BASE_LEN);
+            $MAX_VAL = $BASE-1;
+            return $BASE_LEN unless wantarray;
+            return ($BASE_LEN, $BASE, $AND_BITS, $XOR_BITS, $OR_BITS, $BASE_LEN, $MAX_VAL);
+        }
+
+        # find whether we can use mul or div in mul()/div()
+        $BASE_LEN = $b + 1;
+        my $caught = 0;
+        while (--$BASE_LEN > 5) {
+            $BASE = int("1e" . $BASE_LEN);
+            $RBASE = abs('1e-' . $BASE_LEN); # see USE_MUL
+            $caught = 0;
+            $caught += 1 if (int($BASE * $RBASE) != 1); # should be 1
+            $caught += 2 if (int($BASE / $BASE) != 1);  # should be 1
+            last if $caught != 3;
+        }
+        $BASE = int("1e" . $BASE_LEN);
+        $RBASE = abs('1e-' . $BASE_LEN); # see USE_MUL
+        $MAX_VAL = $BASE-1;
+
+        # ($caught & 1) != 0 => cannot use MUL
+        # ($caught & 2) != 0 => cannot use DIV
+        if ($caught == 2)       # 2
+        {
+            # must USE_MUL since we cannot use DIV
+            *_mul = \&_mul_use_mul;
+            *_div = \&_div_use_mul;
+        } else                  # 0 or 1
+        {
+            # can USE_DIV instead
+            *_mul = \&_mul_use_div;
+            *_div = \&_div_use_div;
+        }
+    }
+    return $BASE_LEN unless wantarray;
+    return ($BASE_LEN, $BASE, $AND_BITS, $XOR_BITS, $OR_BITS, $BASE_LEN, $MAX_VAL);
+}
 
 sub _new {
     # Given a string representing an integer, returns a reference to an array
@@ -113,131 +108,130 @@ sub _new {
 
     my $format = "a" . (($input_len % $BASE_LEN) + 1);
     $format .= $] < 5.008 ? "a$BASE_LEN" x int($input_len / $BASE_LEN)
-                          : "(a$BASE_LEN)*";
+      : "(a$BASE_LEN)*";
 
     [ reverse(map { 0 + $_ } unpack($format, $str)) ];
 }
 
-BEGIN
-  {
-  # from Daniel Pfeiffer: determine largest group of digits that is precisely
-  # multipliable with itself plus carry
-  # Test now changed to expect the proper pattern, not a result off by 1 or 2
-  my ($e, $num) = 3;	# lowest value we will use is 3+1-1 = 3
-  do {
-      $num = '9' x ++$e;
-      $num *= $num + 1;
-  } while $num =~ /9{$e}0{$e}/;		# must be a certain pattern
-  $e--; 				# last test failed, so retract one step
-  # the limits below brush the problems with the test above under the rug:
-  # the test should be able to find the proper $e automatically
-  $e = 5 if $^O =~ /^uts/;	# UTS get's some special treatment
-  $e = 5 if $^O =~ /^unicos/;	# unicos is also problematic (6 seems to work
-				# there, but we play safe)
-
-  my $int = 0;
-  if ($e > 7)
-    {
+BEGIN {
+    # from Daniel Pfeiffer: determine largest group of digits that is precisely
+    # multipliable with itself plus carry
+    # Test now changed to expect the proper pattern, not a result off by 1 or 2
+    my ($e, $num) = 3;          # lowest value we will use is 3+1-1 = 3
+    do {
+        $num = '9' x ++$e;
+        $num *= $num + 1;
+    } while $num =~ /9{$e}0{$e}/; # must be a certain pattern
+    $e--;                         # last test failed, so retract one step
+    # the limits below brush the problems with the test above under the rug:
+    # the test should be able to find the proper $e automatically
+    $e = 5 if $^O =~ /^uts/;    # UTS get's some special treatment
+    $e = 5 if $^O =~ /^unicos/; # unicos is also problematic (6 seems to work
+    # there, but we play safe)
+
+    my $int = 0;
+    if ($e > 7) {
+        use integer;
+        my $e1 = 7;
+        $num = 7;
+        do
+        {
+            $num = ('9' x ++$e1) + 0;
+            $num *= $num + 1;
+        } while ("$num" =~ /9{$e1}0{$e1}/); # must be a certain pattern
+        $e1--;                  # last test failed, so retract one step
+        if ($e1 > 7) {
+            $int = 1;
+            $e = $e1;
+        }
+    }
+
+    __PACKAGE__ -> _base_len($e, $int); # set and store
+
     use integer;
-    my $e1 = 7;
-    $num = 7;
-    do 
-      {
-      $num = ('9' x ++$e1) + 0;
-      $num *= $num + 1;
-      } while ("$num" =~ /9{$e1}0{$e1}/);	# must be a certain pattern
-    $e1--; 					# last test failed, so retract one step
-    if ($e1 > 7)
-      { 
-      $int = 1; $e = $e1; 
-      }
-    }
- 
-  __PACKAGE__->_base_len($e,$int);	# set and store
-
-  use integer;
-  # find out how many bits _and, _or and _xor can take (old default = 16)
-  # I don't think anybody has yet 128 bit scalars, so let's play safe.
-  local $^W = 0;	# don't warn about 'nonportable number'
-  $AND_BITS = 15; $XOR_BITS = 15; $OR_BITS = 15;
-
-  # find max bits, we will not go higher than numberofbits that fit into $BASE
-  # to make _and etc simpler (and faster for smaller, slower for large numbers)
-  my $max = 16;
-  while (2 ** $max < $BASE) { $max++; }
-  {
-    no integer;
-    $max = 16 if $] < 5.006;	# older Perls might not take >16 too well
-  }
-  my ($x,$y,$z);
-  do {
-    $AND_BITS++;
-    $x = CORE::oct('0b' . '1' x $AND_BITS); $y = $x & $x;
-    $z = (2 ** $AND_BITS) - 1;
+    # find out how many bits _and, _or and _xor can take (old default = 16)
+    # I don't think anybody has yet 128 bit scalars, so let's play safe.
+    local $^W = 0;              # don't warn about 'nonportable number'
+    $AND_BITS = 15;
+    $XOR_BITS = 15;
+    $OR_BITS = 15;
+
+    # find max bits, we will not go higher than numberofbits that fit into $BASE
+    # to make _and etc simpler (and faster for smaller, slower for large numbers)
+    my $max = 16;
+    while (2 ** $max < $BASE) {
+        $max++;
+    }
+    {
+        no integer;
+        $max = 16 if $] < 5.006; # older Perls might not take >16 too well
+    }
+    my ($x, $y, $z);
+    do {
+        $AND_BITS++;
+        $x = CORE::oct('0b' . '1' x $AND_BITS);
+        $y = $x & $x;
+        $z = (2 ** $AND_BITS) - 1;
     } while ($AND_BITS < $max && $x == $z && $y == $x);
-  $AND_BITS --;						# retreat one step
-  do {
-    $XOR_BITS++;
-    $x = CORE::oct('0b' . '1' x $XOR_BITS); $y = $x ^ 0;
-    $z = (2 ** $XOR_BITS) - 1;
+    $AND_BITS --;               # retreat one step
+    do {
+        $XOR_BITS++;
+        $x = CORE::oct('0b' . '1' x $XOR_BITS);
+        $y = $x ^ 0;
+        $z = (2 ** $XOR_BITS) - 1;
     } while ($XOR_BITS < $max && $x == $z && $y == $x);
-  $XOR_BITS --;						# retreat one step
-  do {
-    $OR_BITS++;
-    $x = CORE::oct('0b' . '1' x $OR_BITS); $y = $x | $x;
-    $z = (2 ** $OR_BITS) - 1;
+    $XOR_BITS --;               # retreat one step
+    do {
+        $OR_BITS++;
+        $x = CORE::oct('0b' . '1' x $OR_BITS);
+        $y = $x | $x;
+        $z = (2 ** $OR_BITS) -  1;
     } while ($OR_BITS < $max && $x == $z && $y == $x);
-  $OR_BITS --;						# retreat one step
-  
-  $AND_MASK = __PACKAGE__->_new( ( 2 ** $AND_BITS ));
-  $XOR_MASK = __PACKAGE__->_new( ( 2 ** $XOR_BITS ));
-  $OR_MASK = __PACKAGE__->_new( ( 2 ** $OR_BITS ));
+    $OR_BITS--;                # retreat one step
+
+    $AND_MASK = __PACKAGE__->_new( ( 2 ** $AND_BITS ));
+    $XOR_MASK = __PACKAGE__->_new( ( 2 ** $XOR_BITS ));
+    $OR_MASK = __PACKAGE__->_new( ( 2 ** $OR_BITS ));
 
-  # We can compute the approximate length no faster than the real length:
-  *_alen = \&_len;
-  }
+    # We can compute the approximate length no faster than the real length:
+    *_alen = \&_len;
+}
 
 ###############################################################################
 
-sub _zero
-  {
-  # create a zero
-  [ 0 ];
-  }
-
-sub _one
-  {
-  # create a one
-  [ 1 ];
-  }
-
-sub _two
-  {
-  # create a two (used internally for shifting)
-  [ 2 ];
-  }
-
-sub _ten
-  {
-  # create a 10 (used internally for shifting)
-  [ 10 ];
-  }
-
-sub _1ex
-  {
-  # create a 1Ex
-  my $rem = $_[1] % $BASE_LEN;		# remainder
-  my $parts = $_[1] / $BASE_LEN;	# parts
-
-  # 000000, 000000, 100 
-  [ (0) x $parts, '1' . ('0' x $rem) ];
-  }
-
-sub _copy
-  {
-  # make a true copy
-  [ @{$_[1]} ];
-  }
+sub _zero {
+    # create a zero
+    [ 0 ];
+}
+
+sub _one {
+    # create a one
+    [ 1 ];
+}
+
+sub _two {
+    # create a two (used internally for shifting)
+    [ 2 ];
+}
+
+sub _ten {
+    # create a 10 (used internally for shifting)
+    [ 10 ];
+}
+
+sub _1ex {
+    # create a 1Ex
+    my $rem = $_[1] % $BASE_LEN;   # remainder
+    my $parts = $_[1] / $BASE_LEN; # parts
+
+    # 000000, 000000, 100
+    [ (0) x $parts, '1' . ('0' x $rem) ];
+}
+
+sub _copy {
+    # make a true copy
+    [ @{$_[1]} ];
+}
 
 # catch and throw away
 sub import { }
@@ -250,9 +244,9 @@ sub _str {
     # format is always normalized, i.e., no leading zeros.
 
     my $ary = $_[1];
-    my $idx = $#$ary;             # index of last element
+    my $idx = $#$ary;           # index of last element
 
-    if ($idx < 0) {               # should not happen
+    if ($idx < 0) {             # should not happen
         require Carp;
         Carp::croak("$_[1] has no elements");
     }
@@ -261,8 +255,8 @@ sub _str {
     my $ret = int($ary->[$idx]);
     if ($idx > 0) {
         $idx--;
-        # Interestingly, the pre-padd method uses more time
-        # the old grep variant takes longer (14 vs. 10 sec)
+        # Interestingly, the pre-padd method uses more time.
+        # The old grep variant takes longer (14 vs. 10 sec).
         my $z = '0' x ($BASE_LEN - 1);
         while ($idx >= 0) {
             $ret .= substr($z . $ary->[$idx], -$BASE_LEN);
@@ -272,12 +266,11 @@ sub _str {
     $ret;
 }
 
-sub _num
-  {
+sub _num {
     # Make a Perl scalar number (int/float) from a BigInt object.
     my $x = $_[1];
 
-    return 0 + $x->[0] if scalar @$x == 1;      # below $BASE
+    return 0 + $x->[0] if @$x == 1; # below $BASE
 
     # Start with the most significant element and work towards the least
     # significant element. Avoid multiplying "inf" (which happens if the number
@@ -290,7 +283,7 @@ sub _num
         $num += $x -> [$i];
     }
     return $num;
-  }
+}
 
 ##############################################################################
 # actual math code
@@ -304,8 +297,8 @@ sub _add {
 
     my ($c, $x, $y) = @_;
 
-    return $x if @$y == 1 && $y->[0] == 0;      # $x + 0 => $x
-    if (@$x == 1 && $x->[0] == 0) {             # 0 + $y => $y->copy
+    return $x if @$y == 1 && $y->[0] == 0; # $x + 0 => $x
+    if (@$x == 1 && $x->[0] == 0) {        # 0 + $y => $y->copy
         # Twice as slow as $x = [ @$y ], but necessary to modify $x in-place.
         @$x = @$y;
         return $x;
@@ -334,10 +327,10 @@ sub _inc {
     my ($c, $x) = @_;
 
     for my $i (@$x) {
-        return $x if ($i += 1) < $BASE;		# early out
-        $i = 0;					# overflow, next
+        return $x if ($i += 1) < $BASE; # early out
+        $i = 0;                         # overflow, next
     }
-    push @$x, 1 if $x->[-1] == 0;		# last overflowed, so extend
+    push @$x, 1 if $x->[-1] == 0;       # last overflowed, so extend
     $x;
 }
 
@@ -346,12 +339,12 @@ sub _dec {
     # Sub 1 from $x, modify $x in place
     my ($c, $x) = @_;
 
-    my $MAX = $BASE - 1;			# since MAX_VAL based on BASE
+    my $MAX = $BASE - 1;                # since MAX_VAL based on BASE
     for my $i (@$x) {
-        last if ($i -= 1) >= 0;			# early out
-        $i = $MAX;				# underflow, next
+        last if ($i -= 1) >= 0;         # early out
+        $i = $MAX;                      # underflow, next
     }
-    pop @$x if $x->[-1] == 0 && @$x > 1;	# last underflowed (but leave 0)
+    pop @$x if $x->[-1] == 0 && @$x > 1; # last underflowed (but leave 0)
     $x;
 }
 
@@ -386,783 +379,714 @@ sub _sub {
     __strip_zeros($sy);
 }
 
-sub _mul_use_mul
-  {
-  # (ref to int_num_array, ref to int_num_array)
-  # multiply two numbers in internal representation
-  # modifies first arg, second need not be different from first
-  my ($c,$xv,$yv) = @_;
+sub _mul_use_mul {
+    # (ref to int_num_array, ref to int_num_array)
+    # multiply two numbers in internal representation
+    # modifies first arg, second need not be different from first
+    my ($c, $xv, $yv) = @_;
+
+    if (@$yv == 1) {
+        # shortcut for two very short numbers (improved by Nathan Zook)
+        # works also if xv and yv are the same reference, and handles also $x == 0
+        if (@$xv == 1) {
+            if (($xv->[0] *= $yv->[0]) >= $BASE) {
+                $xv->[0] = $xv->[0] - ($xv->[1] = int($xv->[0] * $RBASE)) * $BASE;
+            }
+            ;
+            return $xv;
+        }
+        # $x * 0 => 0
+        if ($yv->[0] == 0) {
+            @$xv = (0);
+            return $xv;
+        }
+        # multiply a large number a by a single element one, so speed up
+        my $y = $yv->[0];
+        my $car = 0;
+        foreach my $i (@$xv) {
+            $i = $i * $y + $car;
+            $car = int($i * $RBASE);
+            $i -= $car * $BASE;
+        }
+        push @$xv, $car if $car != 0;
+        return $xv;
+    }
+    # shortcut for result $x == 0 => result = 0
+    return $xv if @$xv == 1 && $xv->[0] == 0;
+
+    # since multiplying $x with $x fails, make copy in this case
+    $yv = [ @$xv ] if $xv == $yv; # same references?
+
+    my @prod = ();
+    my ($prod, $car, $cty, $xi, $yi);
+
+    for $xi (@$xv) {
+        $car = 0;
+        $cty = 0;
+
+        # slow variant
+        #    for $yi (@$yv)
+        #      {
+        #      $prod = $xi * $yi + ($prod[$cty] || 0) + $car;
+        #      $prod[$cty++] =
+        #       $prod - ($car = int($prod * RBASE)) * $BASE;  # see USE_MUL
+        #      }
+        #    $prod[$cty] += $car if $car; # need really to check for 0?
+        #    $xi = shift @prod;
+
+        # faster variant
+        # looping through this if $xi == 0 is silly - so optimize it away!
+        $xi = (shift @prod || 0), next if $xi == 0;
+        for $yi (@$yv) {
+            $prod = $xi * $yi + ($prod[$cty] || 0) + $car;
+            ##     this is actually a tad slower
+            ##        $prod = $prod[$cty]; $prod += ($car + $xi * $yi);     # no ||0 here
+            $prod[$cty++] =
+              $prod - ($car = int($prod * $RBASE)) * $BASE; # see USE_MUL
+        }
+        $prod[$cty] += $car if $car; # need really to check for 0?
+        $xi = shift @prod || 0;      # || 0 makes v5.005_3 happy
+    }
+    push @$xv, @prod;
+    # can't have leading zeros
+    #  __strip_zeros($xv);
+    $xv;
+}
 
-  if (@$yv == 1)
-    {
-    # shortcut for two very short numbers (improved by Nathan Zook)
-    # works also if xv and yv are the same reference, and handles also $x == 0
-    if (@$xv == 1)
-      {
-      if (($xv->[0] *= $yv->[0]) >= $BASE)
-         {
-         $xv->[0] = $xv->[0] - ($xv->[1] = int($xv->[0] * $RBASE)) * $BASE;
-         };
-      return $xv;
-      }
-    # $x * 0 => 0
-    if ($yv->[0] == 0)
-      {
-      @$xv = (0);
-      return $xv;
-      }
-    # multiply a large number a by a single element one, so speed up
-    my $y = $yv->[0]; my $car = 0;
-    foreach my $i (@$xv)
-      {
-      $i = $i * $y + $car; $car = int($i * $RBASE); $i -= $car * $BASE;
-      }
-    push @$xv, $car if $car != 0;
-    return $xv;
-    }
-  # shortcut for result $x == 0 => result = 0
-  return $xv if ( ((@$xv == 1) && ($xv->[0] == 0)) ); 
-
-  # since multiplying $x with $x fails, make copy in this case
-  $yv = [@$xv] if $xv == $yv;	# same references?
-
-  my @prod = (); my ($prod,$car,$cty,$xi,$yi);
-
-  for $xi (@$xv)
-    {
-    $car = 0; $cty = 0;
-
-    # slow variant
-#    for $yi (@$yv)
-#      {
-#      $prod = $xi * $yi + ($prod[$cty] || 0) + $car;
-#      $prod[$cty++] =
-#       $prod - ($car = int($prod * RBASE)) * $BASE;  # see USE_MUL
-#      }
-#    $prod[$cty] += $car if $car; # need really to check for 0?
-#    $xi = shift @prod;
-
-    # faster variant
-    # looping through this if $xi == 0 is silly - so optimize it away!
-    $xi = (shift @prod || 0), next if $xi == 0;
-    for $yi (@$yv)
-      {
-      $prod = $xi * $yi + ($prod[$cty] || 0) + $car;
-##     this is actually a tad slower
-##        $prod = $prod[$cty]; $prod += ($car + $xi * $yi);	# no ||0 here
-      $prod[$cty++] =
-       $prod - ($car = int($prod * $RBASE)) * $BASE;  # see USE_MUL
-      }
-    $prod[$cty] += $car if $car; # need really to check for 0?
-    $xi = shift @prod || 0;	# || 0 makes v5.005_3 happy
-    }
-  push @$xv, @prod;
-  # can't have leading zeros
-#  __strip_zeros($xv);
-  $xv;
-  }                                                                             
-
-sub _mul_use_div_64
-  {
-  # (ref to int_num_array, ref to int_num_array)
-  # multiply two numbers in internal representation
-  # modifies first arg, second need not be different from first
-  # works for 64 bit integer with "use integer"
-  my ($c,$xv,$yv) = @_;
-
-  use integer;
-  if (@$yv == 1)
-    {
-    # shortcut for two small numbers, also handles $x == 0
-    if (@$xv == 1)
-      {
-      # shortcut for two very short numbers (improved by Nathan Zook)
-      # works also if xv and yv are the same reference, and handles also $x == 0
-      if (($xv->[0] *= $yv->[0]) >= $BASE)
-          {
-          $xv->[0] =
-              $xv->[0] - ($xv->[1] = $xv->[0] / $BASE) * $BASE;
-          };
-      return $xv;
-      }
-    # $x * 0 => 0
-    if ($yv->[0] == 0)
-      {
-      @$xv = (0);
-      return $xv;
-      }
-    # multiply a large number a by a single element one, so speed up
-    my $y = $yv->[0]; my $car = 0;
-    foreach my $i (@$xv)
-      {
-      #$i = $i * $y + $car; $car = $i / $BASE; $i -= $car * $BASE;
-      $i = $i * $y + $car; $i -= ($car = $i / $BASE) * $BASE;
-      }
-    push @$xv, $car if $car != 0;
-    return $xv;
-    }
-  # shortcut for result $x == 0 => result = 0
-  return $xv if ( ((@$xv == 1) && ($xv->[0] == 0)) ); 
-
-  # since multiplying $x with $x fails, make copy in this case
-  $yv = [@$xv] if $xv == $yv;	# same references?
-
-  my @prod = (); my ($prod,$car,$cty,$xi,$yi);
-  for $xi (@$xv)
-    {
-    $car = 0; $cty = 0;
-    # looping through this if $xi == 0 is silly - so optimize it away!
-    $xi = (shift @prod || 0), next if $xi == 0;
-    for $yi (@$yv)
-      {
-      $prod = $xi * $yi + ($prod[$cty] || 0) + $car;
-      $prod[$cty++] = $prod - ($car = $prod / $BASE) * $BASE;
-      }
-    $prod[$cty] += $car if $car; # need really to check for 0?
-    $xi = shift @prod || 0;	# || 0 makes v5.005_3 happy
-    }
-  push @$xv, @prod;
-  $xv;
-  }                                                                             
-
-sub _mul_use_div
-  {
-  # (ref to int_num_array, ref to int_num_array)
-  # multiply two numbers in internal representation
-  # modifies first arg, second need not be different from first
-  my ($c,$xv,$yv) = @_;
-
-  if (@$yv == 1)
-    {
-    # shortcut for two small numbers, also handles $x == 0
-    if (@$xv == 1)
-      {
-      # shortcut for two very short numbers (improved by Nathan Zook)
-      # works also if xv and yv are the same reference, and handles also $x == 0
-      if (($xv->[0] *= $yv->[0]) >= $BASE)
-          {
-          $xv->[0] =
-              $xv->[0] - ($xv->[1] = int($xv->[0] / $BASE)) * $BASE;
-          };
-      return $xv;
-      }
-    # $x * 0 => 0
-    if ($yv->[0] == 0)
-      {
-      @$xv = (0);
-      return $xv;
-      }
-    # multiply a large number a by a single element one, so speed up
-    my $y = $yv->[0]; my $car = 0;
-    foreach my $i (@$xv)
-      {
-      $i = $i * $y + $car; $car = int($i / $BASE); $i -= $car * $BASE;
-      # This (together with use integer;) does not work on 32-bit Perls
-      #$i = $i * $y + $car; $i -= ($car = $i / $BASE) * $BASE;
-      }
-    push @$xv, $car if $car != 0;
-    return $xv;
-    }
-  # shortcut for result $x == 0 => result = 0
-  return $xv if ( ((@$xv == 1) && ($xv->[0] == 0)) ); 
-
-  # since multiplying $x with $x fails, make copy in this case
-  $yv = [@$xv] if $xv == $yv;	# same references?
-
-  my @prod = (); my ($prod,$car,$cty,$xi,$yi);
-  for $xi (@$xv)
-    {
-    $car = 0; $cty = 0;
-    # looping through this if $xi == 0 is silly - so optimize it away!
-    $xi = (shift @prod || 0), next if $xi == 0;
-    for $yi (@$yv)
-      {
-      $prod = $xi * $yi + ($prod[$cty] || 0) + $car;
-      $prod[$cty++] = $prod - ($car = int($prod / $BASE)) * $BASE;
-      }
-    $prod[$cty] += $car if $car; # need really to check for 0?
-    $xi = shift @prod || 0;	# || 0 makes v5.005_3 happy
-    }
-  push @$xv, @prod;
-  # can't have leading zeros
-#  __strip_zeros($xv);
-  $xv;
-  }                                                                             
-
-sub _div_use_mul
-  {
-  # ref to array, ref to array, modify first array and return remainder if 
-  # in list context
-
-  # see comments in _div_use_div() for more explanations
-
-  my ($c,$x,$yorg) = @_;
-  
-  # the general div algorithm here is about O(N*N) and thus quite slow, so
-  # we first check for some special cases and use shortcuts to handle them.
-
-  # This works, because we store the numbers in a chunked format where each
-  # element contains 5..7 digits (depending on system).
-
-  # if both numbers have only one element:
-  if (@$x == 1 && @$yorg == 1)
-    {
-    # shortcut, $yorg and $x are two small numbers
-    if (wantarray)
-      {
-      my $r = [ $x->[0] % $yorg->[0] ];
-      $x->[0] = int($x->[0] / $yorg->[0]);
-      return ($x,$r); 
-      }
-    else
-      {
-      $x->[0] = int($x->[0] / $yorg->[0]);
-      return $x; 
-      }
-    }
-
-  # if x has more than one, but y has only one element:
-  if (@$yorg == 1)
-    {
-    my $rem;
-    $rem = _mod($c,[ @$x ],$yorg) if wantarray;
-
-    # shortcut, $y is < $BASE
-    my $j = scalar @$x; my $r = 0; 
-    my $y = $yorg->[0]; my $b;
-    while ($j-- > 0)
-      {
-      $b = $r * $BASE + $x->[$j];
-      $x->[$j] = int($b/$y);
-      $r = $b % $y;
-      }
-    pop @$x if @$x > 1 && $x->[-1] == 0;	# splice up a leading zero 
-    return ($x,$rem) if wantarray;
-    return $x;
+sub _mul_use_div_64 {
+    # (ref to int_num_array, ref to int_num_array)
+    # multiply two numbers in internal representation
+    # modifies first arg, second need not be different from first
+    # works for 64 bit integer with "use integer"
+    my ($c, $xv, $yv) = @_;
+
+    use integer;
+    if (@$yv == 1) {
+        # shortcut for two small numbers, also handles $x == 0
+        if (@$xv == 1) {
+            # shortcut for two very short numbers (improved by Nathan Zook)
+            # works also if xv and yv are the same reference, and handles also $x == 0
+            if (($xv->[0] *= $yv->[0]) >= $BASE) {
+                $xv->[0] =
+                  $xv->[0] - ($xv->[1] = $xv->[0] / $BASE) * $BASE;
+            }
+            return $xv;
+        }
+        # $x * 0 => 0
+        if ($yv->[0] == 0) {
+            @$xv = (0);
+            return $xv;
+        }
+        # multiply a large number a by a single element one, so speed up
+        my $y = $yv->[0];
+        my $car = 0;
+        foreach my $i (@$xv) {
+            #$i = $i * $y + $car; $car = $i / $BASE; $i -= $car * $BASE;
+            $i = $i * $y + $car;
+            $i -= ($car = $i / $BASE) * $BASE;
+        }
+        push @$xv, $car if $car != 0;
+        return $xv;
+    }
+    # shortcut for result $x == 0 => result = 0
+    return $xv if ( ((@$xv == 1) && ($xv->[0] == 0)) );
+
+    # since multiplying $x with $x fails, make copy in this case
+    $yv = [ @$xv ] if $xv == $yv; # same references?
+
+    my @prod = ();
+    my ($prod, $car, $cty, $xi, $yi);
+    for $xi (@$xv) {
+        $car = 0;
+        $cty = 0;
+        # looping through this if $xi == 0 is silly - so optimize it away!
+        $xi = (shift @prod || 0), next if $xi == 0;
+        for $yi (@$yv) {
+            $prod = $xi * $yi + ($prod[$cty] || 0) + $car;
+            $prod[$cty++] = $prod - ($car = $prod / $BASE) * $BASE;
+        }
+        $prod[$cty] += $car if $car; # need really to check for 0?
+        $xi = shift @prod || 0;      # || 0 makes v5.005_3 happy
     }
+    push @$xv, @prod;
+    $xv;
+}
 
-  # now x and y have more than one element
+sub _mul_use_div {
+    # (ref to int_num_array, ref to int_num_array)
+    # multiply two numbers in internal representation
+    # modifies first arg, second need not be different from first
+    my ($c, $xv, $yv) = @_;
+
+    if (@$yv == 1) {
+        # shortcut for two small numbers, also handles $x == 0
+        if (@$xv == 1) {
+            # shortcut for two very short numbers (improved by Nathan Zook)
+            # works also if xv and yv are the same reference, and handles also $x == 0
+            if (($xv->[0] *= $yv->[0]) >= $BASE) {
+                $xv->[0] =
+                  $xv->[0] - ($xv->[1] = int($xv->[0] / $BASE)) * $BASE;
+            }
+            ;
+            return $xv;
+        }
+        # $x * 0 => 0
+        if ($yv->[0] == 0) {
+            @$xv = (0);
+            return $xv;
+        }
+        # multiply a large number a by a single element one, so speed up
+        my $y = $yv->[0];
+        my $car = 0;
+        foreach my $i (@$xv) {
+            $i = $i * $y + $car;
+            $car = int($i / $BASE);
+            $i -= $car * $BASE;
+            # This (together with use integer;) does not work on 32-bit Perls
+            #$i = $i * $y + $car; $i -= ($car = $i / $BASE) * $BASE;
+        }
+        push @$xv, $car if $car != 0;
+        return $xv;
+    }
+    # shortcut for result $x == 0 => result = 0
+    return $xv if ( ((@$xv == 1) && ($xv->[0] == 0)) );
+
+    # since multiplying $x with $x fails, make copy in this case
+    $yv = [ @$xv ] if $xv == $yv; # same references?
+
+    my @prod = ();
+    my ($prod, $car, $cty, $xi, $yi);
+    for $xi (@$xv) {
+        $car = 0;
+        $cty = 0;
+        # looping through this if $xi == 0 is silly - so optimize it away!
+        $xi = (shift @prod || 0), next if $xi == 0;
+        for $yi (@$yv) {
+            $prod = $xi * $yi + ($prod[$cty] || 0) + $car;
+            $prod[$cty++] = $prod - ($car = int($prod / $BASE)) * $BASE;
+        }
+        $prod[$cty] += $car if $car; # need really to check for 0?
+        $xi = shift @prod || 0;      # || 0 makes v5.005_3 happy
+    }
+    push @$xv, @prod;
+    # can't have leading zeros
+    #  __strip_zeros($xv);
+    $xv;
+}
 
-  # check whether y has more elements than x, if yet, the result will be 0
-  if (@$yorg > @$x)
-    {
-    my $rem;
-    $rem = [@$x] if wantarray;                  # make copy
-    splice (@$x,1);                             # keep ref to original array
-    $x->[0] = 0;                                # set to 0
-    return ($x,$rem) if wantarray;              # including remainder?
-    return $x;					# only x, which is [0] now
-    }
-  # check whether the numbers have the same number of elements, in that case
-  # the result will fit into one element and can be computed efficiently
-  if (@$yorg == @$x)
-    {
-    my $rem;
-    # if $yorg has more digits than $x (it's leading element is longer than
-    # the one from $x), the result will also be 0:
-    if (length(int($yorg->[-1])) > length(int($x->[-1])))
-      {
-      $rem = [@$x] if wantarray;		# make copy
-      splice (@$x,1);				# keep ref to org array
-      $x->[0] = 0;				# set to 0
-      return ($x,$rem) if wantarray;		# including remainder?
-      return $x;
-      }
-    # now calculate $x / $yorg
-    if (length(int($yorg->[-1])) == length(int($x->[-1])))
-      {
-      # same length, so make full compare
-
-      my $a = 0; my $j = scalar @$x - 1;
-      # manual way (abort if unequal, good for early ne)
-      while ($j >= 0)
-        {
-        last if ($a = $x->[$j] - $yorg->[$j]); $j--;
+sub _div_use_mul {
+    # ref to array, ref to array, modify first array and return remainder if
+    # in list context
+
+    # see comments in _div_use_div() for more explanations
+
+    my ($c, $x, $yorg) = @_;
+
+    # the general div algorithm here is about O(N*N) and thus quite slow, so
+    # we first check for some special cases and use shortcuts to handle them.
+
+    # This works, because we store the numbers in a chunked format where each
+    # element contains 5..7 digits (depending on system).
+
+    # if both numbers have only one element:
+    if (@$x == 1 && @$yorg == 1) {
+        # shortcut, $yorg and $x are two small numbers
+        if (wantarray) {
+            my $r = [ $x->[0] % $yorg->[0] ];
+            $x->[0] = int($x->[0] / $yorg->[0]);
+            return ($x, $r);
+        } else {
+            $x->[0] = int($x->[0] / $yorg->[0]);
+            return $x;
         }
-      # $a contains the result of the compare between X and Y
-      # a < 0: x < y, a == 0: x == y, a > 0: x > y
-      if ($a <= 0)
-        {
-        $rem = [ 0 ];                   # a = 0 => x == y => rem 0
-        $rem = [@$x] if $a != 0;        # a < 0 => x < y => rem = x
-        splice(@$x,1);                  # keep single element
-        $x->[0] = 0;                    # if $a < 0
-        $x->[0] = 1 if $a == 0;         # $x == $y
-        return ($x,$rem) if wantarray;
+    }
+
+    # if x has more than one, but y has only one element:
+    if (@$yorg == 1) {
+        my $rem;
+        $rem = _mod($c, [ @$x ], $yorg) if wantarray;
+
+        # shortcut, $y is < $BASE
+        my $j = @$x;
+        my $r = 0;
+        my $y = $yorg->[0];
+        my $b;
+        while ($j-- > 0) {
+            $b = $r * $BASE + $x->[$j];
+            $x->[$j] = int($b/$y);
+            $r = $b % $y;
+        }
+        pop @$x if @$x > 1 && $x->[-1] == 0; # splice up a leading zero
+        return ($x, $rem) if wantarray;
         return $x;
+    }
+
+    # now x and y have more than one element
+
+    # check whether y has more elements than x, if yet, the result will be 0
+    if (@$yorg > @$x) {
+        my $rem;
+        $rem = [ @$x ] if wantarray;      # make copy
+        splice(@$x, 1);                # keep ref to original array
+        $x->[0] = 0;                    # set to 0
+        return ($x, $rem) if wantarray; # including remainder?
+        return $x;                      # only x, which is [0] now
+    }
+    # check whether the numbers have the same number of elements, in that case
+    # the result will fit into one element and can be computed efficiently
+    if (@$yorg == @$x) {
+        my $rem;
+        # if $yorg has more digits than $x (it's leading element is longer than
+        # the one from $x), the result will also be 0:
+        if (length(int($yorg->[-1])) > length(int($x->[-1]))) {
+            $rem = [ @$x ] if wantarray;      # make copy
+            splice(@$x, 1);                # keep ref to org array
+            $x->[0] = 0;                    # set to 0
+            return ($x, $rem) if wantarray; # including remainder?
+            return $x;
+        }
+        # now calculate $x / $yorg
+        if (length(int($yorg->[-1])) == length(int($x->[-1]))) {
+            # same length, so make full compare
+
+            my $a = 0;
+            my $j = @$x - 1;
+            # manual way (abort if unequal, good for early ne)
+            while ($j >= 0) {
+                last if ($a = $x->[$j] - $yorg->[$j]);
+                $j--;
+            }
+            # $a contains the result of the compare between X and Y
+            # a < 0: x < y, a == 0: x == y, a > 0: x > y
+            if ($a <= 0) {
+                $rem = [ 0 ];            # a = 0 => x == y => rem 0
+                $rem = [ @$x ] if $a != 0; # a < 0 => x < y => rem = x
+                splice(@$x, 1);           # keep single element
+                $x->[0] = 0;             # if $a < 0
+                $x->[0] = 1 if $a == 0;  # $x == $y
+                return ($x, $rem) if wantarray;
+                return $x;
+            }
+            # $x >= $y, so proceed normally
         }
-      # $x >= $y, so proceed normally
-      }
     }
 
-  # all other cases:
+    # all other cases:
 
-  my $y = [ @$yorg ];				# always make copy to preserve
+    my $y = [ @$yorg ];         # always make copy to preserve
 
-  my ($car,$bar,$prd,$dd,$xi,$yi,@q,$v2,$v1,@d,$tmp,$q,$u2,$u1,$u0);
+    my ($car, $bar, $prd, $dd, $xi, $yi, @q, $v2, $v1, @d, $tmp, $q, $u2, $u1, $u0);
 
-  $car = $bar = $prd = 0;
-  if (($dd = int($BASE/($y->[-1]+1))) != 1) 
-    {
-    for $xi (@$x) 
-      {
-      $xi = $xi * $dd + $car;
-      $xi -= ($car = int($xi * $RBASE)) * $BASE;	# see USE_MUL
-      }
-    push(@$x, $car); $car = 0;
-    for $yi (@$y) 
-      {
-      $yi = $yi * $dd + $car;
-      $yi -= ($car = int($yi * $RBASE)) * $BASE;	# see USE_MUL
-      }
-    }
-  else 
-    {
-    push(@$x, 0);
+    $car = $bar = $prd = 0;
+    if (($dd = int($BASE / ($y->[-1] + 1))) != 1) {
+        for $xi (@$x) {
+            $xi = $xi * $dd + $car;
+            $xi -= ($car = int($xi * $RBASE)) * $BASE; # see USE_MUL
+        }
+        push(@$x, $car);
+        $car = 0;
+        for $yi (@$y) {
+            $yi = $yi * $dd + $car;
+            $yi -= ($car = int($yi * $RBASE)) * $BASE; # see USE_MUL
+        }
+    } else {
+        push(@$x, 0);
+    }
+    @q = ();
+    ($v2, $v1) = @$y[-2, -1];
+    $v2 = 0 unless $v2;
+    while ($#$x > $#$y) {
+        ($u2, $u1, $u0) = @$x[-3 .. -1];
+        $u2 = 0 unless $u2;
+        #warn "oups v1 is 0, u0: $u0 $y->[-2] $y->[-1] l ",scalar @$y,"\n"
+        # if $v1 == 0;
+        $q = (($u0 == $v1) ? $MAX_VAL : int(($u0 * $BASE + $u1) / $v1));
+        --$q while ($v2 * $q > ($u0 * $BASE + $u1 - $q * $v1) * $BASE + $u2);
+        if ($q) {
+            ($car, $bar) = (0, 0);
+            for ($yi = 0, $xi = $#$x - $#$y-1; $yi <= $#$y; ++$yi, ++$xi) {
+                $prd = $q * $y->[$yi] + $car;
+                $prd -= ($car = int($prd * $RBASE)) * $BASE; # see USE_MUL
+                $x->[$xi] += $BASE if ($bar = (($x->[$xi] -= $prd + $bar) < 0));
+            }
+            if ($x->[-1] < $car + $bar) {
+                $car = 0;
+                --$q;
+                for ($yi = 0, $xi = $#$x - $#$y-1; $yi <= $#$y; ++$yi, ++$xi) {
+                    $x->[$xi] -= $BASE
+                      if ($car = (($x->[$xi] += $y->[$yi] + $car) >= $BASE));
+                }
+            }
+        }
+        pop(@$x);
+        unshift(@q, $q);
+    }
+    if (wantarray) {
+        @d = ();
+        if ($dd != 1) {
+            $car = 0;
+            for $xi (reverse @$x) {
+                $prd = $car * $BASE + $xi;
+                $car = $prd - ($tmp = int($prd / $dd)) * $dd; # see USE_MUL
+                unshift(@d, $tmp);
+            }
+        } else {
+            @d = @$x;
+        }
+        @$x = @q;
+        my $d = \@d;
+        __strip_zeros($x);
+        __strip_zeros($d);
+        return ($x, $d);
     }
-  @q = (); ($v2,$v1) = @$y[-2,-1];
-  $v2 = 0 unless $v2;
-  while ($#$x > $#$y) 
-    {
-    ($u2,$u1,$u0) = @$x[-3..-1];
-    $u2 = 0 unless $u2;
-    #warn "oups v1 is 0, u0: $u0 $y->[-2] $y->[-1] l ",scalar @$y,"\n"
-    # if $v1 == 0;
-    $q = (($u0 == $v1) ? $MAX_VAL : int(($u0*$BASE+$u1)/$v1));
-    --$q while ($v2*$q > ($u0*$BASE+$u1-$q*$v1)*$BASE+$u2);
-    if ($q)
-      {
-      ($car, $bar) = (0,0);
-      for ($yi = 0, $xi = $#$x-$#$y-1; $yi <= $#$y; ++$yi,++$xi) 
-        {
-        $prd = $q * $y->[$yi] + $car;
-        $prd -= ($car = int($prd * $RBASE)) * $BASE;	# see USE_MUL
-	$x->[$xi] += $BASE if ($bar = (($x->[$xi] -= $prd + $bar) < 0));
-	}
-      if ($x->[-1] < $car + $bar) 
-        {
-        $car = 0; --$q;
-	for ($yi = 0, $xi = $#$x-$#$y-1; $yi <= $#$y; ++$yi,++$xi) 
-          {
-	  $x->[$xi] -= $BASE
-	   if ($car = (($x->[$xi] += $y->[$yi] + $car) >= $BASE));
-	  }
-	}   
-      }
-    pop(@$x);
-    unshift(@q, $q);
-    }
-  if (wantarray) 
-    {
-    @d = ();
-    if ($dd != 1)  
-      {
-      $car = 0; 
-      for $xi (reverse @$x) 
-        {
-        $prd = $car * $BASE + $xi;
-        $car = $prd - ($tmp = int($prd / $dd)) * $dd; # see USE_MUL
-        unshift(@d, $tmp);
-        }
-      }
-    else 
-      {
-      @d = @$x;
-      }
     @$x = @q;
-    my $d = \@d; 
     __strip_zeros($x);
-    __strip_zeros($d);
-    return ($x,$d);
-    }
-  @$x = @q;
-  __strip_zeros($x);
-  $x;
-  }
-
-sub _div_use_div_64
-  {
-  # ref to array, ref to array, modify first array and return remainder if 
-  # in list context
-  # This version works on 64 bit integers
-  my ($c,$x,$yorg) = @_;
-
-  use integer;
-  # the general div algorithm here is about O(N*N) and thus quite slow, so
-  # we first check for some special cases and use shortcuts to handle them.
-
-  # This works, because we store the numbers in a chunked format where each
-  # element contains 5..7 digits (depending on system).
-
-  # if both numbers have only one element:
-  if (@$x == 1 && @$yorg == 1)
-    {
-    # shortcut, $yorg and $x are two small numbers
-    if (wantarray)
-      {
-      my $r = [ $x->[0] % $yorg->[0] ];
-      $x->[0] = int($x->[0] / $yorg->[0]);
-      return ($x,$r); 
-      }
-    else
-      {
-      $x->[0] = int($x->[0] / $yorg->[0]);
-      return $x; 
-      }
-    }
-  # if x has more than one, but y has only one element:
-  if (@$yorg == 1)
-    {
-    my $rem;
-    $rem = _mod($c,[ @$x ],$yorg) if wantarray;
-
-    # shortcut, $y is < $BASE
-    my $j = scalar @$x; my $r = 0; 
-    my $y = $yorg->[0]; my $b;
-    while ($j-- > 0)
-      {
-      $b = $r * $BASE + $x->[$j];
-      $x->[$j] = int($b/$y);
-      $r = $b % $y;
-      }
-    pop @$x if @$x > 1 && $x->[-1] == 0;	# splice up a leading zero 
-    return ($x,$rem) if wantarray;
-    return $x;
+    $x;
+}
+
+sub _div_use_div_64 {
+    # ref to array, ref to array, modify first array and return remainder if
+    # in list context
+    # This version works on 64 bit integers
+    my ($c, $x, $yorg) = @_;
+
+    use integer;
+    # the general div algorithm here is about O(N*N) and thus quite slow, so
+    # we first check for some special cases and use shortcuts to handle them.
+
+    # This works, because we store the numbers in a chunked format where each
+    # element contains 5..7 digits (depending on system).
+
+    # if both numbers have only one element:
+    if (@$x == 1 && @$yorg == 1) {
+        # shortcut, $yorg and $x are two small numbers
+        if (wantarray) {
+            my $r = [ $x->[0] % $yorg->[0] ];
+            $x->[0] = int($x->[0] / $yorg->[0]);
+            return ($x, $r);
+        } else {
+            $x->[0] = int($x->[0] / $yorg->[0]);
+            return $x;
+        }
     }
-  # now x and y have more than one element
+    # if x has more than one, but y has only one element:
+    if (@$yorg == 1) {
+        my $rem;
+        $rem = _mod($c, [ @$x ], $yorg) if wantarray;
 
-  # check whether y has more elements than x, if yet, the result will be 0
-  if (@$yorg > @$x)
-    {
-    my $rem;
-    $rem = [@$x] if wantarray;			# make copy
-    splice (@$x,1);				# keep ref to original array
-    $x->[0] = 0;				# set to 0
-    return ($x,$rem) if wantarray;		# including remainder?
-    return $x;					# only x, which is [0] now
-    }
-  # check whether the numbers have the same number of elements, in that case
-  # the result will fit into one element and can be computed efficiently
-  if (@$yorg == @$x)
-    {
-    my $rem;
-    # if $yorg has more digits than $x (it's leading element is longer than
-    # the one from $x), the result will also be 0:
-    if (length(int($yorg->[-1])) > length(int($x->[-1])))
-      {
-      $rem = [@$x] if wantarray;		# make copy
-      splice (@$x,1);				# keep ref to org array
-      $x->[0] = 0;				# set to 0
-      return ($x,$rem) if wantarray;		# including remainder?
-      return $x;
-      }
-    # now calculate $x / $yorg
-
-    if (length(int($yorg->[-1])) == length(int($x->[-1])))
-      {
-      # same length, so make full compare
-
-      my $a = 0; my $j = scalar @$x - 1;
-      # manual way (abort if unequal, good for early ne)
-      while ($j >= 0)
-        {
-        last if ($a = $x->[$j] - $yorg->[$j]); $j--;
+        # shortcut, $y is < $BASE
+        my $j = @$x;
+        my $r = 0;
+        my $y = $yorg->[0];
+        my $b;
+        while ($j-- > 0) {
+            $b = $r * $BASE + $x->[$j];
+            $x->[$j] = int($b/$y);
+            $r = $b % $y;
         }
-      # $a contains the result of the compare between X and Y
-      # a < 0: x < y, a == 0: x == y, a > 0: x > y
-      if ($a <= 0)
-        {
-        $rem = [ 0 ];			# a = 0 => x == y => rem 0
-        $rem = [@$x] if $a != 0;	# a < 0 => x < y => rem = x
-        splice(@$x,1);			# keep single element
-        $x->[0] = 0;			# if $a < 0
-        $x->[0] = 1 if $a == 0; 	# $x == $y
-        return ($x,$rem) if wantarray;	# including remainder?
+        pop @$x if @$x > 1 && $x->[-1] == 0; # splice up a leading zero
+        return ($x, $rem) if wantarray;
         return $x;
+    }
+    # now x and y have more than one element
+
+    # check whether y has more elements than x, if yet, the result will be 0
+    if (@$yorg > @$x) {
+        my $rem;
+        $rem = [ @$x ] if wantarray;      # make copy
+        splice(@$x, 1);                # keep ref to original array
+        $x->[0] = 0;                    # set to 0
+        return ($x, $rem) if wantarray; # including remainder?
+        return $x;                      # only x, which is [0] now
+    }
+    # check whether the numbers have the same number of elements, in that case
+    # the result will fit into one element and can be computed efficiently
+    if (@$yorg == @$x) {
+        my $rem;
+        # if $yorg has more digits than $x (it's leading element is longer than
+        # the one from $x), the result will also be 0:
+        if (length(int($yorg->[-1])) > length(int($x->[-1]))) {
+            $rem = [ @$x ] if wantarray;     # make copy
+            splice(@$x, 1);                # keep ref to org array
+            $x->[0] = 0;                   # set to 0
+            return ($x, $rem) if wantarray; # including remainder?
+            return $x;
         }
-      # $x >= $y, so proceed normally
+        # now calculate $x / $yorg
+
+        if (length(int($yorg->[-1])) == length(int($x->[-1]))) {
+            # same length, so make full compare
+
+            my $a = 0;
+            my $j = @$x - 1;
+            # manual way (abort if unequal, good for early ne)
+            while ($j >= 0) {
+                last if ($a = $x->[$j] - $yorg->[$j]);
+                $j--;
+            }
+            # $a contains the result of the compare between X and Y
+            # a < 0: x < y, a == 0: x == y, a > 0: x > y
+            if ($a <= 0) {
+                $rem = [ 0 ];                  # a = 0 => x == y => rem 0
+                $rem = [ @$x ] if $a != 0;       # a < 0 => x < y => rem = x
+                splice(@$x, 1);                 # keep single element
+                $x->[0] = 0;                   # if $a < 0
+                $x->[0] = 1 if $a == 0;        # $x == $y
+                return ($x, $rem) if wantarray; # including remainder?
+                return $x;
+            }
+            # $x >= $y, so proceed normally
 
-      }
+        }
     }
 
-  # all other cases:
-
-  my $y = [ @$yorg ];				# always make copy to preserve
- 
-  my ($car,$bar,$prd,$dd,$xi,$yi,@q,$v2,$v1,@d,$tmp,$q,$u2,$u1,$u0);
+    # all other cases:
 
-  $car = $bar = $prd = 0;
-  if (($dd = int($BASE/($y->[-1]+1))) != 1) 
-    {
-    for $xi (@$x) 
-      {
-      $xi = $xi * $dd + $car;
-      $xi -= ($car = int($xi / $BASE)) * $BASE;
-      }
-    push(@$x, $car); $car = 0;
-    for $yi (@$y) 
-      {
-      $yi = $yi * $dd + $car;
-      $yi -= ($car = int($yi / $BASE)) * $BASE;
-      }
-    }
-  else 
-    {
-    push(@$x, 0);
-    }
+    my $y = [ @$yorg ];         # always make copy to preserve
 
-  # @q will accumulate the final result, $q contains the current computed
-  # part of the final result
+    my ($car, $bar, $prd, $dd, $xi, $yi, @q, $v2, $v1, @d, $tmp, $q, $u2, $u1, $u0);
 
-  @q = (); ($v2,$v1) = @$y[-2,-1];
-  $v2 = 0 unless $v2;
-  while ($#$x > $#$y) 
-    {
-    ($u2,$u1,$u0) = @$x[-3..-1];
-    $u2 = 0 unless $u2;
-    #warn "oups v1 is 0, u0: $u0 $y->[-2] $y->[-1] l ",scalar @$y,"\n"
-    # if $v1 == 0;
-    $q = (($u0 == $v1) ? $MAX_VAL : int(($u0*$BASE+$u1)/$v1));
-    --$q while ($v2*$q > ($u0*$BASE+$u1-$q*$v1)*$BASE+$u2);
-    if ($q)
-      {
-      ($car, $bar) = (0,0);
-      for ($yi = 0, $xi = $#$x-$#$y-1; $yi <= $#$y; ++$yi,++$xi) 
-        {
-        $prd = $q * $y->[$yi] + $car;
-        $prd -= ($car = int($prd / $BASE)) * $BASE;
-	$x->[$xi] += $BASE if ($bar = (($x->[$xi] -= $prd + $bar) < 0));
-	}
-      if ($x->[-1] < $car + $bar) 
-        {
-        $car = 0; --$q;
-	for ($yi = 0, $xi = $#$x-$#$y-1; $yi <= $#$y; ++$yi,++$xi) 
-          {
-	  $x->[$xi] -= $BASE
-	   if ($car = (($x->[$xi] += $y->[$yi] + $car) >= $BASE));
-	  }
-	}   
-      }
-    pop(@$x); unshift(@q, $q);
-    }
-  if (wantarray) 
-    {
-    @d = ();
-    if ($dd != 1)  
-      {
-      $car = 0; 
-      for $xi (reverse @$x) 
-        {
-        $prd = $car * $BASE + $xi;
-        $car = $prd - ($tmp = int($prd / $dd)) * $dd;
-        unshift(@d, $tmp);
-        }
-      }
-    else 
-      {
-      @d = @$x;
-      }
+    $car = $bar = $prd = 0;
+    if (($dd = int($BASE / ($y->[-1] + 1))) != 1) {
+        for $xi (@$x) {
+            $xi = $xi * $dd + $car;
+            $xi -= ($car = int($xi / $BASE)) * $BASE;
+        }
+        push(@$x, $car);
+        $car = 0;
+        for $yi (@$y) {
+            $yi = $yi * $dd + $car;
+            $yi -= ($car = int($yi / $BASE)) * $BASE;
+        }
+    } else {
+        push(@$x, 0);
+    }
+
+    # @q will accumulate the final result, $q contains the current computed
+    # part of the final result
+
+    @q = ();
+    ($v2, $v1) = @$y[-2, -1];
+    $v2 = 0 unless $v2;
+    while ($#$x > $#$y) {
+        ($u2, $u1, $u0) = @$x[-3..-1];
+        $u2 = 0 unless $u2;
+        #warn "oups v1 is 0, u0: $u0 $y->[-2] $y->[-1] l ",scalar @$y,"\n"
+        # if $v1 == 0;
+        $q = (($u0 == $v1) ? $MAX_VAL : int(($u0 * $BASE + $u1) / $v1));
+        --$q while ($v2 * $q > ($u0 * $BASE +$ u1- $q*$v1) * $BASE + $u2);
+        if ($q) {
+            ($car, $bar) = (0, 0);
+            for ($yi = 0, $xi = $#$x - $#$y - 1; $yi <= $#$y; ++$yi, ++$xi) {
+                $prd = $q * $y->[$yi] + $car;
+                $prd -= ($car = int($prd / $BASE)) * $BASE;
+                $x->[$xi] += $BASE if ($bar = (($x->[$xi] -= $prd + $bar) < 0));
+            }
+            if ($x->[-1] < $car + $bar) {
+                $car = 0;
+                --$q;
+                for ($yi = 0, $xi = $#$x - $#$y - 1; $yi <= $#$y; ++$yi, ++$xi) {
+                    $x->[$xi] -= $BASE
+                      if ($car = (($x->[$xi] += $y->[$yi] + $car) >= $BASE));
+                }
+            }
+        }
+        pop(@$x);
+        unshift(@q, $q);
+    }
+    if (wantarray) {
+        @d = ();
+        if ($dd != 1) {
+            $car = 0;
+            for $xi (reverse @$x) {
+                $prd = $car * $BASE + $xi;
+                $car = $prd - ($tmp = int($prd / $dd)) * $dd;
+                unshift(@d, $tmp);
+            }
+        } else {
+            @d = @$x;
+        }
+        @$x = @q;
+        my $d = \@d;
+        __strip_zeros($x);
+        __strip_zeros($d);
+        return ($x, $d);
+    }
     @$x = @q;
-    my $d = \@d; 
     __strip_zeros($x);
-    __strip_zeros($d);
-    return ($x,$d);
-    }
-  @$x = @q;
-  __strip_zeros($x);
-  $x;
-  }
+    $x;
+}
 
-sub _div_use_div
-  {
-  # ref to array, ref to array, modify first array and return remainder if 
-  # in list context
-  my ($c,$x,$yorg) = @_;
+sub _div_use_div {
+    # ref to array, ref to array, modify first array and return remainder if
+    # in list context
+    my ($c, $x, $yorg) = @_;
 
-  # the general div algorithm here is about O(N*N) and thus quite slow, so
-  # we first check for some special cases and use shortcuts to handle them.
+    # the general div algorithm here is about O(N*N) and thus quite slow, so
+    # we first check for some special cases and use shortcuts to handle them.
 
-  # This works, because we store the numbers in a chunked format where each
-  # element contains 5..7 digits (depending on system).
+    # This works, because we store the numbers in a chunked format where each
+    # element contains 5..7 digits (depending on system).
 
-  # if both numbers have only one element:
-  if (@$x == 1 && @$yorg == 1)
-    {
-    # shortcut, $yorg and $x are two small numbers
-    if (wantarray)
-      {
-      my $r = [ $x->[0] % $yorg->[0] ];
-      $x->[0] = int($x->[0] / $yorg->[0]);
-      return ($x,$r); 
-      }
-    else
-      {
-      $x->[0] = int($x->[0] / $yorg->[0]);
-      return $x; 
-      }
-    }
-  # if x has more than one, but y has only one element:
-  if (@$yorg == 1)
-    {
-    my $rem;
-    $rem = _mod($c,[ @$x ],$yorg) if wantarray;
-
-    # shortcut, $y is < $BASE
-    my $j = scalar @$x; my $r = 0; 
-    my $y = $yorg->[0]; my $b;
-    while ($j-- > 0)
-      {
-      $b = $r * $BASE + $x->[$j];
-      $x->[$j] = int($b/$y);
-      $r = $b % $y;
-      }
-    pop @$x if @$x > 1 && $x->[-1] == 0;	# splice up a leading zero 
-    return ($x,$rem) if wantarray;
-    return $x;
+    # if both numbers have only one element:
+    if (@$x == 1 && @$yorg == 1) {
+        # shortcut, $yorg and $x are two small numbers
+        if (wantarray) {
+            my $r = [ $x->[0] % $yorg->[0] ];
+            $x->[0] = int($x->[0] / $yorg->[0]);
+            return ($x, $r);
+        } else {
+            $x->[0] = int($x->[0] / $yorg->[0]);
+            return $x;
+        }
     }
-  # now x and y have more than one element
+    # if x has more than one, but y has only one element:
+    if (@$yorg == 1) {
+        my $rem;
+        $rem = _mod($c, [ @$x ], $yorg) if wantarray;
 
-  # check whether y has more elements than x, if yet, the result will be 0
-  if (@$yorg > @$x)
-    {
-    my $rem;
-    $rem = [@$x] if wantarray;			# make copy
-    splice (@$x,1);				# keep ref to original array
-    $x->[0] = 0;				# set to 0
-    return ($x,$rem) if wantarray;		# including remainder?
-    return $x;					# only x, which is [0] now
-    }
-  # check whether the numbers have the same number of elements, in that case
-  # the result will fit into one element and can be computed efficiently
-  if (@$yorg == @$x)
-    {
-    my $rem;
-    # if $yorg has more digits than $x (it's leading element is longer than
-    # the one from $x), the result will also be 0:
-    if (length(int($yorg->[-1])) > length(int($x->[-1])))
-      {
-      $rem = [@$x] if wantarray;		# make copy
-      splice (@$x,1);				# keep ref to org array
-      $x->[0] = 0;				# set to 0
-      return ($x,$rem) if wantarray;		# including remainder?
-      return $x;
-      }
-    # now calculate $x / $yorg
-
-    if (length(int($yorg->[-1])) == length(int($x->[-1])))
-      {
-      # same length, so make full compare
-
-      my $a = 0; my $j = scalar @$x - 1;
-      # manual way (abort if unequal, good for early ne)
-      while ($j >= 0)
-        {
-        last if ($a = $x->[$j] - $yorg->[$j]); $j--;
+        # shortcut, $y is < $BASE
+        my $j = @$x;
+        my $r = 0;
+        my $y = $yorg->[0];
+        my $b;
+        while ($j-- > 0) {
+            $b = $r * $BASE + $x->[$j];
+            $x->[$j] = int($b/$y);
+            $r = $b % $y;
         }
-      # $a contains the result of the compare between X and Y
-      # a < 0: x < y, a == 0: x == y, a > 0: x > y
-      if ($a <= 0)
-        {
-        $rem = [ 0 ];			# a = 0 => x == y => rem 0
-        $rem = [@$x] if $a != 0;	# a < 0 => x < y => rem = x
-        splice(@$x,1);			# keep single element
-        $x->[0] = 0;			# if $a < 0
-        $x->[0] = 1 if $a == 0; 	# $x == $y
-        return ($x,$rem) if wantarray;	# including remainder?
+        pop @$x if @$x > 1 && $x->[-1] == 0; # splice up a leading zero
+        return ($x, $rem) if wantarray;
         return $x;
+    }
+    # now x and y have more than one element
+
+    # check whether y has more elements than x, if yet, the result will be 0
+    if (@$yorg > @$x) {
+        my $rem;
+        $rem = [ @$x ] if wantarray;     # make copy
+        splice(@$x, 1);                # keep ref to original array
+        $x->[0] = 0;                   # set to 0
+        return ($x, $rem) if wantarray; # including remainder?
+        return $x;                     # only x, which is [0] now
+    }
+    # check whether the numbers have the same number of elements, in that case
+    # the result will fit into one element and can be computed efficiently
+    if (@$yorg == @$x) {
+        my $rem;
+        # if $yorg has more digits than $x (it's leading element is longer than
+        # the one from $x), the result will also be 0:
+        if (length(int($yorg->[-1])) > length(int($x->[-1]))) {
+            $rem = [ @$x ] if wantarray;     # make copy
+            splice(@$x, 1);                # keep ref to org array
+            $x->[0] = 0;                   # set to 0
+            return ($x, $rem) if wantarray; # including remainder?
+            return $x;
         }
-      # $x >= $y, so proceed normally
+        # now calculate $x / $yorg
+
+        if (length(int($yorg->[-1])) == length(int($x->[-1]))) {
+            # same length, so make full compare
+
+            my $a = 0;
+            my $j = @$x - 1;
+            # manual way (abort if unequal, good for early ne)
+            while ($j >= 0) {
+                last if ($a = $x->[$j] - $yorg->[$j]);
+                $j--;
+            }
+            # $a contains the result of the compare between X and Y
+            # a < 0: x < y, a == 0: x == y, a > 0: x > y
+            if ($a <= 0) {
+                $rem = [ 0 ];                  # a = 0 => x == y => rem 0
+                $rem = [ @$x ] if $a != 0;       # a < 0 => x < y => rem = x
+                splice(@$x, 1);                 # keep single element
+                $x->[0] = 0;                   # if $a < 0
+                $x->[0] = 1 if $a == 0;        # $x == $y
+                return ($x, $rem) if wantarray; # including remainder?
+                return $x;
+            }
+            # $x >= $y, so proceed normally
 
-      }
+        }
     }
 
-  # all other cases:
-
-  my $y = [ @$yorg ];				# always make copy to preserve
- 
-  my ($car,$bar,$prd,$dd,$xi,$yi,@q,$v2,$v1,@d,$tmp,$q,$u2,$u1,$u0);
+    # all other cases:
 
-  $car = $bar = $prd = 0;
-  if (($dd = int($BASE/($y->[-1]+1))) != 1) 
-    {
-    for $xi (@$x) 
-      {
-      $xi = $xi * $dd + $car;
-      $xi -= ($car = int($xi / $BASE)) * $BASE;
-      }
-    push(@$x, $car); $car = 0;
-    for $yi (@$y) 
-      {
-      $yi = $yi * $dd + $car;
-      $yi -= ($car = int($yi / $BASE)) * $BASE;
-      }
-    }
-  else 
-    {
-    push(@$x, 0);
-    }
+    my $y = [ @$yorg ];         # always make copy to preserve
 
-  # @q will accumulate the final result, $q contains the current computed
-  # part of the final result
+    my ($car, $bar, $prd, $dd, $xi, $yi, @q, $v2, $v1, @d, $tmp, $q, $u2, $u1, $u0);
 
-  @q = (); ($v2,$v1) = @$y[-2,-1];
-  $v2 = 0 unless $v2;
-  while ($#$x > $#$y) 
-    {
-    ($u2,$u1,$u0) = @$x[-3..-1];
-    $u2 = 0 unless $u2;
-    #warn "oups v1 is 0, u0: $u0 $y->[-2] $y->[-1] l ",scalar @$y,"\n"
-    # if $v1 == 0;
-    $q = (($u0 == $v1) ? $MAX_VAL : int(($u0*$BASE+$u1)/$v1));
-    --$q while ($v2*$q > ($u0*$BASE+$u1-$q*$v1)*$BASE+$u2);
-    if ($q)
-      {
-      ($car, $bar) = (0,0);
-      for ($yi = 0, $xi = $#$x-$#$y-1; $yi <= $#$y; ++$yi,++$xi) 
-        {
-        $prd = $q * $y->[$yi] + $car;
-        $prd -= ($car = int($prd / $BASE)) * $BASE;
-	$x->[$xi] += $BASE if ($bar = (($x->[$xi] -= $prd + $bar) < 0));
-	}
-      if ($x->[-1] < $car + $bar) 
-        {
-        $car = 0; --$q;
-	for ($yi = 0, $xi = $#$x-$#$y-1; $yi <= $#$y; ++$yi,++$xi) 
-          {
-	  $x->[$xi] -= $BASE
-	   if ($car = (($x->[$xi] += $y->[$yi] + $car) >= $BASE));
-	  }
-	}   
-      }
-    pop(@$x); unshift(@q, $q);
-    }
-  if (wantarray) 
-    {
-    @d = ();
-    if ($dd != 1)  
-      {
-      $car = 0; 
-      for $xi (reverse @$x) 
-        {
-        $prd = $car * $BASE + $xi;
-        $car = $prd - ($tmp = int($prd / $dd)) * $dd;
-        unshift(@d, $tmp);
-        }
-      }
-    else 
-      {
-      @d = @$x;
-      }
+    $car = $bar = $prd = 0;
+    if (($dd = int($BASE / ($y->[-1] + 1))) != 1) {
+        for $xi (@$x) {
+            $xi = $xi * $dd + $car;
+            $xi -= ($car = int($xi / $BASE)) * $BASE;
+        }
+        push(@$x, $car);
+        $car = 0;
+        for $yi (@$y) {
+            $yi = $yi * $dd + $car;
+            $yi -= ($car = int($yi / $BASE)) * $BASE;
+        }
+    } else {
+        push(@$x, 0);
+    }
+
+    # @q will accumulate the final result, $q contains the current computed
+    # part of the final result
+
+    @q = ();
+    ($v2, $v1) = @$y[-2, -1];
+    $v2 = 0 unless $v2;
+    while ($#$x > $#$y) {
+        ($u2, $u1, $u0) = @$x[-3..-1];
+        $u2 = 0 unless $u2;
+        #warn "oups v1 is 0, u0: $u0 $y->[-2] $y->[-1] l ",scalar @$y,"\n"
+        # if $v1 == 0;
+        $q = (($u0 == $v1) ? $MAX_VAL : int(($u0 * $BASE + $u1) / $v1));
+        --$q while ($v2 * $q > ($u0 * $BASE + $u1 - $q * $v1) * $BASE + $u2);
+        if ($q) {
+            ($car, $bar) = (0, 0);
+            for ($yi = 0, $xi = $#$x - $#$y - 1; $yi <= $#$y; ++$yi, ++$xi) {
+                $prd = $q * $y->[$yi] + $car;
+                $prd -= ($car = int($prd / $BASE)) * $BASE;
+                $x->[$xi] += $BASE if ($bar = (($x->[$xi] -= $prd + $bar) < 0));
+            }
+            if ($x->[-1] < $car + $bar) {
+                $car = 0;
+                --$q;
+                for ($yi = 0, $xi = $#$x - $#$y - 1; $yi <= $#$y; ++$yi, ++$xi) {
+                    $x->[$xi] -= $BASE
+                      if ($car = (($x->[$xi] += $y->[$yi] + $car) >= $BASE));
+                }
+            }
+        }
+        pop(@$x);
+        unshift(@q, $q);
+    }
+    if (wantarray) {
+        @d = ();
+        if ($dd != 1) {
+            $car = 0;
+            for $xi (reverse @$x) {
+                $prd = $car * $BASE + $xi;
+                $car = $prd - ($tmp = int($prd / $dd)) * $dd;
+                unshift(@d, $tmp);
+            }
+        } else {
+            @d = @$x;
+        }
+        @$x = @q;
+        my $d = \@d;
+        __strip_zeros($x);
+        __strip_zeros($d);
+        return ($x, $d);
+    }
     @$x = @q;
-    my $d = \@d; 
     __strip_zeros($x);
-    __strip_zeros($d);
-    return ($x,$d);
-    }
-  @$x = @q;
-  __strip_zeros($x);
-  $x;
-  }
+    $x;
+}
 
 ##############################################################################
 # testing
@@ -1207,7 +1131,7 @@ sub _len {
 }
 
 sub _digit {
-    # Return the nth digit. Zero is rightmost, so _digit(123,0) gives 3.
+    # Return the nth digit. Zero is rightmost, so _digit(123, 0) gives 3.
     # Negative values count from the left, so _digit(123, -1) gives 1.
     my ($c, $x, $n) = @_;
 
@@ -1216,8 +1140,8 @@ sub _digit {
     $n += $len if $n < 0;               # -1 last, -2 second-to-last
     return "0" if $n < 0 || $n >= $len; # return 0 for digits out of range
 
-    my $elem = int($n / $BASE_LEN);     # which array element
-    my $digit = $n % $BASE_LEN;         # which digit in this element
+    my $elem = int($n / $BASE_LEN); # which array element
+    my $digit = $n % $BASE_LEN;     # which digit in this element
     substr("$x->[$elem]", -$digit - 1, 1);
 }
 
@@ -1234,13 +1158,13 @@ sub _zeros {
     my $elem;
     foreach my $e (@$x) {
         if ($e != 0) {
-            $elem = "$e";               # preserve x
-            $elem =~ s/.*?(0*$)/$1/;    # strip anything not zero
-            $zeros *= $BASE_LEN;        # elems * 5
-            $zeros += length($elem);    # count trailing zeros
-            last;                       # early out
+            $elem = "$e";            # preserve x
+            $elem =~ s/.*?(0*$)/$1/; # strip anything not zero
+            $zeros *= $BASE_LEN;     # elems * 5
+            $zeros += length($elem); # count trailing zeros
+            last;                    # early out
         }
-        $zeros ++;                      # real else branch: 50% slower!
+        $zeros ++;              # real else branch: 50% slower!
     }
     $zeros;
 }
@@ -1249,7 +1173,7 @@ sub _zeros {
 # _is_* routines
 
 sub _is_zero {
-    # return true if arg is zero 
+    # return true if arg is zero
     @{$_[1]} == 1 && $_[1]->[0] == 0 ? 1 : 0;
 }
 
@@ -1269,12 +1193,12 @@ sub _is_one {
 }
 
 sub _is_two {
-    # return true if arg is two 
+    # return true if arg is two
     @{$_[1]} == 1 && $_[1]->[0] == 2 ? 1 : 0;
 }
 
 sub _is_ten {
-    # return true if arg is ten 
+    # return true if arg is ten
     @{$_[1]} == 1 && $_[1]->[0] == 10 ? 1 : 0;
 }
 
@@ -1285,9 +1209,9 @@ sub __strip_zeros {
 
     my $cnt = @$s;              # get count of parts
     my $i = $cnt - 1;
-    push @$s, 0 if $i < 0;	# div might return empty results, so fix it
+    push @$s, 0 if $i < 0;      # div might return empty results, so fix it
 
-    return $s if @$s == 1;	# early out
+    return $s if @$s == 1;      # early out
 
     #print "strip: cnt $cnt i $i\n";
     # '0', '3', '4', '0', '0',
@@ -1302,7 +1226,7 @@ sub __strip_zeros {
         $i--;
     }
     $i++;
-    splice @$s, $i if $i < $cnt;        # $i cant be 0
+    splice(@$s, $i) if $i < $cnt; # $i cant be 0
     $s;
 }
 
@@ -1320,7 +1244,8 @@ sub _check {
     my $j = @$x;
     my ($e, $try);
     while ($i < $j) {
-        $e = $x->[$i]; $e = 'undef' unless defined $e;
+        $e = $x->[$i];
+        $e = 'undef' unless defined $e;
         $try = '=~ /^[\+]?[0-9]+\$/; '."($x, $e)";
         last if $e !~ /^[+]?[0-9]+$/;
         $try = '=~ /^[\+]?[0-9]+\$/; '."($x, $e) (stringify)";
@@ -1355,7 +1280,7 @@ sub _mod {
     my $y = $yo->[0];
 
     # if both are single element arrays
-    if (scalar @$x == 1) {
+    if (@$x == 1) {
         $x->[0] %= $y;
         return $x;
     }
@@ -1372,7 +1297,7 @@ sub _mod {
         # simplified
         my $r = 0;
         foreach (@$x) {
-            $r = ($r + $_) % $y;        # not much faster, but heh...
+            $r = ($r + $_) % $y; # not much faster, but heh...
             #$r += $_ % $y; $r %= $y;
         }
         $r = 0 if $r == $y;
@@ -1393,7 +1318,7 @@ sub _mod {
         $r = 0 if $r == $y;
         $x->[0] = $r;
     }
-    @$x = $x->[0];		# keep one element of @$x
+    @$x = $x->[0];              # keep one element of @$x
     return $x;
 }
 
@@ -1410,24 +1335,24 @@ sub _rsft {
 
     # shortcut (faster) for shifting by 10)
     # multiples of $BASE_LEN
-    my $dst = 0;                                            # destination
-    my $src = _num($c, $y);                                 # as normal int
+    my $dst = 0;                # destination
+    my $src = _num($c, $y);     # as normal int
     my $xlen = (@$x - 1) * $BASE_LEN + length(int($x->[-1]));
     if ($src >= $xlen or ($src == $xlen and !defined $x->[1])) {
         # 12345 67890 shifted right by more than 10 digits => 0
-        splice(@$x, 1);                 # leave only one element
-        $x->[0] = 0;                    # set to zero
+        splice(@$x, 1);         # leave only one element
+        $x->[0] = 0;            # set to zero
         return $x;
     }
-    my $rem = $src % $BASE_LEN;         # remainder to shift
-    $src = int($src / $BASE_LEN);       # source
+    my $rem = $src % $BASE_LEN;   # remainder to shift
+    $src = int($src / $BASE_LEN); # source
     if ($rem == 0) {
-        splice(@$x, 0, $src);           # even faster, 38.4 => 39.3
+        splice(@$x, 0, $src);   # even faster, 38.4 => 39.3
     } else {
-        my $len = @$x - $src;           # elems to go
+        my $len = @$x - $src;   # elems to go
         my $vd;
         my $z = '0' x $BASE_LEN;
-        $x->[@$x] = 0;                  # avoid || 0 test inside loop
+        $x->[ @$x ] = 0;          # avoid || 0 test inside loop
         while ($dst < $len) {
             $vd = $z . $x->[$src];
             $vd = substr($vd, -$BASE_LEN, $BASE_LEN - $rem);
@@ -1437,9 +1362,9 @@ sub _rsft {
             $x->[$dst] = int($vd);
             $dst++;
         }
-        splice(@$x, $dst) if $dst > 0;          # kill left-over array elems
-        pop @$x if $x->[-1] == 0 && @$x > 1;    # kill last element if 0
-    }                                           # else rem == 0
+        splice(@$x, $dst) if $dst > 0;       # kill left-over array elems
+        pop @$x if $x->[-1] == 0 && @$x > 1; # kill last element if 0
+    }                                        # else rem == 0
     $x;
 }
 
@@ -1453,19 +1378,19 @@ sub _lsft {
 
     # shortcut (faster) for shifting by 10) since we are in base 10eX
     # multiples of $BASE_LEN:
-    my $src = @$x;                              # source
-    my $len = _num($c, $y);		        # shift-len as normal int
-    my $rem = $len % $BASE_LEN;	        	# remainder to shift
-    my $dst = $src + int($len / $BASE_LEN);     # destination
-    my $vd;                                     # further speedup
-    $x->[$src] = 0;                             # avoid first ||0 for speed
+    my $src = @$x;                          # source
+    my $len = _num($c, $y);                 # shift-len as normal int
+    my $rem = $len % $BASE_LEN;             # remainder to shift
+    my $dst = $src + int($len / $BASE_LEN); # destination
+    my $vd;                                 # further speedup
+    $x->[$src] = 0;                         # avoid first ||0 for speed
     my $z = '0' x $BASE_LEN;
     while ($src >= 0) {
         $vd = $x->[$src];
         $vd = $z . $vd;
         $vd = substr($vd, -$BASE_LEN + $rem, $BASE_LEN - $rem);
         $vd .= $src > 0 ? substr($z . $x->[$src - 1], -$BASE_LEN, $rem)
-                        : '0' x $rem;
+          : '0' x $rem;
         $vd = substr($vd, -$BASE_LEN, $BASE_LEN) if length($vd) > $BASE_LEN;
         $x->[$dst] = int($vd);
         $dst--;
@@ -1487,19 +1412,19 @@ sub _pow {
 
     if (@$cy == 1 && $cy->[0] == 0) {
         splice(@$cx, 1);
-        $cx->[0] = 1;                   # y == 0 => x => 1
+        $cx->[0] = 1;           # y == 0 => x => 1
         return $cx;
     }
 
-    if ((@$cx == 1 && $cx->[0] == 1) ||     #    x == 1
-        (@$cy == 1 && $cy->[0] == 1))       # or y == 1
+    if ((@$cx == 1 && $cx->[0] == 1) || #    x == 1
+        (@$cy == 1 && $cy->[0] == 1))   # or y == 1
     {
         return $cx;
     }
 
     if (@$cx == 1 && $cx->[0] == 0) {
         splice (@$cx, 1);
-        $cx->[0] = 0;                   # 0 ** y => 0 (if not y <= 0)
+        $cx->[0] = 0;           # 0 ** y => 0 (if not y <= 0)
         return $cx;
     }
 
@@ -1528,9 +1453,9 @@ sub _nok {
     # nok(n, n-k), to minimize the number if iterations in the loop.
 
     {
-        my $twok = _mul($c, _two($c), _copy($c, $k));   # 2 * k
-        if (_acmp($c, $twok, $n) > 0) {                 # if 2*k > n
-            $k = _sub($c, _copy($c, $n), $k);           # k = n - k
+        my $twok = _mul($c, _two($c), _copy($c, $k)); # 2 * k
+        if (_acmp($c, $twok, $n) > 0) {               # if 2*k > n
+            $k = _sub($c, _copy($c, $n), $k);         # k = n - k
         }
     }
 
@@ -1542,9 +1467,7 @@ sub _nok {
 
     if (_is_zero($c, $k)) {
         @$n = 1;
-    }
-
-    else {
+    } else {
 
         # Make a copy of the original n, since we'll be modifying n in-place.
 
@@ -1581,879 +1504,843 @@ sub _nok {
 }
 
 my @factorials = (
-  1,
-  1,
-  2,
-  2*3,
-  2*3*4,
-  2*3*4*5,
-  2*3*4*5*6,
-  2*3*4*5*6*7,
-);
-
-sub _fac
-  {
-  # factorial of $x
-  # ref to array, return ref to array
-  my ($c,$cx) = @_;
-
-  if ((@$cx == 1) && ($cx->[0] <= 7))
-    {
-    $cx->[0] = $factorials[$cx->[0]];		# 0 => 1, 1 => 1, 2 => 2 etc.
-    return $cx;
+                  1,
+                  1,
+                  2,
+                  2*3,
+                  2*3*4,
+                  2*3*4*5,
+                  2*3*4*5*6,
+                  2*3*4*5*6*7,
+                 );
+
+sub _fac {
+    # factorial of $x
+    # ref to array, return ref to array
+    my ($c, $cx) = @_;
+
+    if ((@$cx == 1) && ($cx->[0] <= 7)) {
+        $cx->[0] = $factorials[$cx->[0]]; # 0 => 1, 1 => 1, 2 => 2 etc.
+        return $cx;
     }
 
-  if ((@$cx == 1) && 		# we do this only if $x >= 12 and $x <= 7000
-      ($cx->[0] >= 12 && $cx->[0] < 7000))
-    {
+    if ((@$cx == 1) &&          # we do this only if $x >= 12 and $x <= 7000
+        ($cx->[0] >= 12 && $cx->[0] < 7000)) {
 
-  # Calculate (k-j) * (k-j+1) ... k .. (k+j-1) * (k + j)
-  # See http://blogten.blogspot.com/2007/01/calculating-n.html
-  # The above series can be expressed as factors:
-  #   k * k - (j - i) * 2
-  # We cache k*k, and calculate (j * j) as the sum of the first j odd integers
+        # Calculate (k-j) * (k-j+1) ... k .. (k+j-1) * (k + j)
+        # See http://blogten.blogspot.com/2007/01/calculating-n.html
+        # The above series can be expressed as factors:
+        #   k * k - (j - i) * 2
+        # We cache k*k, and calculate (j * j) as the sum of the first j odd integers
 
-  # This will not work when N exceeds the storage of a Perl scalar, however,
-  # in this case the algorithm would be way to slow to terminate, anyway.
+        # This will not work when N exceeds the storage of a Perl scalar, however,
+        # in this case the algorithm would be way too slow to terminate, anyway.
 
-  # As soon as the last element of $cx is 0, we split it up and remember
-  # how many zeors we got so far. The reason is that n! will accumulate
-  # zeros at the end rather fast.
-  my $zero_elements = 0;
+        # As soon as the last element of $cx is 0, we split it up and remember
+        # how many zeors we got so far. The reason is that n! will accumulate
+        # zeros at the end rather fast.
+        my $zero_elements = 0;
 
-  # If n is even, set n = n -1
-  my $k = _num($c,$cx); my $even = 1;
-  if (($k & 1) == 0)
-    {
-    $even = $k; $k --;
-    }
-  # set k to the center point
-  $k = ($k + 1) / 2;
-#  print "k $k even: $even\n";
-  # now calculate k * k
-  my $k2 = $k * $k;
-  my $odd = 1; my $sum = 1;
-  my $i = $k - 1;
-  # keep reference to x
-  my $new_x = _new($c, $k * $even);
-  @$cx = @$new_x;
-  if ($cx->[0] == 0)
-    {
-    $zero_elements ++; shift @$cx;
-    }
-#  print STDERR "x = ", _str($c,$cx),"\n";
-  my $BASE2 = int(sqrt($BASE))-1;
-  my $j = 1; 
-  while ($j <= $i)
-    {
-    my $m = ($k2 - $sum); $odd += 2; $sum += $odd; $j++;
-    while ($j <= $i && ($m < $BASE2) && (($k2 - $sum) < $BASE2))
-      {
-      $m *= ($k2 - $sum);
-      $odd += 2; $sum += $odd; $j++;
-#      print STDERR "\n k2 $k2 m $m sum $sum odd $odd\n"; sleep(1);
-      }
-    if ($m < $BASE)
-      {
-      _mul($c,$cx,[$m]);
-      }
-    else
-      {
-      _mul($c,$cx,$c->_new($m));
-      }
-    if ($cx->[0] == 0)
-      {
-      $zero_elements ++; shift @$cx;
-      }
-#    print STDERR "Calculate $k2 - $sum = $m (x = ", _str($c,$cx),")\n";
-    }
-  # multiply in the zeros again
-  unshift @$cx, (0) x $zero_elements; 
-  return $cx;
-  }
-
-  # go forward until $base is exceeded
-  # limit is either $x steps (steps == 100 means a result always too high) or
-  # $base.
-  my $steps = 100; $steps = $cx->[0] if @$cx == 1;
-  my $r = 2; my $cf = 3; my $step = 2; my $last = $r;
-  while ($r*$cf < $BASE && $step < $steps)
-    {
-    $last = $r; $r *= $cf++; $step++;
-    }
-  if ((@$cx == 1) && $step == $cx->[0])
-    {
-    # completely done, so keep reference to $x and return
-    $cx->[0] = $r;
-    return $cx;
-    }
-  
-  # now we must do the left over steps
-  my $n;					# steps still to do
-  if (scalar @$cx == 1)
-    {
-    $n = $cx->[0];
-    }
-  else
-    {
-    $n = _copy($c,$cx);
+        # If n is even, set n = n -1
+        my $k = _num($c, $cx);
+        my $even = 1;
+        if (($k & 1) == 0) {
+            $even = $k;
+            $k --;
+        }
+        # set k to the center point
+        $k = ($k + 1) / 2;
+        #  print "k $k even: $even\n";
+        # now calculate k * k
+        my $k2 = $k * $k;
+        my $odd = 1;
+        my $sum = 1;
+        my $i = $k - 1;
+        # keep reference to x
+        my $new_x = _new($c, $k * $even);
+        @$cx = @$new_x;
+        if ($cx->[0] == 0) {
+            $zero_elements ++;
+            shift @$cx;
+        }
+        #  print STDERR "x = ", _str($c, $cx), "\n";
+        my $BASE2 = int(sqrt($BASE))-1;
+        my $j = 1;
+        while ($j <= $i) {
+            my $m = ($k2 - $sum);
+            $odd += 2;
+            $sum += $odd;
+            $j++;
+            while ($j <= $i && ($m < $BASE2) && (($k2 - $sum) < $BASE2)) {
+                $m *= ($k2 - $sum);
+                $odd += 2;
+                $sum += $odd;
+                $j++;
+                #      print STDERR "\n k2 $k2 m $m sum $sum odd $odd\n"; sleep(1);
+            }
+            if ($m < $BASE) {
+                _mul($c, $cx, [$m]);
+            } else {
+                _mul($c, $cx, $c->_new($m));
+            }
+            if ($cx->[0] == 0) {
+                $zero_elements ++;
+                shift @$cx;
+            }
+            #    print STDERR "Calculate $k2 - $sum = $m (x = ", _str($c, $cx), ")\n";
+        }
+        # multiply in the zeros again
+        unshift @$cx, (0) x $zero_elements;
+        return $cx;
     }
 
-  # Set $cx to the last result below $BASE (but keep ref to $x)
-  $cx->[0] = $last; splice (@$cx,1);
-  # As soon as the last element of $cx is 0, we split it up and remember
-  # how many zeors we got so far. The reason is that n! will accumulate
-  # zeros at the end rather fast.
-  my $zero_elements = 0;
+    # go forward until $base is exceeded limit is either $x steps (steps == 100
+    # means a result always too high) or $base.
+    my $steps = 100;
+    $steps = $cx->[0] if @$cx == 1;
+    my $r = 2;
+    my $cf = 3;
+    my $step = 2;
+    my $last = $r;
+    while ($r * $cf < $BASE && $step < $steps) {
+        $last = $r;
+        $r *= $cf++;
+        $step++;
+    }
+    if ((@$cx == 1) && $step == $cx->[0]) {
+        # completely done, so keep reference to $x and return
+        $cx->[0] = $r;
+        return $cx;
+    }
 
-  # do left-over steps fit into a scalar?
-  if (ref $n eq 'ARRAY')
-    {
-    # No, so use slower inc() & cmp()
-    # ($n is at least $BASE here)
-    my $base_2 = int(sqrt($BASE)) - 1;
-    #print STDERR "base_2: $base_2\n"; 
-    while ($step < $base_2)
-      {
-      if ($cx->[0] == 0)
-        {
-        $zero_elements ++; shift @$cx;
-        }
-      my $b = $step * ($step + 1); $step += 2;
-      _mul($c,$cx,[$b]);
-      }
-    $step = [$step];
-    while (_acmp($c,$step,$n) <= 0)
-      {
-      if ($cx->[0] == 0)
-        {
-        $zero_elements ++; shift @$cx;
+    # now we must do the left over steps
+    my $n;                      # steps still to do
+    if (@$cx == 1) {
+        $n = $cx->[0];
+    } else {
+        $n = _copy($c, $cx);
+    }
+
+    # Set $cx to the last result below $BASE (but keep ref to $x)
+    $cx->[0] = $last;
+    splice (@$cx, 1);
+    # As soon as the last element of $cx is 0, we split it up and remember
+    # how many zeors we got so far. The reason is that n! will accumulate
+    # zeros at the end rather fast.
+    my $zero_elements = 0;
+
+    # do left-over steps fit into a scalar?
+    if (ref $n eq 'ARRAY') {
+        # No, so use slower inc() & cmp()
+        # ($n is at least $BASE here)
+        my $base_2 = int(sqrt($BASE)) - 1;
+        #print STDERR "base_2: $base_2\n";
+        while ($step < $base_2) {
+            if ($cx->[0] == 0) {
+                $zero_elements ++;
+                shift @$cx;
+            }
+            my $b = $step * ($step + 1);
+            $step += 2;
+            _mul($c, $cx, [$b]);
         }
-      _mul($c,$cx,$step); _inc($c,$step);
-      }
-    }
-  else
-    {
-    # Yes, so we can speed it up slightly
-  
-#    print "# left over steps $n\n";
-
-    my $base_4 = int(sqrt(sqrt($BASE))) - 2;
-    #print STDERR "base_4: $base_4\n";
-    my $n4 = $n - 4; 
-    while ($step < $n4 && $step < $base_4)
-      {
-      if ($cx->[0] == 0)
-        {
-        $zero_elements ++; shift @$cx;
-        }
-      my $b = $step * ($step + 1); $step += 2; $b *= $step * ($step + 1); $step += 2;
-      _mul($c,$cx,[$b]);
-      }
-    my $base_2 = int(sqrt($BASE)) - 1;
-    my $n2 = $n - 2; 
-    #print STDERR "base_2: $base_2\n"; 
-    while ($step < $n2 && $step < $base_2)
-      {
-      if ($cx->[0] == 0)
-        {
-        $zero_elements ++; shift @$cx;
-        }
-      my $b = $step * ($step + 1); $step += 2;
-      _mul($c,$cx,[$b]);
-      }
-    # do what's left over
-    while ($step <= $n)
-      {
-      _mul($c,$cx,[$step]); $step++;
-      if ($cx->[0] == 0)
-        {
-        $zero_elements ++; shift @$cx;
+        $step = [$step];
+        while (_acmp($c, $step, $n) <= 0) {
+            if ($cx->[0] == 0) {
+                $zero_elements ++;
+                shift @$cx;
+            }
+            _mul($c, $cx, $step);
+            _inc($c, $step);
+        }
+    } else {
+        # Yes, so we can speed it up slightly
+
+        #    print "# left over steps $n\n";
+
+        my $base_4 = int(sqrt(sqrt($BASE))) - 2;
+        #print STDERR "base_4: $base_4\n";
+        my $n4 = $n - 4;
+        while ($step < $n4 && $step < $base_4) {
+            if ($cx->[0] == 0) {
+                $zero_elements ++;
+                shift @$cx;
+            }
+            my $b = $step * ($step + 1);
+            $step += 2;
+            $b *= $step * ($step + 1);
+            $step += 2;
+            _mul($c, $cx, [$b]);
+        }
+        my $base_2 = int(sqrt($BASE)) - 1;
+        my $n2 = $n - 2;
+        #print STDERR "base_2: $base_2\n";
+        while ($step < $n2 && $step < $base_2) {
+            if ($cx->[0] == 0) {
+                $zero_elements ++;
+                shift @$cx;
+            }
+            my $b = $step * ($step + 1);
+            $step += 2;
+            _mul($c, $cx, [$b]);
+        }
+        # do what's left over
+        while ($step <= $n) {
+            _mul($c, $cx, [$step]);
+            $step++;
+            if ($cx->[0] == 0) {
+                $zero_elements ++;
+                shift @$cx;
+            }
         }
-      }
     }
-  # multiply in the zeros again
-  unshift @$cx, (0) x $zero_elements;
-  $cx;			# return result
-  }
+    # multiply in the zeros again
+    unshift @$cx, (0) x $zero_elements;
+    $cx;                        # return result
+}
 
 #############################################################################
 
-sub _log_int
-  {
-  # calculate integer log of $x to base $base
-  # ref to array, ref to array - return ref to array
-  my ($c,$x,$base) = @_;
-
-  # X == 0 => NaN
-  return if (scalar @$x == 1 && $x->[0] == 0);
-  # BASE 0 or 1 => NaN
-  return if (scalar @$base == 1 && $base->[0] < 2);
-  my $cmp = _acmp($c,$x,$base); # X == BASE => 1
-  if ($cmp == 0)
-    {
-    splice (@$x,1); $x->[0] = 1;
-    return ($x,1)
-    }
-  # X < BASE
-  if ($cmp < 0)
-    {
-    splice (@$x,1); $x->[0] = 0;
-    return ($x,undef);
+sub _log_int {
+    # calculate integer log of $x to base $base
+    # ref to array, ref to array - return ref to array
+    my ($c, $x, $base) = @_;
+
+    # X == 0 => NaN
+    return if (@$x == 1 && $x->[0] == 0);
+    # BASE 0 or 1 => NaN
+    return if (@$base == 1 && $base->[0] < 2);
+    my $cmp = _acmp($c, $x, $base); # X == BASE => 1
+    if ($cmp == 0) {
+        splice (@$x, 1);
+        $x->[0] = 1;
+        return ($x, 1)
+    }
+    # X < BASE
+    if ($cmp < 0) {
+        splice (@$x, 1);
+        $x->[0] = 0;
+        return ($x, undef);
+    }
+
+    my $x_org = _copy($c, $x);   # preserve x
+    splice(@$x, 1);
+    $x->[0] = 1;                # keep ref to $x
+
+    # Compute a guess for the result based on:
+    # $guess = int ( length_in_base_10(X) / ( log(base) / log(10) ) )
+    my $len = _len($c, $x_org);
+    my $log = log($base->[-1]) / log(10);
+
+    # for each additional element in $base, we add $BASE_LEN to the result,
+    # based on the observation that log($BASE, 10) is BASE_LEN and
+    # log(x*y) == log(x) + log(y):
+    $log += (@$base - 1) * $BASE_LEN;
+
+    # calculate now a guess based on the values obtained above:
+    my $res = int($len / $log);
+
+    $x->[0] = $res;
+    my $trial = _pow ($c, _copy($c, $base), $x);
+    my $a = _acmp($c, $trial, $x_org);
+
+    #  print STDERR "# trial ", _str($c, $x), " was: $a (0 = exact, -1 too small, +1 too big)\n";
+
+    # found an exact result?
+    return ($x, 1) if $a == 0;
+
+    if ($a > 0) {
+        # or too big
+        _div($c, $trial, $base);
+        _dec($c, $x);
+        while (($a = _acmp($c, $trial, $x_org)) > 0) {
+            #      print STDERR "# big _log_int at ", _str($c, $x), "\n";
+            _div($c, $trial, $base);
+            _dec($c, $x);
+        }
+        # result is now exact (a == 0), or too small (a < 0)
+        return ($x, $a == 0 ? 1 : 0);
     }
 
-  my $x_org = _copy($c,$x);		# preserve x
-  splice(@$x,1); $x->[0] = 1;		# keep ref to $x
+    # else: result was to small
+    _mul($c, $trial, $base);
 
-  # Compute a guess for the result based on:
-  # $guess = int ( length_in_base_10(X) / ( log(base) / log(10) ) )
-  my $len = _len($c,$x_org);
-  my $log = log($base->[-1]) / log(10);
+    # did we now get the right result?
+    $a = _acmp($c, $trial, $x_org);
 
-  # for each additional element in $base, we add $BASE_LEN to the result,
-  # based on the observation that log($BASE,10) is BASE_LEN and
-  # log(x*y) == log(x) + log(y):
-  $log += ((scalar @$base)-1) * $BASE_LEN;
+    if ($a == 0)                # yes, exactly
+    {
+        _inc($c, $x);
+        return ($x, 1);
+    }
+    return ($x, 0) if $a > 0;
 
-  # calculate now a guess based on the values obtained above:
-  my $res = int($len / $log);
+    # Result still too small (we should come here only if the estimate above
+    # was very off base):
 
-  $x->[0] = $res;
-  my $trial = _pow ($c, _copy($c, $base), $x);
-  my $a = _acmp($c,$trial,$x_org);
+    # Now let the normal trial run obtain the real result
+    # Simple loop that increments $x by 2 in each step, possible overstepping
+    # the real result
 
-#  print STDERR "# trial ", _str($c,$x)," was: $a (0 = exact, -1 too small, +1 too big)\n";
+    my $base_mul = _mul($c, _copy($c, $base), $base); # $base * $base
 
-  # found an exact result?
-  return ($x,1) if $a == 0;
+    while (($a = _acmp($c, $trial, $x_org)) < 0) {
+        #    print STDERR "# small _log_int at ", _str($c, $x), "\n";
+        _mul($c, $trial, $base_mul);
+        _add($c, $x, [2]);
+    }
 
-  if ($a > 0)
-    {
-    # or too big
-    _div($c,$trial,$base); _dec($c, $x);
-    while (($a = _acmp($c,$trial,$x_org)) > 0)
-      {
-#      print STDERR "# big _log_int at ", _str($c,$x), "\n"; 
-      _div($c,$trial,$base); _dec($c, $x);
-      }
-    # result is now exact (a == 0), or too small (a < 0)
-    return ($x, $a == 0 ? 1 : 0);
+    my $exact = 1;
+    if ($a > 0) {
+        # overstepped the result
+        _dec($c, $x);
+        _div($c, $trial, $base);
+        $a = _acmp($c, $trial, $x_org);
+        if ($a > 0) {
+            _dec($c, $x);
+        }
+        $exact = 0 if $a != 0;  # a = -1 => not exact result, a = 0 => exact
     }
 
-  # else: result was to small
-  _mul($c,$trial,$base);
+    ($x, $exact);                # return result
+}
 
-  # did we now get the right result?
-  $a = _acmp($c,$trial,$x_org);
+# for debugging:
+use constant DEBUG => 0;
+my $steps = 0;
+sub steps { $steps };
+
+sub _sqrt {
+    # square-root of $x in place
+    # Compute a guess of the result (by rule of thumb), then improve it via
+    # Newton's method.
+    my ($c, $x) = @_;
 
-  if ($a == 0)				# yes, exactly
-    {
-    _inc($c, $x);
-    return ($x,1); 
+    if (@$x == 1) {
+        # fits into one Perl scalar, so result can be computed directly
+        $x->[0] = int(sqrt($x->[0]));
+        return $x;
     }
-  return ($x,0) if $a > 0;  
-
-  # Result still too small (we should come here only if the estimate above
-  # was very off base):
- 
-  # Now let the normal trial run obtain the real result
-  # Simple loop that increments $x by 2 in each step, possible overstepping
-  # the real result
+    my $y = _copy($c, $x);
+    # hopefully _len/2 is < $BASE, the -1 is to always undershot the guess
+    # since our guess will "grow"
+    my $l = int((_len($c, $x)-1) / 2);
+
+    my $lastelem = $x->[-1];    # for guess
+    my $elems = @$x - 1;
+    # not enough digits, but could have more?
+    if ((length($lastelem) <= 3) && ($elems > 1)) {
+        # right-align with zero pad
+        my $len = length($lastelem) & 1;
+        print "$lastelem => " if DEBUG;
+        $lastelem .= substr($x->[-2] . '0' x $BASE_LEN, 0, $BASE_LEN);
+        # former odd => make odd again, or former even to even again
+        $lastelem = $lastelem / 10 if (length($lastelem) & 1) != $len;
+        print "$lastelem\n" if DEBUG;
+    }
+
+    # construct $x (instead of _lsft($c, $x, $l, 10)
+    my $r = $l % $BASE_LEN;     # 10000 00000 00000 00000 ($BASE_LEN=5)
+    $l = int($l / $BASE_LEN);
+    print "l =  $l " if DEBUG;
+
+    splice @$x, $l;              # keep ref($x), but modify it
+
+    # we make the first part of the guess not '1000...0' but int(sqrt($lastelem))
+    # that gives us:
+    # 14400 00000 => sqrt(14400) => guess first digits to be 120
+    # 144000 000000 => sqrt(144000) => guess 379
+
+    print "$lastelem (elems $elems) => " if DEBUG;
+    $lastelem = $lastelem / 10 if ($elems & 1 == 1); # odd or even?
+    my $g = sqrt($lastelem);
+    $g =~ s/\.//;               # 2.345 => 2345
+    $r -= 1 if $elems & 1 == 0; # 70 => 7
+
+    # padd with zeros if result is too short
+    $x->[$l--] = int(substr($g . '0' x $r, 0, $r+1));
+    print "now ", $x->[-1] if DEBUG;
+    print " would have been ", int('1' . '0' x $r), "\n" if DEBUG;
+
+    # If @$x > 1, we could compute the second elem of the guess, too, to create
+    # an even better guess. Not implemented yet. Does it improve performance?
+    $x->[$l--] = 0 while ($l >= 0); # all other digits of guess are zero
+
+    print "start x= ", _str($c, $x), "\n" if DEBUG;
+    my $two = _two();
+    my $last = _zero();
+    my $lastlast = _zero();
+    $steps = 0 if DEBUG;
+    while (_acmp($c, $last, $x) != 0 && _acmp($c, $lastlast, $x) != 0) {
+        $steps++ if DEBUG;
+        $lastlast = _copy($c, $last);
+        $last = _copy($c, $x);
+        _add($c, $x, _div($c, _copy($c, $y), $x));
+        _div($c, $x, $two );
+        print " x= ", _str($c, $x), "\n" if DEBUG;
+    }
+    print "\nsteps in sqrt: $steps, " if DEBUG;
+    _dec($c, $x) if _acmp($c, $y, _mul($c, _copy($c, $x), $x)) < 0; # overshot?
+    print " final ", $x->[-1], "\n" if DEBUG;
+    $x;
+}
 
-  my $base_mul = _mul($c, _copy($c,$base), $base);	# $base * $base
+sub _root {
+    # take n'th root of $x in place (n >= 3)
+    my ($c, $x, $n) = @_;
 
-  while (($a = _acmp($c,$trial,$x_org)) < 0)
-    {
-#    print STDERR "# small _log_int at ", _str($c,$x), "\n"; 
-    _mul($c,$trial,$base_mul); _add($c, $x, [2]);
+    if (@$x == 1) {
+        if (@$n > 1) {
+            # result will always be smaller than 2 so trunc to 1 at once
+            $x->[0] = 1;
+        } else {
+            # fits into one Perl scalar, so result can be computed directly
+            # cannot use int() here, because it rounds wrongly (try
+            # (81 ** 3) ** (1/3) to see what I mean)
+            #$x->[0] = int( $x->[0] ** (1 / $n->[0]) );
+            # round to 8 digits, then truncate result to integer
+            $x->[0] = int ( sprintf ("%.8f", $x->[0] ** (1 / $n->[0]) ) );
+        }
+        return $x;
     }
 
-  my $exact = 1;
-  if ($a > 0)
-    {
-    # overstepped the result
-    _dec($c, $x);
-    _div($c,$trial,$base);
-    $a = _acmp($c,$trial,$x_org);
-    if ($a > 0)
-      {
-      _dec($c, $x);
-      }
-    $exact = 0 if $a != 0;		# a = -1 => not exact result, a = 0 => exact
-    }
-  
-  ($x,$exact);				# return result
-  }
-
-# for debugging:
-  use constant DEBUG => 0;
-  my $steps = 0;
-  sub steps { $steps };
-
-sub _sqrt
-  {
-  # square-root of $x in place
-  # Compute a guess of the result (by rule of thumb), then improve it via
-  # Newton's method.
-  my ($c,$x) = @_;
-
-  if (scalar @$x == 1)
-    {
-    # fits into one Perl scalar, so result can be computed directly
-    $x->[0] = int(sqrt($x->[0]));
-    return $x;
-    } 
-  my $y = _copy($c,$x);
-  # hopefully _len/2 is < $BASE, the -1 is to always undershot the guess
-  # since our guess will "grow"
-  my $l = int((_len($c,$x)-1) / 2);	
-
-  my $lastelem = $x->[-1];					# for guess
-  my $elems = scalar @$x - 1;
-  # not enough digits, but could have more?
-  if ((length($lastelem) <= 3) && ($elems > 1))
-    {
-    # right-align with zero pad
-    my $len = length($lastelem) & 1;
-    print "$lastelem => " if DEBUG;
-    $lastelem .= substr($x->[-2] . '0' x $BASE_LEN,0,$BASE_LEN);
-    # former odd => make odd again, or former even to even again
-    $lastelem = $lastelem / 10 if (length($lastelem) & 1) != $len;
-    print "$lastelem\n" if DEBUG;
-    }
-
-  # construct $x (instead of _lsft($c,$x,$l,10)
-  my $r = $l % $BASE_LEN;	# 10000 00000 00000 00000 ($BASE_LEN=5)
-  $l = int($l / $BASE_LEN);
-  print "l =  $l " if DEBUG;
-
-  splice @$x,$l;		# keep ref($x), but modify it
-
-  # we make the first part of the guess not '1000...0' but int(sqrt($lastelem))
-  # that gives us:
-  # 14400 00000 => sqrt(14400) => guess first digits to be 120
-  # 144000 000000 => sqrt(144000) => guess 379
-
-  print "$lastelem (elems $elems) => " if DEBUG;
-  $lastelem = $lastelem / 10 if ($elems & 1 == 1);		# odd or even?
-  my $g = sqrt($lastelem); $g =~ s/\.//;			# 2.345 => 2345
-  $r -= 1 if $elems & 1 == 0;					# 70 => 7
-
-  # padd with zeros if result is too short
-  $x->[$l--] = int(substr($g . '0' x $r,0,$r+1));
-  print "now ",$x->[-1] if DEBUG;
-  print " would have been ", int('1' . '0' x $r),"\n" if DEBUG;
-
-  # If @$x > 1, we could compute the second elem of the guess, too, to create
-  # an even better guess. Not implemented yet. Does it improve performance?
-  $x->[$l--] = 0 while ($l >= 0);	# all other digits of guess are zero
-
-  print "start x= ",_str($c,$x),"\n" if DEBUG;
-  my $two = _two();
-  my $last = _zero();
-  my $lastlast = _zero();
-  $steps = 0 if DEBUG;
-  while (_acmp($c,$last,$x) != 0 && _acmp($c,$lastlast,$x) != 0)
-    {
-    $steps++ if DEBUG;
-    $lastlast = _copy($c,$last);
-    $last = _copy($c,$x);
-    _add($c,$x, _div($c,_copy($c,$y),$x));
-    _div($c,$x, $two );
-    print " x= ",_str($c,$x),"\n" if DEBUG;
-    }
-  print "\nsteps in sqrt: $steps, " if DEBUG;
-  _dec($c,$x) if _acmp($c,$y,_mul($c,_copy($c,$x),$x)) < 0;	# overshot? 
-  print " final ",$x->[-1],"\n" if DEBUG;
-  $x;
-  }
-
-sub _root
-  {
-  # take n'th root of $x in place (n >= 3)
-  my ($c,$x,$n) = @_;
- 
-  if (scalar @$x == 1)
-    {
-    if (scalar @$n > 1)
-      {
-      # result will always be smaller than 2 so trunc to 1 at once
-      $x->[0] = 1;
-      }
-    else
-      {
-      # fits into one Perl scalar, so result can be computed directly
-      # cannot use int() here, because it rounds wrongly (try 
-      # (81 ** 3) ** (1/3) to see what I mean)
-      #$x->[0] = int( $x->[0] ** (1 / $n->[0]) );
-      # round to 8 digits, then truncate result to integer
-      $x->[0] = int ( sprintf ("%.8f", $x->[0] ** (1 / $n->[0]) ) );
-      }
-    return $x;
-    } 
+    # we know now that X is more than one element long
+
+    # if $n is a power of two, we can repeatedly take sqrt($X) and find the
+    # proper result, because sqrt(sqrt($x)) == root($x, 4)
+    my $b = _as_bin($c, $n);
+    if ($b =~ /0b1(0+)$/) {
+        my $count = CORE::length($1); # 0b100 => len('00') => 2
+        my $cnt = $count;             # counter for loop
+        unshift (@$x, 0);             # add one element, together with one
+        # more below in the loop this makes 2
+        while ($cnt-- > 0) {
+            # 'inflate' $X by adding one element, basically computing
+            # $x * $BASE * $BASE. This gives us more $BASE_LEN digits for result
+            # since len(sqrt($X)) approx == len($x) / 2.
+            unshift (@$x, 0);
+            # calculate sqrt($x), $x is now one element to big, again. In the next
+            # round we make that two, again.
+            _sqrt($c, $x);
+        }
+        # $x is now one element to big, so truncate result by removing it
+        splice (@$x, 0, 1);
+    } else {
+        # trial computation by starting with 2, 4, 8, 16 etc until we overstep
+        my $step;
+        my $trial = _two();
+
+        # while still to do more than X steps
+        do {
+            $step = _two();
+            while (_acmp($c, _pow($c, _copy($c, $trial), $n), $x) < 0) {
+                _mul ($c, $step, [2]);
+                _add ($c, $trial, $step);
+            }
+
+            # hit exactly?
+            if (_acmp($c, _pow($c, _copy($c, $trial), $n), $x) == 0) {
+                @$x = @$trial;  # make copy while preserving ref to $x
+                return $x;
+            }
+            # overstepped, so go back on step
+            _sub($c, $trial, $step);
+        } while (@$step > 1 || $step->[0] > 128);
+
+        # reset step to 2
+        $step = _two();
+        # add two, because $trial cannot be exactly the result (otherwise we would
+        # already have found it)
+        _add($c, $trial, $step);
+
+        # and now add more and more (2, 4, 6, 8, 10 etc)
+        while (_acmp($c, _pow($c, _copy($c, $trial), $n), $x) < 0) {
+            _add ($c, $trial, $step);
+        }
 
-  # we know now that X is more than one element long
+        # hit not exactly? (overstepped)
+        if (_acmp($c, _pow($c, _copy($c, $trial), $n), $x) > 0) {
+            _dec($c, $trial);
+        }
 
-  # if $n is a power of two, we can repeatedly take sqrt($X) and find the
-  # proper result, because sqrt(sqrt($x)) == root($x,4)
-  my $b = _as_bin($c,$n);
-  if ($b =~ /0b1(0+)$/)
-    {
-    my $count = CORE::length($1);	# 0b100 => len('00') => 2
-    my $cnt = $count;			# counter for loop
-    unshift (@$x, 0);			# add one element, together with one
-					# more below in the loop this makes 2
-    while ($cnt-- > 0)
-      {
-      # 'inflate' $X by adding one element, basically computing
-      # $x * $BASE * $BASE. This gives us more $BASE_LEN digits for result
-      # since len(sqrt($X)) approx == len($x) / 2.
-      unshift (@$x, 0);
-      # calculate sqrt($x), $x is now one element to big, again. In the next
-      # round we make that two, again.
-      _sqrt($c,$x);
-      }
-    # $x is now one element to big, so truncate result by removing it
-    splice (@$x,0,1);
-    } 
-  else
-    {
-    # trial computation by starting with 2,4,8,16 etc until we overstep
-    my $step;
-    my $trial = _two();
-
-    # while still to do more than X steps
-    do
-      {
-      $step = _two();
-      while (_acmp($c, _pow($c, _copy($c, $trial), $n), $x) < 0)
-        {
-        _mul ($c, $step, [2]);
-        _add ($c, $trial, $step);
+        # hit not exactly? (overstepped)
+        # 80 too small, 81 slightly too big, 82 too big
+        if (_acmp($c, _pow($c, _copy($c, $trial), $n), $x) > 0) {
+            _dec ($c, $trial);
         }
 
-      # hit exactly?
-      if (_acmp($c, _pow($c, _copy($c, $trial), $n), $x) == 0)
-        {
-        @$x = @$trial;			# make copy while preserving ref to $x
+        @$x = @$trial;          # make copy while preserving ref to $x
         return $x;
-        }
-      # overstepped, so go back on step
-      _sub($c, $trial, $step);
-      } while (scalar @$step > 1 || $step->[0] > 128);
-
-    # reset step to 2
-    $step = _two();
-    # add two, because $trial cannot be exactly the result (otherwise we would
-    # already have found it)
-    _add($c, $trial, $step);
- 
-    # and now add more and more (2,4,6,8,10 etc)
-    while (_acmp($c, _pow($c, _copy($c, $trial), $n), $x) < 0)
-      {
-      _add ($c, $trial, $step);
-      }
-
-    # hit not exactly? (overstepped)
-    if (_acmp($c, _pow($c, _copy($c, $trial), $n), $x) > 0)
-      {
-      _dec($c,$trial);
-      }
-
-    # hit not exactly? (overstepped)
-    # 80 too small, 81 slightly too big, 82 too big
-    if (_acmp($c, _pow($c, _copy($c, $trial), $n), $x) > 0)
-      {
-      _dec ($c, $trial); 
-      }
-
-    @$x = @$trial;			# make copy while preserving ref to $x
-    return $x;
     }
-  $x; 
-  }
+    $x;
+}
 
 ##############################################################################
 # binary stuff
 
-sub _and
-  {
-  my ($c,$x,$y) = @_;
-
-  # the shortcut makes equal, large numbers _really_ fast, and makes only a
-  # very small performance drop for small numbers (e.g. something with less
-  # than 32 bit) Since we optimize for large numbers, this is enabled.
-  return $x if _acmp($c,$x,$y) == 0;		# shortcut
-  
-  my $m = _one(); my ($xr,$yr);
-  my $mask = $AND_MASK;
-
-  my $x1 = $x;
-  my $y1 = _copy($c,$y);			# make copy
-  $x = _zero();
-  my ($b,$xrr,$yrr);
-  use integer;
-  while (!_is_zero($c,$x1) && !_is_zero($c,$y1))
-    {
-    ($x1, $xr) = _div($c,$x1,$mask);
-    ($y1, $yr) = _div($c,$y1,$mask);
-
-    # make ints() from $xr, $yr
-    # this is when the AND_BITS are greater than $BASE and is slower for
-    # small (<256 bits) numbers, but faster for large numbers. Disabled
-    # due to KISS principle
-
-#    $b = 1; $xrr = 0; foreach (@$xr) { $xrr += $_ * $b; $b *= $BASE; }
-#    $b = 1; $yrr = 0; foreach (@$yr) { $yrr += $_ * $b; $b *= $BASE; }
-#    _add($c,$x, _mul($c, _new( $c, ($xrr & $yrr) ), $m) );
-    
-    # 0+ due to '&' doesn't work in strings
-    _add($c,$x, _mul($c, [ 0+$xr->[0] & 0+$yr->[0] ], $m) );
-    _mul($c,$m,$mask);
-    }
-  $x;
-  }
-
-sub _xor
-  {
-  my ($c,$x,$y) = @_;
-
-  return _zero() if _acmp($c,$x,$y) == 0;	# shortcut (see -and)
-
-  my $m = _one(); my ($xr,$yr);
-  my $mask = $XOR_MASK;
-
-  my $x1 = $x;
-  my $y1 = _copy($c,$y);			# make copy
-  $x = _zero();
-  my ($b,$xrr,$yrr);
-  use integer;
-  while (!_is_zero($c,$x1) && !_is_zero($c,$y1))
-    {
-    ($x1, $xr) = _div($c,$x1,$mask);
-    ($y1, $yr) = _div($c,$y1,$mask);
-    # make ints() from $xr, $yr (see _and())
-    #$b = 1; $xrr = 0; foreach (@$xr) { $xrr += $_ * $b; $b *= $BASE; }
-    #$b = 1; $yrr = 0; foreach (@$yr) { $yrr += $_ * $b; $b *= $BASE; }
-    #_add($c,$x, _mul($c, _new( $c, ($xrr ^ $yrr) ), $m) );
-
-    # 0+ due to '^' doesn't work in strings
-    _add($c,$x, _mul($c, [ 0+$xr->[0] ^ 0+$yr->[0] ], $m) );
-    _mul($c,$m,$mask);
-    }
-  # the loop stops when the shorter of the two numbers is exhausted
-  # the remainder of the longer one will survive bit-by-bit, so we simple
-  # multiply-add it in
-  _add($c,$x, _mul($c, $x1, $m) ) if !_is_zero($c,$x1);
-  _add($c,$x, _mul($c, $y1, $m) ) if !_is_zero($c,$y1);
-  
-  $x;
-  }
-
-sub _or
-  {
-  my ($c,$x,$y) = @_;
-
-  return $x if _acmp($c,$x,$y) == 0;		# shortcut (see _and)
-
-  my $m = _one(); my ($xr,$yr);
-  my $mask = $OR_MASK;
-
-  my $x1 = $x;
-  my $y1 = _copy($c,$y);			# make copy
-  $x = _zero();
-  my ($b,$xrr,$yrr);
-  use integer;
-  while (!_is_zero($c,$x1) && !_is_zero($c,$y1))
-    {
-    ($x1, $xr) = _div($c,$x1,$mask);
-    ($y1, $yr) = _div($c,$y1,$mask);
-    # make ints() from $xr, $yr (see _and())
-#    $b = 1; $xrr = 0; foreach (@$xr) { $xrr += $_ * $b; $b *= $BASE; }
-#    $b = 1; $yrr = 0; foreach (@$yr) { $yrr += $_ * $b; $b *= $BASE; }
-#    _add($c,$x, _mul($c, _new( $c, ($xrr | $yrr) ), $m) );
-    
-    # 0+ due to '|' doesn't work in strings
-    _add($c,$x, _mul($c, [ 0+$xr->[0] | 0+$yr->[0] ], $m) );
-    _mul($c,$m,$mask);
-    }
-  # the loop stops when the shorter of the two numbers is exhausted
-  # the remainder of the longer one will survive bit-by-bit, so we simple
-  # multiply-add it in
-  _add($c,$x, _mul($c, $x1, $m) ) if !_is_zero($c,$x1);
-  _add($c,$x, _mul($c, $y1, $m) ) if !_is_zero($c,$y1);
-  
-  $x;
-  }
-
-sub _as_hex
-  {
-  # convert a decimal number to hex (ref to array, return ref to string)
-  my ($c,$x) = @_;
-
-  # fits into one element (handle also 0x0 case)
-  return sprintf("0x%x",$x->[0]) if @$x == 1;
-
-  my $x1 = _copy($c,$x);
-
-  my $es = '';
-  my ($xr, $h, $x10000);
-  if ($] >= 5.006)
-    {
-    $x10000 = [ 0x10000 ]; $h = 'h4';
-    }
-  else
-    {
-    $x10000 = [ 0x1000 ]; $h = 'h3';
+sub _and {
+    my ($c, $x, $y) = @_;
+
+    # the shortcut makes equal, large numbers _really_ fast, and makes only a
+    # very small performance drop for small numbers (e.g. something with less
+    # than 32 bit) Since we optimize for large numbers, this is enabled.
+    return $x if _acmp($c, $x, $y) == 0; # shortcut
+
+    my $m = _one();
+    my ($xr, $yr);
+    my $mask = $AND_MASK;
+
+    my $x1 = $x;
+    my $y1 = _copy($c, $y);      # make copy
+    $x = _zero();
+    my ($b, $xrr, $yrr);
+    use integer;
+    while (!_is_zero($c, $x1) && !_is_zero($c, $y1)) {
+        ($x1, $xr) = _div($c, $x1, $mask);
+        ($y1, $yr) = _div($c, $y1, $mask);
+
+        # make ints() from $xr, $yr
+        # this is when the AND_BITS are greater than $BASE and is slower for
+        # small (<256 bits) numbers, but faster for large numbers. Disabled
+        # due to KISS principle
+
+        #    $b = 1; $xrr = 0; foreach (@$xr) { $xrr += $_ * $b; $b *= $BASE; }
+        #    $b = 1; $yrr = 0; foreach (@$yr) { $yrr += $_ * $b; $b *= $BASE; }
+        #    _add($c, $x, _mul($c, _new( $c, ($xrr & $yrr) ), $m) );
+
+        # 0+ due to '&' doesn't work in strings
+        _add($c, $x, _mul($c, [ 0 + $xr->[0] & 0 + $yr->[0] ], $m) );
+        _mul($c, $m, $mask);
     }
-  while (@$x1 != 1 || $x1->[0] != 0)		# _is_zero()
-    {
-    ($x1, $xr) = _div($c,$x1,$x10000);
-    $es .= unpack($h,pack('V',$xr->[0]));
-    }
-  $es = reverse $es;
-  $es =~ s/^[0]+//;   # strip leading zeros
-  '0x' . $es;					# return result prepended with 0x
-  }
-
-sub _as_bin
-  {
-  # convert a decimal number to bin (ref to array, return ref to string)
-  my ($c,$x) = @_;
-
-  # fits into one element (and Perl recent enough), handle also 0b0 case
-  # handle zero case for older Perls
-  if ($] <= 5.005 && @$x == 1 && $x->[0] == 0)
-    {
-    my $t = '0b0'; return $t;
+    $x;
+}
+
+sub _xor {
+    my ($c, $x, $y) = @_;
+
+    return _zero() if _acmp($c, $x, $y) == 0; # shortcut (see -and)
+
+    my $m = _one();
+    my ($xr, $yr);
+    my $mask = $XOR_MASK;
+
+    my $x1 = $x;
+    my $y1 = _copy($c, $y);      # make copy
+    $x = _zero();
+    my ($b, $xrr, $yrr);
+    use integer;
+    while (!_is_zero($c, $x1) && !_is_zero($c, $y1)) {
+        ($x1, $xr) = _div($c, $x1, $mask);
+        ($y1, $yr) = _div($c, $y1, $mask);
+        # make ints() from $xr, $yr (see _and())
+        #$b = 1; $xrr = 0; foreach (@$xr) { $xrr += $_ * $b; $b *= $BASE; }
+        #$b = 1; $yrr = 0; foreach (@$yr) { $yrr += $_ * $b; $b *= $BASE; }
+        #_add($c, $x, _mul($c, _new( $c, ($xrr ^ $yrr) ), $m) );
+
+        # 0+ due to '^' doesn't work in strings
+        _add($c, $x, _mul($c, [ 0+$xr->[0] ^ 0+$yr->[0] ], $m) );
+        _mul($c, $m, $mask);
+    }
+    # the loop stops when the shorter of the two numbers is exhausted
+    # the remainder of the longer one will survive bit-by-bit, so we simple
+    # multiply-add it in
+    _add($c, $x, _mul($c, $x1, $m) ) if !_is_zero($c, $x1);
+    _add($c, $x, _mul($c, $y1, $m) ) if !_is_zero($c, $y1);
+
+    $x;
+}
+
+sub _or {
+    my ($c, $x, $y) = @_;
+
+    return $x if _acmp($c, $x, $y) == 0; # shortcut (see _and)
+
+    my $m = _one();
+    my ($xr, $yr);
+    my $mask = $OR_MASK;
+
+    my $x1 = $x;
+    my $y1 = _copy($c, $y);      # make copy
+    $x = _zero();
+    my ($b, $xrr, $yrr);
+    use integer;
+    while (!_is_zero($c, $x1) && !_is_zero($c, $y1)) {
+        ($x1, $xr) = _div($c, $x1, $mask);
+        ($y1, $yr) = _div($c, $y1, $mask);
+        # make ints() from $xr, $yr (see _and())
+        #    $b = 1; $xrr = 0; foreach (@$xr) { $xrr += $_ * $b; $b *= $BASE; }
+        #    $b = 1; $yrr = 0; foreach (@$yr) { $yrr += $_ * $b; $b *= $BASE; }
+        #    _add($c, $x, _mul($c, _new( $c, ($xrr | $yrr) ), $m) );
+
+        # 0+ due to '|' doesn't work in strings
+        _add($c, $x, _mul($c, [ 0+$xr->[0] | 0+$yr->[0] ], $m) );
+        _mul($c, $m, $mask);
+    }
+    # the loop stops when the shorter of the two numbers is exhausted
+    # the remainder of the longer one will survive bit-by-bit, so we simple
+    # multiply-add it in
+    _add($c, $x, _mul($c, $x1, $m) ) if !_is_zero($c, $x1);
+    _add($c, $x, _mul($c, $y1, $m) ) if !_is_zero($c, $y1);
+
+    $x;
+}
+
+sub _as_hex {
+    # convert a decimal number to hex (ref to array, return ref to string)
+    my ($c, $x) = @_;
+
+    # fits into one element (handle also 0x0 case)
+    return sprintf("0x%x", $x->[0]) if @$x == 1;
+
+    my $x1 = _copy($c, $x);
+
+    my $es = '';
+    my ($xr, $h, $x10000);
+    if ($] >= 5.006) {
+        $x10000 = [ 0x10000 ];
+        $h = 'h4';
+    } else {
+        $x10000 = [ 0x1000 ];
+        $h = 'h3';
     }
-  if (@$x == 1 && $] >= 5.006)
+    while (@$x1 != 1 || $x1->[0] != 0) # _is_zero()
     {
-    my $t = sprintf("0b%b",$x->[0]);
-    return $t;
+        ($x1, $xr) = _div($c, $x1, $x10000);
+        $es .= unpack($h, pack('V', $xr->[0]));
     }
-  my $x1 = _copy($c,$x);
+    $es = reverse $es;
+    $es =~ s/^[0]+//;           # strip leading zeros
+    '0x' . $es;                 # return result prepended with 0x
+}
 
-  my $es = '';
-  my ($xr, $b, $x10000);
-  if ($] >= 5.006)
-    {
-    $x10000 = [ 0x10000 ]; $b = 'b16';
+sub _as_bin {
+    # convert a decimal number to bin (ref to array, return ref to string)
+    my ($c, $x) = @_;
+
+    # fits into one element (and Perl recent enough), handle also 0b0 case
+    # handle zero case for older Perls
+    if ($] <= 5.005 && @$x == 1 && $x->[0] == 0) {
+        my $t = '0b0';
+        return $t;
     }
-  else
-    {
-    $x10000 = [ 0x1000 ]; $b = 'b12';
+    if (@$x == 1 && $] >= 5.006) {
+        my $t = sprintf("0b%b", $x->[0]);
+        return $t;
+    }
+    my $x1 = _copy($c, $x);
+
+    my $es = '';
+    my ($xr, $b, $x10000);
+    if ($] >= 5.006) {
+        $x10000 = [ 0x10000 ];
+        $b = 'b16';
+    } else {
+        $x10000 = [ 0x1000 ];
+        $b = 'b12';
     }
-  while (!(@$x1 == 1 && $x1->[0] == 0))		# _is_zero()
+    while (!(@$x1 == 1 && $x1->[0] == 0)) # _is_zero()
     {
-    ($x1, $xr) = _div($c,$x1,$x10000);
-    $es .= unpack($b,pack('v',$xr->[0]));
+        ($x1, $xr) = _div($c, $x1, $x10000);
+        $es .= unpack($b, pack('v', $xr->[0]));
     }
-  $es = reverse $es;
-  $es =~ s/^[0]+//;   # strip leading zeros
-  '0b' . $es;					# return result prepended with 0b
-  }
+    $es = reverse $es;
+    $es =~ s/^[0]+//;           # strip leading zeros
+    '0b' . $es;                 # return result prepended with 0b
+}
 
-sub _as_oct
-  {
-  # convert a decimal number to octal (ref to array, return ref to string)
-  my ($c,$x) = @_;
+sub _as_oct {
+    # convert a decimal number to octal (ref to array, return ref to string)
+    my ($c, $x) = @_;
 
-  # fits into one element (handle also 0 case)
-  return sprintf("0%o",$x->[0]) if @$x == 1;
+    # fits into one element (handle also 0 case)
+    return sprintf("0%o", $x->[0]) if @$x == 1;
 
-  my $x1 = _copy($c,$x);
+    my $x1 = _copy($c, $x);
 
-  my $es = '';
-  my $xr;
-  my $x1000 = [ 0100000 ];
-  while (@$x1 != 1 || $x1->[0] != 0)		# _is_zero()
+    my $es = '';
+    my $xr;
+    my $x1000 = [ 0100000 ];
+    while (@$x1 != 1 || $x1->[0] != 0) # _is_zero()
     {
-    ($x1, $xr) = _div($c,$x1,$x1000);
-    $es .= reverse sprintf("%05o", $xr->[0]);
+        ($x1, $xr) = _div($c, $x1, $x1000);
+        $es .= reverse sprintf("%05o", $xr->[0]);
     }
-  $es = reverse $es;
-  $es =~ s/^0+//;   # strip leading zeros
-  '0' . $es;					# return result prepended with 0
-  }
-
-sub _from_oct
-  {
-  # convert a octal number to decimal (string, return ref to array)
-  my ($c,$os) = @_;
-
-  # for older Perls, play safe
-  my $m = [ 0100000 ];
-  my $d = 5;					# 5 digits at a time
+    $es = reverse $es;
+    $es =~ s/^0+//;             # strip leading zeros
+    '0' . $es;                  # return result prepended with 0
+}
 
-  my $mul = _one();
-  my $x = _zero();
+sub _from_oct {
+    # convert a octal number to decimal (string, return ref to array)
+    my ($c, $os) = @_;
 
-  my $len = int( (length($os)-1)/$d );		# $d digit parts, w/o the '0'
-  my $val; my $i = -$d;
-  while ($len >= 0)
-    {
-    $val = substr($os,$i,$d);			# get oct digits
-    $val = CORE::oct($val);
-    $i -= $d; $len --;
-    my $adder = [ $val ];
-    _add ($c, $x, _mul ($c, $adder, $mul ) ) if $val != 0;
-    _mul ($c, $mul, $m ) if $len >= 0; 		# skip last mul
-    }
-  $x;
-  }
-
-sub _from_hex
-  {
-  # convert a hex number to decimal (string, return ref to array)
-  my ($c,$hs) = @_;
-
-  my $m = _new($c, 0x10000000);			# 28 bit at a time (<32 bit!)
-  my $d = 7;					# 7 digits at a time
-  if ($] <= 5.006)
-    {
     # for older Perls, play safe
-    $m = [ 0x10000 ];				# 16 bit at a time (<32 bit!)
-    $d = 4;					# 4 digits at a time
+    my $m = [ 0100000 ];
+    my $d = 5;                  # 5 digits at a time
+
+    my $mul = _one();
+    my $x = _zero();
+
+    my $len = int((length($os) - 1) / $d); # $d digit parts, w/o the '0'
+    my $val;
+    my $i = -$d;
+    while ($len >= 0) {
+        $val = substr($os, $i, $d); # get oct digits
+        $val = CORE::oct($val);
+        $i -= $d;
+        $len --;
+        my $adder = [ $val ];
+        _add($c, $x, _mul($c, $adder, $mul)) if $val != 0;
+        _mul($c, $mul, $m ) if $len >= 0; # skip last mul
     }
+    $x;
+}
 
-  my $mul = _one();
-  my $x = _zero();
+sub _from_hex {
+    # convert a hex number to decimal (string, return ref to array)
+    my ($c, $hs) = @_;
+
+    my $m = _new($c, 0x10000000); # 28 bit at a time (<32 bit!)
+    my $d = 7;                    # 7 digits at a time
+    if ($] <= 5.006) {
+        # for older Perls, play safe
+        $m = [ 0x10000 ];       # 16 bit at a time (<32 bit!)
+        $d = 4;                 # 4 digits at a time
+    }
+
+    my $mul = _one();
+    my $x = _zero();
+
+    my $len = int((length($hs) - 2) / $d); # $d digit parts, w/o the '0x'
+    my $val;
+    my $i = -$d;
+    while ($len >= 0) {
+        $val = substr($hs, $i, $d);     # get hex digits
+        $val =~ s/^0x// if $len == 0; # for last part only because
+        $val = CORE::hex($val);       # hex does not like wrong chars
+        $i -= $d;
+        $len --;
+        my $adder = [ $val ];
+        # if the resulting number was to big to fit into one element, create a
+        # two-element version (bug found by Mark Lakata - Thanx!)
+        if (CORE::length($val) > $BASE_LEN) {
+            $adder = _new($c, $val);
+        }
+        _add($c, $x, _mul($c, $adder, $mul)) if $val != 0;
+        _mul($c, $mul, $m) if $len >= 0; # skip last mul
+    }
+    $x;
+}
 
-  my $len = int( (length($hs)-2)/$d );		# $d digit parts, w/o the '0x'
-  my $val; my $i = -$d;
-  while ($len >= 0)
-    {
-    $val = substr($hs,$i,$d);			# get hex digits
-    $val =~ s/^0x// if $len == 0;		# for last part only because
-    $val = CORE::hex($val);			# hex does not like wrong chars
-    $i -= $d; $len --;
-    my $adder = [ $val ];
-    # if the resulting number was to big to fit into one element, create a
-    # two-element version (bug found by Mark Lakata - Thanx!)
-    if (CORE::length($val) > $BASE_LEN)
-      {
-      $adder = _new($c,$val);
-      }
-    _add ($c, $x, _mul ($c, $adder, $mul ) ) if $val != 0;
-    _mul ($c, $mul, $m ) if $len >= 0; 		# skip last mul
-    }
-  $x;
-  }
-
-sub _from_bin
-  {
-  # convert a hex number to decimal (string, return ref to array)
-  my ($c,$bs) = @_;
-
-  # instead of converting X (8) bit at a time, it is faster to "convert" the
-  # number to hex, and then call _from_hex.
-
-  my $hs = $bs;
-  $hs =~ s/^[+-]?0b//;					# remove sign and 0b
-  my $l = length($hs);					# bits
-  $hs = '0' x (8-($l % 8)) . $hs if ($l % 8) != 0;	# padd left side w/ 0
-  my $h = '0x' . unpack('H*', pack ('B*', $hs));	# repack as hex
-  
-  $c->_from_hex($h);
-  }
+sub _from_bin {
+    # convert a hex number to decimal (string, return ref to array)
+    my ($c, $bs) = @_;
+
+    # instead of converting X (8) bit at a time, it is faster to "convert" the
+    # number to hex, and then call _from_hex.
+
+    my $hs = $bs;
+    $hs =~ s/^[+-]?0b//;                                # remove sign and 0b
+    my $l = length($hs);                                # bits
+    $hs = '0' x (8 - ($l % 8)) . $hs if ($l % 8) != 0;  # padd left side w/ 0
+    my $h = '0x' . unpack('H*', pack ('B*', $hs));      # repack as hex
+
+    $c->_from_hex($h);
+}
 
 ##############################################################################
 # special modulus functions
 
-sub _modinv
-  {
-  # modular multiplicative inverse
-  my ($c,$x,$y) = @_;
-
-  # modulo zero
-  if (_is_zero($c, $y)) {
-      return (undef, undef);
-  }
-
-  # modulo one
-  if (_is_one($c, $y)) {
-      return (_zero($c), '+');
-  }
-
-  my $u = _zero($c);
-  my $v = _one($c);
-  my $a = _copy($c,$y);
-  my $b = _copy($c,$x);
-
-  # Euclid's Algorithm for bgcd(), only that we calc bgcd() ($a) and the result
-  # ($u) at the same time. See comments in BigInt for why this works.
-  my $q;
-  my $sign = 1;
-  {
-      ($a, $q, $b) = ($b, _div($c, $a, $b));        # step 1
-      last if _is_zero($c, $b);
-
-      my $t = _add($c,                              # step 2:
-                   _mul($c, _copy($c, $v), $q) ,    #  t =   v * q
-                   $u );                            #      + u
-      $u = $v;                                      #  u = v
-      $v = $t;                                      #  v = t
-      $sign = -$sign;
-      redo;
-  }
-
-  # if the gcd is not 1, then return NaN
-  return (undef, undef) unless _is_one($c, $a);
-
-  ($v, $sign == 1 ? '+' : '-');
-  }
-
-sub _modpow
-  {
-  # modulus of power ($x ** $y) % $z
-  my ($c,$num,$exp,$mod) = @_;
-
-  # a^b (mod 1) = 0 for all a and b
-  if (_is_one($c,$mod))
+sub _modinv {
+    # modular multiplicative inverse
+    my ($c, $x, $y) = @_;
+
+    # modulo zero
+    if (_is_zero($c, $y)) {
+        return (undef, undef);
+    }
+
+    # modulo one
+    if (_is_one($c, $y)) {
+        return (_zero($c), '+');
+    }
+
+    my $u = _zero($c);
+    my $v = _one($c);
+    my $a = _copy($c, $y);
+    my $b = _copy($c, $x);
+
+    # Euclid's Algorithm for bgcd(), only that we calc bgcd() ($a) and the result
+    # ($u) at the same time. See comments in BigInt for why this works.
+    my $q;
+    my $sign = 1;
     {
+        ($a, $q, $b) = ($b, _div($c, $a, $b)); # step 1
+        last if _is_zero($c, $b);
+
+        my $t = _add($c,                           # step 2:
+                     _mul($c, _copy($c, $v), $q) , #  t =   v * q
+                     $u );                         #      + u
+        $u = $v;                                   #  u = v
+        $v = $t;                                   #  v = t
+        $sign = -$sign;
+        redo;
+    }
+
+    # if the gcd is not 1, then return NaN
+    return (undef, undef) unless _is_one($c, $a);
+
+    ($v, $sign == 1 ? '+' : '-');
+}
+
+sub _modpow {
+    # modulus of power ($x ** $y) % $z
+    my ($c, $num, $exp, $mod) = @_;
+
+    # a^b (mod 1) = 0 for all a and b
+    if (_is_one($c, $mod)) {
         @$num = 0;
         return $num;
     }
 
-  # 0^a (mod m) = 0 if m != 0, a != 0
-  # 0^0 (mod m) = 1 if m != 0
-  if (_is_zero($c, $num)) {
-      if (_is_zero($c, $exp)) {
-          @$num = 1;
-      } else {
-          @$num = 0;
-      }
-      return $num;
-  }
+    # 0^a (mod m) = 0 if m != 0, a != 0
+    # 0^0 (mod m) = 1 if m != 0
+    if (_is_zero($c, $num)) {
+        if (_is_zero($c, $exp)) {
+            @$num = 1;
+        } else {
+            @$num = 0;
+        }
+        return $num;
+    }
 
-#  $num = _mod($c,$num,$mod);	# this does not make it faster
+    #  $num = _mod($c, $num, $mod);   # this does not make it faster
 
-  my $acc = _copy($c,$num); my $t = _one();
+    my $acc = _copy($c, $num);
+    my $t = _one();
 
-  my $expbin = _as_bin($c,$exp); $expbin =~ s/^0b//;
-  my $len = length($expbin);
-  while (--$len >= 0)
-    {
-    if ( substr($expbin,$len,1) eq '1')			# is_odd
-      {
-      _mul($c,$t,$acc);
-      $t = _mod($c,$t,$mod);
-      }
-    _mul($c,$acc,$acc);
-    $acc = _mod($c,$acc,$mod);
-    }
-  @$num = @$t;
-  $num;
-  }
+    my $expbin = _as_bin($c, $exp);
+    $expbin =~ s/^0b//;
+    my $len = length($expbin);
+    while (--$len >= 0) {
+        if (substr($expbin, $len, 1) eq '1') { # is_odd
+            _mul($c, $t, $acc);
+            $t = _mod($c, $t, $mod);
+        }
+        _mul($c, $acc, $acc);
+        $acc = _mod($c, $acc, $mod);
+    }
+    @$num = @$t;
+    $num;
+}
 
 sub _gcd {
     # Greatest common divisor.
 
     my ($c, $x, $y) = @_;
 
-    # gcd(0,0) = 0
-    # gcd(0,a) = a, if a != 0
+    # gcd(0, 0) = 0
+    # gcd(0, a) = a, if a != 0
 
     if (@$x == 1 && $x->[0] == 0) {
         if (@$y == 1 && $y->[0] == 0) {
@@ -2476,7 +2363,7 @@ sub _gcd {
 
         my $tmp = [ @$x ];
         @$x = @$y;
-        $y = $tmp;      # no deref here; that would modify input $y
+        $y = $tmp;              # no deref here; that would modify input $y
     }
 
     return $x;
@@ -2486,6 +2373,7 @@ sub _gcd {
 ##############################################################################
 
 1;
+
 __END__
 
 =pod
@@ -2518,7 +2406,7 @@ In order to allow for multiple big integer libraries, Math::BigInt was
 rewritten to use a plug-in library for core math routines. Any module which
 conforms to the API can be used by Math::BigInt by using this in your program:
 
-	use Math::BigInt lib => 'libname';
+        use Math::BigInt lib => 'libname';
 
 'libname' is either the long name, like 'Math::BigInt::Pari', or only the short
 version, like 'Pari'.
@@ -2866,9 +2754,9 @@ Return the binomial coefficient OBJ1 over OBJ1.
 
 =item I<_alen(OBJ)>
 
-Return the approximate number of decimal digits of the object. The
-output is one Perl scalar. This estimate must be greater than or equal
-to what C<_len()> returns.
+Return the approximate number of decimal digits of the object. The output is
+one Perl scalar. This estimate must be greater than or equal to what C<_len()>
+returns.
 
 =back
 
@@ -2901,15 +2789,16 @@ Return the signed bitwise exclusive or.
 =head1 WRAP YOUR OWN
 
 If you want to port your own favourite c-lib for big numbers to the
-Math::BigInt interface, you can take any of the already existing modules as
-a rough guideline. You should really wrap up the latest BigInt and BigFloat
-testsuites with your module, and replace in them any of the following:
+Math::BigInt interface, you can take any of the already existing modules as a
+rough guideline. You should really wrap up the latest Math::BigInt and
+Math::BigFloat testsuites with your module, and replace in them any of the
+following:
 
-	use Math::BigInt;
+        use Math::BigInt;
 
 by this:
 
-	use Math::BigInt lib => 'yourlib';
+        use Math::BigInt lib => 'yourlib';
 
 This way you ensure that your library really works 100% within Math::BigInt.
 
@@ -2975,7 +2864,7 @@ L<http://lists.scsys.co.uk/cgi-bin/mailman/listinfo/bignum>
 =head1 LICENSE
 
 This program is free software; you may redistribute it and/or modify it under
-the same terms as Perl itself. 
+the same terms as Perl itself.
 
 =head1 AUTHORS
 
@@ -3003,7 +2892,7 @@ E<lt>pjacklam@online.noE<gt>
 
 =head1 SEE ALSO
 
-L<Math::BigInt>, L<Math::BigFloat>,
-L<Math::BigInt::GMP>, L<Math::BigInt::FastCalc> and L<Math::BigInt::Pari>.
+L<Math::BigInt>, L<Math::BigFloat>, L<Math::BigInt::GMP>,
+L<Math::BigInt::FastCalc> and L<Math::BigInt::Pari>.
 
 =cut
diff --git a/cpan/Math-BigInt/lib/Math/BigInt/CalcEmu.pm b/cpan/Math-BigInt/lib/Math/BigInt/CalcEmu.pm
index 8e994ede27..509a071a49 100644
--- a/cpan/Math-BigInt/lib/Math/BigInt/CalcEmu.pm
+++ b/cpan/Math-BigInt/lib/Math/BigInt/CalcEmu.pm
@@ -4,7 +4,7 @@ use 5.006001;
 use strict;
 use warnings;
 
-our $VERSION = '1.999715';
+our $VERSION = '1.999724';
 $VERSION = eval $VERSION;
 
 package Math::BigInt;
diff --git a/cpan/Math-BigInt/t/bare_mbf.t b/cpan/Math-BigInt/t/bare_mbf.t
index 38fdae3c95..6b9af66eaa 100644
--- a/cpan/Math-BigInt/t/bare_mbf.t
+++ b/cpan/Math-BigInt/t/bare_mbf.t
@@ -3,7 +3,7 @@
 use strict;
 use warnings;
 
-use Test::More tests => 2409;
+use Test::More tests => 2402;
 
 use lib 't';
 
diff --git a/cpan/Math-BigInt/t/bare_mbi.t b/cpan/Math-BigInt/t/bare_mbi.t
index b87625d078..93dbc7a131 100644
--- a/cpan/Math-BigInt/t/bare_mbi.t
+++ b/cpan/Math-BigInt/t/bare_mbi.t
@@ -3,7 +3,7 @@
 use strict;
 use warnings;
 
-use Test::More tests => 3724;           # tests in require'd file
+use Test::More tests => 3913;           # tests in require'd file
 
 use lib 't';
 
diff --git a/cpan/Math-BigInt/t/bare_mif.t b/cpan/Math-BigInt/t/bare_mif.t
index 89835bb8bc..d63e3da8a7 100644
--- a/cpan/Math-BigInt/t/bare_mif.t
+++ b/cpan/Math-BigInt/t/bare_mif.t
@@ -6,7 +6,7 @@
 use strict;
 use warnings;
 
-use Test::More tests => 684             # tests in require'd file
+use Test::More tests => 712             # tests in require'd file
                         + 1;            # tests in this file
 
 use lib 't';
diff --git a/cpan/Math-BigInt/t/bdstr-mbf.t b/cpan/Math-BigInt/t/bdstr-mbf.t
new file mode 100644
index 0000000000..8b13bd4403
--- /dev/null
+++ b/cpan/Math-BigInt/t/bdstr-mbf.t
@@ -0,0 +1,275 @@
+#!perl
+
+use strict;
+use warnings;
+
+use Test::More tests => 460;
+
+use Math::BigFloat;
+
+while (<DATA>) {
+    s/#.*$//;                   # remove comments
+    s/\s+$//;                   # remove trailing whitespace
+    next unless length;         # skip empty lines
+
+    my ($x_str, $expected) = split /:/;
+    my ($x, $str);
+
+    my $test = qq|\$x = Math::BigFloat -> new("$x_str");|
+             . qq| \$str = \$x -> bdstr();|;
+
+    note "\n$test\n\n";
+    eval $test;
+
+    is($str, $expected, qq|input value is "$x_str"|);
+    is($x,   $x_str, "input object is unmodified");
+}
+
+__DATA__
+
+NaN:NaN
+
+inf:inf
+-inf:-inf
+
+0:0
+
+# positive numbers
+
+0.000000000001:0.000000000001
+0.00000000001:0.00000000001
+0.0000000001:0.0000000001
+0.000000001:0.000000001
+0.00000001:0.00000001
+0.0000001:0.0000001
+0.000001:0.000001
+0.00001:0.00001
+0.0001:0.0001
+0.001:0.001
+0.01:0.01
+0.1:0.1
+1:1
+10:10
+100:100
+1000:1000
+10000:10000
+100000:100000
+1000000:1000000
+10000000:10000000
+100000000:100000000
+1000000000:1000000000
+10000000000:10000000000
+100000000000:100000000000
+1000000000000:1000000000000
+
+0.0000000000012:0.0000000000012
+0.000000000012:0.000000000012
+0.00000000012:0.00000000012
+0.0000000012:0.0000000012
+0.000000012:0.000000012
+0.00000012:0.00000012
+0.0000012:0.0000012
+0.000012:0.000012
+0.00012:0.00012
+0.0012:0.0012
+0.012:0.012
+0.12:0.12
+1.2:1.2
+12:12
+120:120
+1200:1200
+12000:12000
+120000:120000
+1200000:1200000
+12000000:12000000
+120000000:120000000
+1200000000:1200000000
+12000000000:12000000000
+120000000000:120000000000
+1200000000000:1200000000000
+
+0.00000000000123:0.00000000000123
+0.0000000000123:0.0000000000123
+0.000000000123:0.000000000123
+0.00000000123:0.00000000123
+0.0000000123:0.0000000123
+0.000000123:0.000000123
+0.00000123:0.00000123
+0.0000123:0.0000123
+0.000123:0.000123
+0.00123:0.00123
+0.0123:0.0123
+0.123:0.123
+1.23:1.23
+12.3:12.3
+123:123
+1230:1230
+12300:12300
+123000:123000
+1230000:1230000
+12300000:12300000
+123000000:123000000
+1230000000:1230000000
+12300000000:12300000000
+123000000000:123000000000
+1230000000000:1230000000000
+
+0.000000000001234:0.000000000001234
+0.00000000001234:0.00000000001234
+0.0000000001234:0.0000000001234
+0.000000001234:0.000000001234
+0.00000001234:0.00000001234
+0.0000001234:0.0000001234
+0.000001234:0.000001234
+0.00001234:0.00001234
+0.0001234:0.0001234
+0.001234:0.001234
+0.01234:0.01234
+0.1234:0.1234
+1.234:1.234
+12.34:12.34
+123.4:123.4
+1234:1234
+12340:12340
+123400:123400
+1234000:1234000
+12340000:12340000
+123400000:123400000
+1234000000:1234000000
+12340000000:12340000000
+123400000000:123400000000
+1234000000000:1234000000000
+
+0.000003141592:0.000003141592
+0.00003141592:0.00003141592
+0.0003141592:0.0003141592
+0.003141592:0.003141592
+0.03141592:0.03141592
+0.3141592:0.3141592
+3.141592:3.141592
+31.41592:31.41592
+314.1592:314.1592
+3141.592:3141.592
+31415.92:31415.92
+314159.2:314159.2
+3141592:3141592
+
+# negative numbers
+
+-0.000000000001:-0.000000000001
+-0.00000000001:-0.00000000001
+-0.0000000001:-0.0000000001
+-0.000000001:-0.000000001
+-0.00000001:-0.00000001
+-0.0000001:-0.0000001
+-0.000001:-0.000001
+-0.00001:-0.00001
+-0.0001:-0.0001
+-0.001:-0.001
+-0.01:-0.01
+-0.1:-0.1
+-1:-1
+-10:-10
+-100:-100
+-1000:-1000
+-10000:-10000
+-100000:-100000
+-1000000:-1000000
+-10000000:-10000000
+-100000000:-100000000
+-1000000000:-1000000000
+-10000000000:-10000000000
+-100000000000:-100000000000
+-1000000000000:-1000000000000
+
+-0.0000000000012:-0.0000000000012
+-0.000000000012:-0.000000000012
+-0.00000000012:-0.00000000012
+-0.0000000012:-0.0000000012
+-0.000000012:-0.000000012
+-0.00000012:-0.00000012
+-0.0000012:-0.0000012
+-0.000012:-0.000012
+-0.00012:-0.00012
+-0.0012:-0.0012
+-0.012:-0.012
+-0.12:-0.12
+-1.2:-1.2
+-12:-12
+-120:-120
+-1200:-1200
+-12000:-12000
+-120000:-120000
+-1200000:-1200000
+-12000000:-12000000
+-120000000:-120000000
+-1200000000:-1200000000
+-12000000000:-12000000000
+-120000000000:-120000000000
+-1200000000000:-1200000000000
+
+-0.00000000000123:-0.00000000000123
+-0.0000000000123:-0.0000000000123
+-0.000000000123:-0.000000000123
+-0.00000000123:-0.00000000123
+-0.0000000123:-0.0000000123
+-0.000000123:-0.000000123
+-0.00000123:-0.00000123
+-0.0000123:-0.0000123
+-0.000123:-0.000123
+-0.00123:-0.00123
+-0.0123:-0.0123
+-0.123:-0.123
+-1.23:-1.23
+-12.3:-12.3
+-123:-123
+-1230:-1230
+-12300:-12300
+-123000:-123000
+-1230000:-1230000
+-12300000:-12300000
+-123000000:-123000000
+-1230000000:-1230000000
+-12300000000:-12300000000
+-123000000000:-123000000000
+-1230000000000:-1230000000000
+
+-0.000000000001234:-0.000000000001234
+-0.00000000001234:-0.00000000001234
+-0.0000000001234:-0.0000000001234
+-0.000000001234:-0.000000001234
+-0.00000001234:-0.00000001234
+-0.0000001234:-0.0000001234
+-0.000001234:-0.000001234
+-0.00001234:-0.00001234
+-0.0001234:-0.0001234
+-0.001234:-0.001234
+-0.01234:-0.01234
+-0.1234:-0.1234
+-1.234:-1.234
+-12.34:-12.34
+-123.4:-123.4
+-1234:-1234
+-12340:-12340
+-123400:-123400
+-1234000:-1234000
+-12340000:-12340000
+-123400000:-123400000
+-1234000000:-1234000000
+-12340000000:-12340000000
+-123400000000:-123400000000
+-1234000000000:-1234000000000
+
+-0.000003141592:-0.000003141592
+-0.00003141592:-0.00003141592
+-0.0003141592:-0.0003141592
+-0.003141592:-0.003141592
+-0.03141592:-0.03141592
+-0.3141592:-0.3141592
+-3.141592:-3.141592
+-31.41592:-31.41592
+-314.1592:-314.1592
+-3141.592:-3141.592
+-31415.92:-31415.92
+-314159.2:-314159.2
+-3141592:-3141592
diff --git a/cpan/Math-BigInt/t/bdstr-mbi.t b/cpan/Math-BigInt/t/bdstr-mbi.t
new file mode 100644
index 0000000000..d369ec9f8f
--- /dev/null
+++ b/cpan/Math-BigInt/t/bdstr-mbi.t
@@ -0,0 +1,155 @@
+#!perl
+
+use strict;
+use warnings;
+
+use Test::More tests => 220;
+
+use Math::BigInt;
+
+while (<DATA>) {
+    s/#.*$//;                   # remove comments
+    s/\s+$//;                   # remove trailing whitespace
+    next unless length;         # skip empty lines
+
+    my ($x_str, $expected) = split /:/;
+    my ($x, $str);
+
+    my $test = qq|\$x = Math::BigInt -> new("$x_str");|
+             . qq| \$str = \$x -> bdstr();|;
+
+    note "\n$test\n\n";
+    eval $test;
+
+    is($str, $expected, qq|input value is "$x_str"|);
+    is($x,   $x_str, "input object is unmodified");
+}
+
+__DATA__
+
+NaN:NaN
+
+inf:inf
+-inf:-inf
+
+0:0
+
+# positive numbers
+
+1:1
+10:10
+100:100
+1000:1000
+10000:10000
+100000:100000
+1000000:1000000
+10000000:10000000
+100000000:100000000
+1000000000:1000000000
+10000000000:10000000000
+100000000000:100000000000
+1000000000000:1000000000000
+
+12:12
+120:120
+1200:1200
+12000:12000
+120000:120000
+1200000:1200000
+12000000:12000000
+120000000:120000000
+1200000000:1200000000
+12000000000:12000000000
+120000000000:120000000000
+1200000000000:1200000000000
+
+123:123
+1230:1230
+12300:12300
+123000:123000
+1230000:1230000
+12300000:12300000
+123000000:123000000
+1230000000:1230000000
+12300000000:12300000000
+123000000000:123000000000
+1230000000000:1230000000000
+
+1234:1234
+12340:12340
+123400:123400
+1234000:1234000
+12340000:12340000
+123400000:123400000
+1234000000:1234000000
+12340000000:12340000000
+123400000000:123400000000
+1234000000000:1234000000000
+
+3:3
+31:31
+314:314
+3141:3141
+31415:31415
+314159:314159
+3141592:3141592
+
+# negative numbers
+
+-1:-1
+-10:-10
+-100:-100
+-1000:-1000
+-10000:-10000
+-100000:-100000
+-1000000:-1000000
+-10000000:-10000000
+-100000000:-100000000
+-1000000000:-1000000000
+-10000000000:-10000000000
+-100000000000:-100000000000
+-1000000000000:-1000000000000
+
+-12:-12
+-120:-120
+-1200:-1200
+-12000:-12000
+-120000:-120000
+-1200000:-1200000
+-12000000:-12000000
+-120000000:-120000000
+-1200000000:-1200000000
+-12000000000:-12000000000
+-120000000000:-120000000000
+-1200000000000:-1200000000000
+
+-123:-123
+-1230:-1230
+-12300:-12300
+-123000:-123000
+-1230000:-1230000
+-12300000:-12300000
+-123000000:-123000000
+-1230000000:-1230000000
+-12300000000:-12300000000
+-123000000000:-123000000000
+-1230000000000:-1230000000000
+
+-1234:-1234
+-12340:-12340
+-123400:-123400
+-1234000:-1234000
+-12340000:-12340000
+-123400000:-123400000
+-1234000000:-1234000000
+-12340000000:-12340000000
+-123400000000:-123400000000
+-1234000000000:-1234000000000
+
+-3:-3
+-31:-31
+-314:-314
+-3141:-3141
+-31415:-31415
+-314159:-314159
+-3141592:-3141592
diff --git a/cpan/Math-BigInt/t/bestr-mbf.t b/cpan/Math-BigInt/t/bestr-mbf.t
new file mode 100644
index 0000000000..fcb11078b3
--- /dev/null
+++ b/cpan/Math-BigInt/t/bestr-mbf.t
@@ -0,0 +1,275 @@
+#!perl
+
+use strict;
+use warnings;
+
+use Test::More tests => 460;
+
+use Math::BigFloat;
+
+while (<DATA>) {
+    s/#.*$//;                   # remove comments
+    s/\s+$//;                   # remove trailing whitespace
+    next unless length;         # skip empty lines
+
+    my ($x_str, $expected) = split /:/;
+    my ($x, $str);
+
+    my $test = qq|\$x = Math::BigFloat -> new("$x_str");|
+             . qq| \$str = \$x -> bestr();|;
+
+    note "\n$test\n\n";
+    eval $test;
+
+    is($str, $expected, qq|input value is "$x_str"|);
+    is($x,   $x_str, "input object is unmodified");
+}
+
+__DATA__
+
+NaN:NaN
+
+inf:inf
+-inf:-inf
+
+0:0e+0
+
+# positive numbers
+
+0.000000000001:1e-12
+0.00000000001:10e-12
+0.0000000001:100e-12
+0.000000001:1e-9
+0.00000001:10e-9
+0.0000001:100e-9
+0.000001:1e-6
+0.00001:10e-6
+0.0001:100e-6
+0.001:1e-3
+0.01:10e-3
+0.1:100e-3
+1:1e+0
+10:10e+0
+100:100e+0
+1000:1e+3
+10000:10e+3
+100000:100e+3
+1000000:1e+6
+10000000:10e+6
+100000000:100e+6
+1000000000:1e+9
+10000000000:10e+9
+100000000000:100e+9
+1000000000000:1e+12
+
+0.0000000000012:1.2e-12
+0.000000000012:12e-12
+0.00000000012:120e-12
+0.0000000012:1.2e-9
+0.000000012:12e-9
+0.00000012:120e-9
+0.0000012:1.2e-6
+0.000012:12e-6
+0.00012:120e-6
+0.0012:1.2e-3
+0.012:12e-3
+0.12:120e-3
+1.2:1.2e+0
+12:12e+0
+120:120e+0
+1200:1.2e+3
+12000:12e+3
+120000:120e+3
+1200000:1.2e+6
+12000000:12e+6
+120000000:120e+6
+1200000000:1.2e+9
+12000000000:12e+9
+120000000000:120e+9
+1200000000000:1.2e+12
+
+0.00000000000123:1.23e-12
+0.0000000000123:12.3e-12
+0.000000000123:123e-12
+0.00000000123:1.23e-9
+0.0000000123:12.3e-9
+0.000000123:123e-9
+0.00000123:1.23e-6
+0.0000123:12.3e-6
+0.000123:123e-6
+0.00123:1.23e-3
+0.0123:12.3e-3
+0.123:123e-3
+1.23:1.23e+0
+12.3:12.3e+0
+123:123e+0
+1230:1.23e+3
+12300:12.3e+3
+123000:123e+3
+1230000:1.23e+6
+12300000:12.3e+6
+123000000:123e+6
+1230000000:1.23e+9
+12300000000:12.3e+9
+123000000000:123e+9
+1230000000000:1.23e+12
+
+0.000000000001234:1.234e-12
+0.00000000001234:12.34e-12
+0.0000000001234:123.4e-12
+0.000000001234:1.234e-9
+0.00000001234:12.34e-9
+0.0000001234:123.4e-9
+0.000001234:1.234e-6
+0.00001234:12.34e-6
+0.0001234:123.4e-6
+0.001234:1.234e-3
+0.01234:12.34e-3
+0.1234:123.4e-3
+1.234:1.234e+0
+12.34:12.34e+0
+123.4:123.4e+0
+1234:1.234e+3
+12340:12.34e+3
+123400:123.4e+3
+1234000:1.234e+6
+12340000:12.34e+6
+123400000:123.4e+6
+1234000000:1.234e+9
+12340000000:12.34e+9
+123400000000:123.4e+9
+1234000000000:1.234e+12
+
+0.000003141592:3.141592e-6
+0.00003141592:31.41592e-6
+0.0003141592:314.1592e-6
+0.003141592:3.141592e-3
+0.03141592:31.41592e-3
+0.3141592:314.1592e-3
+3.141592:3.141592e+0
+31.41592:31.41592e+0
+314.1592:314.1592e+0
+3141.592:3.141592e+3
+31415.92:31.41592e+3
+314159.2:314.1592e+3
+3141592:3.141592e+6
+
+# negative numbers
+
+-0.000000000001:-1e-12
+-0.00000000001:-10e-12
+-0.0000000001:-100e-12
+-0.000000001:-1e-9
+-0.00000001:-10e-9
+-0.0000001:-100e-9
+-0.000001:-1e-6
+-0.00001:-10e-6
+-0.0001:-100e-6
+-0.001:-1e-3
+-0.01:-10e-3
+-0.1:-100e-3
+-1:-1e+0
+-10:-10e+0
+-100:-100e+0
+-1000:-1e+3
+-10000:-10e+3
+-100000:-100e+3
+-1000000:-1e+6
+-10000000:-10e+6
+-100000000:-100e+6
+-1000000000:-1e+9
+-10000000000:-10e+9
+-100000000000:-100e+9
+-1000000000000:-1e+12
+
+-0.0000000000012:-1.2e-12
+-0.000000000012:-12e-12
+-0.00000000012:-120e-12
+-0.0000000012:-1.2e-9
+-0.000000012:-12e-9
+-0.00000012:-120e-9
+-0.0000012:-1.2e-6
+-0.000012:-12e-6
+-0.00012:-120e-6
+-0.0012:-1.2e-3
+-0.012:-12e-3
+-0.12:-120e-3
+-1.2:-1.2e+0
+-12:-12e+0
+-120:-120e+0
+-1200:-1.2e+3
+-12000:-12e+3
+-120000:-120e+3
+-1200000:-1.2e+6
+-12000000:-12e+6
+-120000000:-120e+6
+-1200000000:-1.2e+9
+-12000000000:-12e+9
+-120000000000:-120e+9
+-1200000000000:-1.2e+12
+
+-0.00000000000123:-1.23e-12
+-0.0000000000123:-12.3e-12
+-0.000000000123:-123e-12
+-0.00000000123:-1.23e-9
+-0.0000000123:-12.3e-9
+-0.000000123:-123e-9
+-0.00000123:-1.23e-6
+-0.0000123:-12.3e-6
+-0.000123:-123e-6
+-0.00123:-1.23e-3
+-0.0123:-12.3e-3
+-0.123:-123e-3
+-1.23:-1.23e+0
+-12.3:-12.3e+0
+-123:-123e+0
+-1230:-1.23e+3
+-12300:-12.3e+3
+-123000:-123e+3
+-1230000:-1.23e+6
+-12300000:-12.3e+6
+-123000000:-123e+6
+-1230000000:-1.23e+9
+-12300000000:-12.3e+9
+-123000000000:-123e+9
+-1230000000000:-1.23e+12
+
+-0.000000000001234:-1.234e-12
+-0.00000000001234:-12.34e-12
+-0.0000000001234:-123.4e-12
+-0.000000001234:-1.234e-9
+-0.00000001234:-12.34e-9
+-0.0000001234:-123.4e-9
+-0.000001234:-1.234e-6
+-0.00001234:-12.34e-6
+-0.0001234:-123.4e-6
+-0.001234:-1.234e-3
+-0.01234:-12.34e-3
+-0.1234:-123.4e-3
+-1.234:-1.234e+0
+-12.34:-12.34e+0
+-123.4:-123.4e+0
+-1234:-1.234e+3
+-12340:-12.34e+3
+-123400:-123.4e+3
+-1234000:-1.234e+6
+-12340000:-12.34e+6
+-123400000:-123.4e+6
+-1234000000:-1.234e+9
+-12340000000:-12.34e+9
+-123400000000:-123.4e+9
+-1234000000000:-1.234e+12
+
+-0.000003141592:-3.141592e-6
+-0.00003141592:-31.41592e-6
+-0.0003141592:-314.1592e-6
+-0.003141592:-3.141592e-3
+-0.03141592:-31.41592e-3
+-0.3141592:-314.1592e-3
+-3.141592:-3.141592e+0
+-31.41592:-31.41592e+0
+-314.1592:-314.1592e+0
+-3141.592:-3.141592e+3
+-31415.92:-31.41592e+3
+-314159.2:-314.1592e+3
+-3141592:-3.141592e+6
diff --git a/cpan/Math-BigInt/t/bestr-mbi.t b/cpan/Math-BigInt/t/bestr-mbi.t
new file mode 100644
index 0000000000..1d391d4e35
--- /dev/null
+++ b/cpan/Math-BigInt/t/bestr-mbi.t
@@ -0,0 +1,155 @@
+#!perl
+
+use strict;
+use warnings;
+
+use Test::More tests => 220;
+
+use Math::BigInt;
+
+while (<DATA>) {
+    s/#.*$//;                   # remove comments
+    s/\s+$//;                   # remove trailing whitespace
+    next unless length;         # skip empty lines
+
+    my ($x_str, $expected) = split /:/;
+    my ($x, $str);
+
+    my $test = qq|\$x = Math::BigInt -> new("$x_str");|
+             . qq| \$str = \$x -> bestr();|;
+
+    note "\n$test\n\n";
+    eval $test;
+
+    is($str, $expected, qq|input value is "$x_str"|);
+    is($x,   $x_str, "input object is unmodified");
+}
+
+__DATA__
+
+NaN:NaN
+
+inf:inf
+-inf:-inf
+
+0:0e+0
+
+# positive numbers
+
+1:1e+0
+10:10e+0
+100:100e+0
+1000:1e+3
+10000:10e+3
+100000:100e+3
+1000000:1e+6
+10000000:10e+6
+100000000:100e+6
+1000000000:1e+9
+10000000000:10e+9
+100000000000:100e+9
+1000000000000:1e+12
+
+12:12e+0
+120:120e+0
+1200:1.2e+3
+12000:12e+3
+120000:120e+3
+1200000:1.2e+6
+12000000:12e+6
+120000000:120e+6
+1200000000:1.2e+9
+12000000000:12e+9
+120000000000:120e+9
+1200000000000:1.2e+12
+
+123:123e+0
+1230:1.23e+3
+12300:12.3e+3
+123000:123e+3
+1230000:1.23e+6
+12300000:12.3e+6
+123000000:123e+6
+1230000000:1.23e+9
+12300000000:12.3e+9
+123000000000:123e+9
+1230000000000:1.23e+12
+
+1234:1.234e+3
+12340:12.34e+3
+123400:123.4e+3
+1234000:1.234e+6
+12340000:12.34e+6
+123400000:123.4e+6
+1234000000:1.234e+9
+12340000000:12.34e+9
+123400000000:123.4e+9
+1234000000000:1.234e+12
+
+3:3e+0
+31:31e+0
+314:314e+0
+3141:3.141e+3
+31415:31.415e+3
+314159:314.159e+3
+3141592:3.141592e+6
+
+# negative numbers
+
+-1:-1e+0
+-10:-10e+0
+-100:-100e+0
+-1000:-1e+3
+-10000:-10e+3
+-100000:-100e+3
+-1000000:-1e+6
+-10000000:-10e+6
+-100000000:-100e+6
+-1000000000:-1e+9
+-10000000000:-10e+9
+-100000000000:-100e+9
+-1000000000000:-1e+12
+
+-12:-12e+0
+-120:-120e+0
+-1200:-1.2e+3
+-12000:-12e+3
+-120000:-120e+3
+-1200000:-1.2e+6
+-12000000:-12e+6
+-120000000:-120e+6
+-1200000000:-1.2e+9
+-12000000000:-12e+9
+-120000000000:-120e+9
+-1200000000000:-1.2e+12
+
+-123:-123e+0
+-1230:-1.23e+3
+-12300:-12.3e+3
+-123000:-123e+3
+-1230000:-1.23e+6
+-12300000:-12.3e+6
+-123000000:-123e+6
+-1230000000:-1.23e+9
+-12300000000:-12.3e+9
+-123000000000:-123e+9
+-1230000000000:-1.23e+12
+
+-1234:-1.234e+3
+-12340:-12.34e+3
+-123400:-123.4e+3
+-1234000:-1.234e+6
+-12340000:-12.34e+6
+-123400000:-123.4e+6
+-1234000000:-1.234e+9
+-12340000000:-12.34e+9
+-123400000000:-123.4e+9
+-1234000000000:-1.234e+12
+
+-3:-3e+0
+-31:-31e+0
+-314:-314e+0
+-3141:-3.141e+3
+-31415:-31.415e+3
+-314159:-314.159e+3
+-3141592:-3.141592e+6
diff --git a/cpan/Math-BigInt/t/bigfltpm.inc b/cpan/Math-BigInt/t/bigfltpm.inc
index 10d05137df..44b1114091 100644
--- a/cpan/Math-BigInt/t/bigfltpm.inc
+++ b/cpan/Math-BigInt/t/bigfltpm.inc
@@ -15,7 +15,6 @@ while (<DATA>) {
     s/\s+$//;                   # remove trailing whitespace
     next unless length;         # skip empty lines
 
-
     if (s/^&//) {
         $f = $_;
         next;
@@ -71,9 +70,9 @@ while (<DATA>) {
     } elsif ($f eq "bpi") {
         $try .= qq| $CLASS->bpi(\$x);|;
     } elsif ($f eq "binc") {
-        $try .= ' ++$x;';
+        $try .= ' $x->binc();';
     } elsif ($f eq "bdec") {
-        $try .= ' --$x;';
+        $try .= ' $x->bdec();';
     } elsif ($f eq "bround") {
         $try .= qq| $setup; \$x->bround($args[1]);|;
     } elsif ($f eq "bfround") {
@@ -112,7 +111,7 @@ while (<DATA>) {
         } elsif ($f eq "bacmp") {
             $try .= ' $x->bacmp($y);';
         } elsif ($f eq "bpow") {
-            $try .= ' $x ** $y;';
+            $try .= ' $x->bpow($y);';
         } elsif ($f eq "bnok") {
             $try .= ' $x->bnok($y);';
         } elsif ($f eq "bcos") {
@@ -124,21 +123,21 @@ while (<DATA>) {
         } elsif ($f eq "broot") {
             $try .= qq| $setup; \$x->broot(\$y);|;
         } elsif ($f eq "badd") {
-            $try .= ' $x + $y;';
+            $try .= ' $x->badd($y);';
         } elsif ($f eq "bsub") {
-            $try .= ' $x - $y;';
+            $try .= ' $x->bsub($y);';
         } elsif ($f eq "bmul") {
-            $try .= ' $x * $y;';
+            $try .= ' $x->bmul($y);';
         } elsif ($f eq "bdiv") {
-            $try .= qq| $setup; \$x / \$y;|;
+            $try .= qq| $setup; scalar \$x->bdiv(\$y);|;
         } elsif ($f eq "bdiv-list") {
             $try .= qq| $setup; join(",", \$x->bdiv(\$y));|;
         } elsif ($f eq "brsft") {
-            $try .= ' $x >> $y;';
+            $try .= ' $x->brsft($y);';
         } elsif ($f eq "blsft") {
-            $try .= ' $x << $y;';
+            $try .= ' $x->blsft($y);';
         } elsif ($f eq "bmod") {
-            $try .= ' $x % $y;';
+            $try .= ' $x->bmod($y);';
         } else {
             # Functions with three arguments
             $try .= qq| \$z = $CLASS->new("$args[2]");|;
@@ -260,42 +259,6 @@ $CLASS->accuracy(undef);	# reset
 $CLASS->precision(undef);	# reset
 
 ###############################################################################
-# bug in bsstr()/numify() showed up in after-rounding in bdiv()
-
-$x = $CLASS->new("0.008");
-$y = $CLASS->new(2);
-$x->bdiv(3, $y);
-is($x, "0.0027",
-   qq|\$x = $CLASS->new("0.008"); \$y = $CLASS->new(2); \$x->bdiv(3, \$y);|);
-
-###############################################################################
-# Verify that numify() returns a normalized value, and underflows and
-# overflows when given "extreme" values.
-
-like($CLASS->new("12345e67")->numify(), qr/^1\.2345e\+?0*71$/,
-     qq|$CLASS->new("12345e67")->numify()|);
-
-# underflow
-like($CLASS->new("1e-9999")->numify(), qr/^\+?0$/,
-     qq|$CLASS->new("1e-9999")->numify()|);
-
-# overflow
-unlike($CLASS->new("1e9999")->numify(), qr/^1(\.0*)?e\+?9+$/,
-       qq|$CLASS->new("1e9999")->numify()|);
-
-###############################################################################
-# Check numify on non-finite objects.
-
-{
-    require Math::Complex;
-    my $inf = Math::Complex::Inf();
-    my $nan = $inf - $inf;
-    is($CLASS -> binf("+") -> numify(),  $inf, "numify of +Inf");
-    is($CLASS -> binf("-") -> numify(), -$inf, "numify of -Inf");
-    is($CLASS -> bnan()    -> numify(),  $nan, "numify of NaN");
-}
-
-###############################################################################
 # bsqrt() with set global A/P or A/P enabled on $x, also a test whether bsqrt()
 # correctly modifies $x
 
@@ -497,7 +460,7 @@ is($x, 2,
 $x = $CLASS->new("2");
 $y = $CLASS->new("18.2");
 
-# 2 * (2 ** 18.2);
+# 2 * (2 ** int(18.2));
 $x <<= $y;
 is($x->copy()->bfround(-9), "602248.763144685",
    qq|\$x = $CLASS->new("2"); \$y = $CLASS->new("18.2");| .
diff --git a/cpan/Math-BigInt/t/bigfltpm.t b/cpan/Math-BigInt/t/bigfltpm.t
index 2c76155c67..629cb56998 100644
--- a/cpan/Math-BigInt/t/bigfltpm.t
+++ b/cpan/Math-BigInt/t/bigfltpm.t
@@ -3,8 +3,8 @@
 use strict;
 use warnings;
 
-use Test::More tests => 2409            # tests in require'd file
-                        + 5;            # tests in this file
+use Test::More tests => 2402            # tests in require'd file
+                         + 5;           # tests in this file
 
 use Math::BigInt lib => 'Calc';
 use Math::BigFloat;
diff --git a/cpan/Math-BigInt/t/bigintpm.inc b/cpan/Math-BigInt/t/bigintpm.inc
index ad7322c203..e996c69a08 100644
--- a/cpan/Math-BigInt/t/bigintpm.inc
+++ b/cpan/Math-BigInt/t/bigintpm.inc
@@ -110,16 +110,20 @@ while (<DATA>) {
         } elsif ($f eq "bacmp") {
             $try .= ' $x->bacmp($y);';
         } elsif ($f eq "badd") {
-            $try .= ' $x + $y;';
+            $try .= ' $x->badd($y);';
         } elsif ($f eq "bsub") {
-            $try .= ' $x - $y;';
+            $try .= ' $x->bsub($y);';
         } elsif ($f eq "bmul") {
-            $try .= ' $x * $y;';
+            $try .= ' $x->bmul($y);';
         } elsif ($f eq "bdiv") {
-            $try .= ' $x / $y;';
+            $try .= ' $x->bdiv($y);';
         } elsif ($f eq "bdiv-list") {
             $try .= ' join (",", $x->bdiv($y));';
-            # overload via x=
+        } elsif ($f eq "btdiv") {
+            $try .= ' $x->btdiv($y);';
+        } elsif ($f eq "btdiv-list") {
+            $try .= ' join (",", $x->btdiv($y));';
+        # overload via x=
         } elsif ($f =~ /^.=$/) {
             $try .= " \$x $f \$y;";
             # overload via x
@@ -653,18 +657,6 @@ is($x, -3, '$x = Math::Foo->new(5); $x = 8 - $x; $x = -3');
 is(ref($x), 'Math::Foo', '$x is an object of class "Math::Foo"');
 
 ###############################################################################
-# Check numify on non-finite objects.
-
-{
-    require Math::Complex;
-    my $inf = Math::Complex::Inf();
-    my $nan = $inf - $inf;
-    is($CLASS -> binf("+") -> numify(),  $inf, "numify of +Inf");
-    is($CLASS -> binf("-") -> numify(), -$inf, "numify of -Inf");
-    is($CLASS -> bnan()    -> numify(),  $nan, "numify of NaN");
-}
-
-###############################################################################
 # Test whether +inf eq inf
 #
 # This tried to test whether Math::BigInt inf equals Perl inf. Unfortunately,
@@ -1844,43 +1836,83 @@ NaNmul:-inf:NaN
 9999999999999999999:10000000000000000000:99999999999999999990000000000000000000
 
 &bdiv-list
-100:20:5,0
-4095:4095:1,0
--4095:-4095:1,0
-4095:-4095:-1,0
--4095:4095:-1,0
-123:2:61,1
-9:5:1,4
-9:4:2,1
-# inf handling and general remainder
-5:8:0,5
-0:8:0,0
-11:2:5,1
-11:-2:-6,-1
--11:2:-6,1
-# see table in documentation in MBI
-0:inf:0,0
-0:-inf:0,0
-5:inf:0,5
-5:-inf:-1,-inf
--5:inf:-1,inf
--5:-inf:0,-5
-inf:5:inf,NaN
--inf:5:-inf,NaN
+
+# Divide by zero and modulo zero.
+
+inf:0:inf,inf
+5:0:inf,5
+0:0:NaN,0
+-5:0:-inf,-5
+-inf:0:-inf,-inf
+
+# Numerator (dividend) is +/-inf, and denominator is finite and non-zero.
+
+inf:-inf:NaN,NaN
 inf:-5:-inf,NaN
--inf:-5:inf,NaN
-5:5:1,0
--5:-5:1,0
+inf:5:inf,NaN
 inf:inf:NaN,NaN
+
 -inf:-inf:NaN,NaN
+-inf:-5:inf,NaN
+-inf:5:-inf,NaN
 -inf:inf:NaN,NaN
-inf:-inf:NaN,NaN
-8:0:inf,8
-inf:0:inf,inf
-# exceptions to remainder rule
--8:0:-inf,-8
--inf:0:-inf,-inf
-0:0:NaN,0
+
+# Denominator (divisor) is +/-inf. The cases when the numerator is +/-inf
+# are covered above.
+
+-5:inf:-1,inf
+0:inf:0,0
+5:inf:0,5
+
+-5:-inf:0,-5
+0:-inf:0,0
+5:-inf:-1,-inf
+
+# Numerator is finite, and denominator is finite and non-zero.
+
+-5:-5:1,0
+-5:-2:2,-1
+-5:-1:5,0
+-5:1:-5,0
+-5:2:-3,1
+-5:5:-1,0
+-2:-5:0,-2
+-2:-2:1,0
+-2:-1:2,0
+-2:1:-2,0
+-2:2:-1,0
+-2:5:-1,3
+-1:-5:0,-1
+-1:-2:0,-1
+-1:-1:1,0
+-1:1:-1,0
+-1:2:-1,1
+-1:5:-1,4
+0:-5:0,0
+0:-2:0,0
+0:-1:0,0
+0:1:0,0
+0:2:0,0
+0:5:0,0
+1:-5:-1,-4
+1:-2:-1,-1
+1:-1:-1,0
+1:1:1,0
+1:2:0,1
+1:5:0,1
+2:-5:-1,-3
+2:-2:-1,0
+2:-1:-2,0
+2:1:2,0
+2:2:1,0
+2:5:0,2
+5:-5:-1,0
+5:-2:-3,-1
+5:-1:-5,0
+5:1:5,0
+5:2:2,1
+5:5:1,0
+
 # test the shortcut in Calc if @$x == @$yorg
 1234567812345678:123456712345678:10,688888898
 12345671234567:1234561234567:10,58888897
@@ -1916,32 +1948,42 @@ inf:0:inf,inf
 9999999_9999999_9999999_9999999:1_0000000_0000000_0000000:9999999,999999999999999999999
 
 &bdiv
-abc:abc:NaN
-abc:1:NaN
-1:abc:NaN
+
+# Divide by zero and modulo zero.
+
+inf:0:inf
+5:0:inf
 0:0:NaN
-# inf handling (see table in doc)
+-5:0:-inf
+-inf:0:-inf
+
+# Numerator (dividend) is +/-inf, and denominator is finite and non-zero.
+
+inf:-inf:NaN
+inf:-5:-inf
+inf:5:inf
+inf:inf:NaN
+
+-inf:-inf:NaN
+-inf:-5:inf
+-inf:5:-inf
+-inf:inf:NaN
+
+# Denominator (divisor) is +/-inf. The cases when the numerator is +/-inf
+# are covered above.
+
+-5:inf:-1
 0:inf:0
-0:-inf:0
 5:inf:0
-5:-inf:-1
--5:inf:-1
+
 -5:-inf:0
-inf:5:inf
--inf:5:-inf
-inf:-5:-inf
--inf:-5:inf
+0:-inf:0
+5:-inf:-1
+
+# Numerator is finite, and denominator is finite and non-zero.
+
 5:5:1
 -5:-5:1
-inf:inf:NaN
--inf:-inf:NaN
--inf:inf:NaN
-inf:-inf:NaN
-8:0:inf
-inf:0:inf
--8:0:-inf
--inf:0:-inf
-0:0:NaN
 11:2:5
 -11:-2:5
 -11:2:-6
@@ -2033,6 +2075,164 @@ inf:0:inf
 # bug with shortcut in Calc 0.44
 949418181818187070707070707070707070:181818181853535353535353535353535353:5
 
+&btdiv-list
+
+# Divide by zero and modulo zero.
+
+inf:0:inf,inf
+5:0:inf,5
+0:0:NaN,0
+-5:0:-inf,-5
+-inf:0:-inf,-inf
+
+# Numerator (dividend) is +/-inf, and denominator is finite and non-zero.
+
+inf:-inf:NaN,NaN
+inf:-5:-inf,NaN
+inf:5:inf,NaN
+inf:inf:NaN,NaN
+
+-inf:-inf:NaN,NaN
+-inf:-5:inf,NaN
+-inf:5:-inf,NaN
+-inf:inf:NaN,NaN
+
+# Denominator (divisor) is +/-inf. The cases when the numerator is +/-inf
+# are covered above.
+
+-5:inf:0,-5
+0:inf:0,0
+5:inf:0,5
+
+-5:-inf:0,-5
+0:-inf:0,0
+5:-inf:0,5
+
+# Numerator is finite, and denominator is finite and non-zero.
+
+-5:-5:1,0
+-5:-2:2,-1
+-5:-1:5,0
+-5:1:-5,0
+-5:2:-2,-1
+-5:5:-1,0
+-2:-5:0,-2
+-2:-2:1,0
+-2:-1:2,0
+-2:1:-2,0
+-2:2:-1,0
+-2:5:0,-2
+-1:-5:0,-1
+-1:-2:0,-1
+-1:-1:1,0
+-1:1:-1,0
+-1:2:0,-1
+-1:5:0,-1
+0:-5:0,0
+0:-2:0,0
+0:-1:0,0
+0:1:0,0
+0:2:0,0
+0:5:0,0
+1:-5:0,1
+1:-2:0,1
+1:-1:-1,0
+1:1:1,0
+1:2:0,1
+1:5:0,1
+2:-5:0,2
+2:-2:-1,0
+2:-1:-2,0
+2:1:2,0
+2:2:1,0
+2:5:0,2
+5:-5:-1,0
+5:-2:-2,1
+5:-1:-5,0
+5:1:5,0
+5:2:2,1
+5:5:1,0
+
+&btdiv
+
+# Divide by zero and modulo zero.
+
+inf:0:inf
+5:0:inf
+0:0:NaN
+-5:0:-inf
+-inf:0:-inf
+
+# Numerator (dividend) is +/-inf, and denominator is finite and non-zero.
+
+inf:-inf:NaN
+inf:-5:-inf
+inf:5:inf
+inf:inf:NaN
+
+-inf:-inf:NaN
+-inf:-5:inf
+-inf:5:-inf
+-inf:inf:NaN
+
+# Denominator (divisor) is +/-inf. The cases when the numerator is +/-inf
+# are covered above.
+
+-5:inf:0
+0:inf:0
+5:inf:0
+
+-5:-inf:0
+0:-inf:0
+5:-inf:0
+
+# Numerator is finite, and denominator is finite and non-zero.
+
+-5:-5:1
+-5:-2:2
+-5:-1:5
+-5:1:-5
+-5:2:-2
+-5:5:-1
+-2:-5:0
+-2:-2:1
+-2:-1:2
+-2:1:-2
+-2:2:-1
+-2:5:0
+-1:-5:0
+-1:-2:0
+-1:-1:1
+-1:1:-1
+-1:2:0
+-1:5:0
+0:-5:0
+0:-2:0
+0:-1:0
+0:1:0
+0:2:0
+0:5:0
+1:-5:0
+1:-2:0
+1:-1:-1
+1:1:1
+1:2:0
+1:5:0
+2:-5:0
+2:-2:-1
+2:-1:-2
+2:1:2
+2:2:1
+2:5:0
+5:-5:-1
+5:-2:-2
+5:-1:-5
+5:1:5
+5:2:2
+5:5:1
+
+###############################################################################
+
 &bmodinv
 # format: number:modulus:result
 # bmodinv Data errors
@@ -2248,35 +2448,44 @@ inf:5:13:NaN
 5:inf:13:NaN
 
 &bmod
-# inf handling, see table in doc
+
+# Divide by zero and modulo zero.
+
+inf:0:inf
+5:0:5
+0:0:0
+-5:0:-5
+-inf:0:-inf
+
+# Numerator (dividend) is +/-inf, and denominator is finite and non-zero.
+
+inf:-inf:NaN
+inf:-5:NaN
+inf:5:NaN
+inf:inf:NaN
+
+-inf:-inf:NaN
+-inf:-5:NaN
+-inf:5:NaN
+-inf:inf:NaN
+
+# Denominator (divisor) is +/-inf. The cases when the numerator is +/-inf
+# are covered above.
+
+-5:inf:inf
 0:inf:0
-0:-inf:0
 5:inf:5
-5:-inf:-inf
--5:inf:inf
+
 -5:-inf:-5
-inf:5:NaN
--inf:5:NaN
-inf:-5:NaN
--inf:-5:NaN
+0:-inf:0
+5:-inf:-inf
+
+# Numerator is finite, and denominator is finite and non-zero.
+
 5:5:0
 -5:-5:0
-inf:inf:NaN
--inf:-inf:NaN
--inf:inf:NaN
-inf:-inf:NaN
-8:0:8
-inf:0:inf
--inf:0:-inf
--8:0:-8
-0:0:0
-abc:abc:NaN
-abc:1:abc:NaN
-1:abc:NaN
 0:1:0
-1:0:1
 0:-1:0
--1:0:-1
 1:1:0
 -1:-1:0
 1:-1:0
diff --git a/cpan/Math-BigInt/t/bigintpm.t b/cpan/Math-BigInt/t/bigintpm.t
index 7c81c89d54..e87e05a6fa 100644
--- a/cpan/Math-BigInt/t/bigintpm.t
+++ b/cpan/Math-BigInt/t/bigintpm.t
@@ -3,7 +3,7 @@
 use strict;
 use warnings;
 
-use Test::More tests => 3724            # tests in require'd file
+use Test::More tests => 3913            # tests in require'd file
                          + 6;           # tests in this file
 
 use Math::BigInt lib => 'Calc';
diff --git a/cpan/Math-BigInt/t/bnstr-mbf.t b/cpan/Math-BigInt/t/bnstr-mbf.t
new file mode 100644
index 0000000000..d21051a915
--- /dev/null
+++ b/cpan/Math-BigInt/t/bnstr-mbf.t
@@ -0,0 +1,278 @@
+#!perl
+
+use strict;
+use warnings;
+
+use Test::More tests => 460;
+
+use Math::BigFloat;
+
+while (<DATA>) {
+    s/#.*$//;                   # remove comments
+    s/\s+$//;                   # remove trailing whitespace
+    next unless length;         # skip empty lines
+
+    my ($x_str, $expected) = split /:/;
+    my ($x, $str);
+
+    {
+        my $test = qq|\$x = Math::BigFloat -> new("$x_str");|
+                 . qq| \$str = \$x -> bnstr();|;
+
+        note "\n$test\n\n";
+        eval $test;
+
+        is($str, $expected, qq|input value is "$x_str"|);
+        is($x,   $x_str, "input object is unmodified");
+    }
+
+}
+
+__DATA__
+
+NaN:NaN
+
+inf:inf
+-inf:-inf
+
+0:0e+0
+
+# positive numbers
+
+0.000000000001:1e-12
+0.00000000001:1e-11
+0.0000000001:1e-10
+0.000000001:1e-9
+0.00000001:1e-8
+0.0000001:1e-7
+0.000001:1e-6
+0.00001:1e-5
+0.0001:1e-4
+0.001:1e-3
+0.01:1e-2
+0.1:1e-1
+1:1e+0
+10:1e+1
+100:1e+2
+1000:1e+3
+10000:1e+4
+100000:1e+5
+1000000:1e+6
+10000000:1e+7
+100000000:1e+8
+1000000000:1e+9
+10000000000:1e+10
+100000000000:1e+11
+1000000000000:1e+12
+
+0.0000000000012:1.2e-12
+0.000000000012:1.2e-11
+0.00000000012:1.2e-10
+0.0000000012:1.2e-9
+0.000000012:1.2e-8
+0.00000012:1.2e-7
+0.0000012:1.2e-6
+0.000012:1.2e-5
+0.00012:1.2e-4
+0.0012:1.2e-3
+0.012:1.2e-2
+0.12:1.2e-1
+1.2:1.2e+0
+12:1.2e+1
+120:1.2e+2
+1200:1.2e+3
+12000:1.2e+4
+120000:1.2e+5
+1200000:1.2e+6
+12000000:1.2e+7
+120000000:1.2e+8
+1200000000:1.2e+9
+12000000000:1.2e+10
+120000000000:1.2e+11
+1200000000000:1.2e+12
+
+0.00000000000123:1.23e-12
+0.0000000000123:1.23e-11
+0.000000000123:1.23e-10
+0.00000000123:1.23e-9
+0.0000000123:1.23e-8
+0.000000123:1.23e-7
+0.00000123:1.23e-6
+0.0000123:1.23e-5
+0.000123:1.23e-4
+0.00123:1.23e-3
+0.0123:1.23e-2
+0.123:1.23e-1
+1.23:1.23e+0
+12.3:1.23e+1
+123:1.23e+2
+1230:1.23e+3
+12300:1.23e+4
+123000:1.23e+5
+1230000:1.23e+6
+12300000:1.23e+7
+123000000:1.23e+8
+1230000000:1.23e+9
+12300000000:1.23e+10
+123000000000:1.23e+11
+1230000000000:1.23e+12
+
+0.000000000001234:1.234e-12
+0.00000000001234:1.234e-11
+0.0000000001234:1.234e-10
+0.000000001234:1.234e-9
+0.00000001234:1.234e-8
+0.0000001234:1.234e-7
+0.000001234:1.234e-6
+0.00001234:1.234e-5
+0.0001234:1.234e-4
+0.001234:1.234e-3
+0.01234:1.234e-2
+0.1234:1.234e-1
+1.234:1.234e+0
+12.34:1.234e+1
+123.4:1.234e+2
+1234:1.234e+3
+12340:1.234e+4
+123400:1.234e+5
+1234000:1.234e+6
+12340000:1.234e+7
+123400000:1.234e+8
+1234000000:1.234e+9
+12340000000:1.234e+10
+123400000000:1.234e+11
+1234000000000:1.234e+12
+
+0.000003141592:3.141592e-6
+0.00003141592:3.141592e-5
+0.0003141592:3.141592e-4
+0.003141592:3.141592e-3
+0.03141592:3.141592e-2
+0.3141592:3.141592e-1
+3.141592:3.141592e+0
+31.41592:3.141592e+1
+314.1592:3.141592e+2
+3141.592:3.141592e+3
+31415.92:3.141592e+4
+314159.2:3.141592e+5
+3141592:3.141592e+6
+
+# negative numbers
+
+-0.000000000001:-1e-12
+-0.00000000001:-1e-11
+-0.0000000001:-1e-10
+-0.000000001:-1e-9
+-0.00000001:-1e-8
+-0.0000001:-1e-7
+-0.000001:-1e-6
+-0.00001:-1e-5
+-0.0001:-1e-4
+-0.001:-1e-3
+-0.01:-1e-2
+-0.1:-1e-1
+-1:-1e+0
+-10:-1e+1
+-100:-1e+2
+-1000:-1e+3
+-10000:-1e+4
+-100000:-1e+5
+-1000000:-1e+6
+-10000000:-1e+7
+-100000000:-1e+8
+-1000000000:-1e+9
+-10000000000:-1e+10
+-100000000000:-1e+11
+-1000000000000:-1e+12
+
+-0.0000000000012:-1.2e-12
+-0.000000000012:-1.2e-11
+-0.00000000012:-1.2e-10
+-0.0000000012:-1.2e-9
+-0.000000012:-1.2e-8
+-0.00000012:-1.2e-7
+-0.0000012:-1.2e-6
+-0.000012:-1.2e-5
+-0.00012:-1.2e-4
+-0.0012:-1.2e-3
+-0.012:-1.2e-2
+-0.12:-1.2e-1
+-1.2:-1.2e+0
+-12:-1.2e+1
+-120:-1.2e+2
+-1200:-1.2e+3
+-12000:-1.2e+4
+-120000:-1.2e+5
+-1200000:-1.2e+6
+-12000000:-1.2e+7
+-120000000:-1.2e+8
+-1200000000:-1.2e+9
+-12000000000:-1.2e+10
+-120000000000:-1.2e+11
+-1200000000000:-1.2e+12
+
+-0.00000000000123:-1.23e-12
+-0.0000000000123:-1.23e-11
+-0.000000000123:-1.23e-10
+-0.00000000123:-1.23e-9
+-0.0000000123:-1.23e-8
+-0.000000123:-1.23e-7
+-0.00000123:-1.23e-6
+-0.0000123:-1.23e-5
+-0.000123:-1.23e-4
+-0.00123:-1.23e-3
+-0.0123:-1.23e-2
+-0.123:-1.23e-1
+-1.23:-1.23e+0
+-12.3:-1.23e+1
+-123:-1.23e+2
+-1230:-1.23e+3
+-12300:-1.23e+4
+-123000:-1.23e+5
+-1230000:-1.23e+6
+-12300000:-1.23e+7
+-123000000:-1.23e+8
+-1230000000:-1.23e+9
+-12300000000:-1.23e+10
+-123000000000:-1.23e+11
+-1230000000000:-1.23e+12
+
+-0.000000000001234:-1.234e-12
+-0.00000000001234:-1.234e-11
+-0.0000000001234:-1.234e-10
+-0.000000001234:-1.234e-9
+-0.00000001234:-1.234e-8
+-0.0000001234:-1.234e-7
+-0.000001234:-1.234e-6
+-0.00001234:-1.234e-5
+-0.0001234:-1.234e-4
+-0.001234:-1.234e-3
+-0.01234:-1.234e-2
+-0.1234:-1.234e-1
+-1.234:-1.234e+0
+-12.34:-1.234e+1
+-123.4:-1.234e+2
+-1234:-1.234e+3
+-12340:-1.234e+4
+-123400:-1.234e+5
+-1234000:-1.234e+6
+-12340000:-1.234e+7
+-123400000:-1.234e+8
+-1234000000:-1.234e+9
+-12340000000:-1.234e+10
+-123400000000:-1.234e+11
+-1234000000000:-1.234e+12
+
+-0.000003141592:-3.141592e-6
+-0.00003141592:-3.141592e-5
+-0.0003141592:-3.141592e-4
+-0.003141592:-3.141592e-3
+-0.03141592:-3.141592e-2
+-0.3141592:-3.141592e-1
+-3.141592:-3.141592e+0
+-31.41592:-3.141592e+1
+-314.1592:-3.141592e+2
+-3141.592:-3.141592e+3
+-31415.92:-3.141592e+4
+-314159.2:-3.141592e+5
+-3141592:-3.141592e+6
diff --git a/cpan/Math-BigInt/t/bnstr-mbi.t b/cpan/Math-BigInt/t/bnstr-mbi.t
new file mode 100644
index 0000000000..361166c6db
--- /dev/null
+++ b/cpan/Math-BigInt/t/bnstr-mbi.t
@@ -0,0 +1,158 @@
+#!perl
+
+use strict;
+use warnings;
+
+use Test::More tests => 220;
+
+use Math::BigInt;
+
+while (<DATA>) {
+    s/#.*$//;                   # remove comments
+    s/\s+$//;                   # remove trailing whitespace
+    next unless length;         # skip empty lines
+
+    my ($x_str, $expected) = split /:/;
+    my ($x, $str);
+
+    {
+        my $test = qq|\$x = Math::BigInt -> new("$x_str");|
+                 . qq| \$str = \$x -> bnstr();|;
+
+        note "\n$test\n\n";
+        eval $test;
+
+        is($str, $expected, qq|input value is "$x_str"|);
+        is($x,   $x_str, "input object is unmodified");
+    }
+
+}
+
+__DATA__
+
+NaN:NaN
+
+inf:inf
+-inf:-inf
+
+0:0e+0
+
+# positive numbers
+
+1:1e+0
+10:1e+1
+100:1e+2
+1000:1e+3
+10000:1e+4
+100000:1e+5
+1000000:1e+6
+10000000:1e+7
+100000000:1e+8
+1000000000:1e+9
+10000000000:1e+10
+100000000000:1e+11
+1000000000000:1e+12
+
+12:1.2e+1
+120:1.2e+2
+1200:1.2e+3
+12000:1.2e+4
+120000:1.2e+5
+1200000:1.2e+6
+12000000:1.2e+7
+120000000:1.2e+8
+1200000000:1.2e+9
+12000000000:1.2e+10
+120000000000:1.2e+11
+1200000000000:1.2e+12
+
+123:1.23e+2
+1230:1.23e+3
+12300:1.23e+4
+123000:1.23e+5
+1230000:1.23e+6
+12300000:1.23e+7
+123000000:1.23e+8
+1230000000:1.23e+9
+12300000000:1.23e+10
+123000000000:1.23e+11
+1230000000000:1.23e+12
+
+1234:1.234e+3
+12340:1.234e+4
+123400:1.234e+5
+1234000:1.234e+6
+12340000:1.234e+7
+123400000:1.234e+8
+1234000000:1.234e+9
+12340000000:1.234e+10
+123400000000:1.234e+11
+1234000000000:1.234e+12
+
+3:3e+0
+31:3.1e+1
+314:3.14e+2
+3141:3.141e+3
+31415:3.1415e+4
+314159:3.14159e+5
+3141592:3.141592e+6
+
+# negative numbers
+
+-1:-1e+0
+-10:-1e+1
+-100:-1e+2
+-1000:-1e+3
+-10000:-1e+4
+-100000:-1e+5
+-1000000:-1e+6
+-10000000:-1e+7
+-100000000:-1e+8
+-1000000000:-1e+9
+-10000000000:-1e+10
+-100000000000:-1e+11
+-1000000000000:-1e+12
+
+-12:-1.2e+1
+-120:-1.2e+2
+-1200:-1.2e+3
+-12000:-1.2e+4
+-120000:-1.2e+5
+-1200000:-1.2e+6
+-12000000:-1.2e+7
+-120000000:-1.2e+8
+-1200000000:-1.2e+9
+-12000000000:-1.2e+10
+-120000000000:-1.2e+11
+-1200000000000:-1.2e+12
+
+-123:-1.23e+2
+-1230:-1.23e+3
+-12300:-1.23e+4
+-123000:-1.23e+5
+-1230000:-1.23e+6
+-12300000:-1.23e+7
+-123000000:-1.23e+8
+-1230000000:-1.23e+9
+-12300000000:-1.23e+10
+-123000000000:-1.23e+11
+-1230000000000:-1.23e+12
+
+-1234:-1.234e+3
+-12340:-1.234e+4
+-123400:-1.234e+5
+-1234000:-1.234e+6
+-12340000:-1.234e+7
+-123400000:-1.234e+8
+-1234000000:-1.234e+9
+-12340000000:-1.234e+10
+-123400000000:-1.234e+11
+-1234000000000:-1.234e+12
+
+-3:-3e+0
+-31:-3.1e+1
+-314:-3.14e+2
+-3141:-3.141e+3
+-31415:-3.1415e+4
+-314159:-3.14159e+5
+-3141592:-3.141592e+6
diff --git a/cpan/Math-BigInt/t/bsstr-mbf.t b/cpan/Math-BigInt/t/bsstr-mbf.t
new file mode 100644
index 0000000000..89faab1784
--- /dev/null
+++ b/cpan/Math-BigInt/t/bsstr-mbf.t
@@ -0,0 +1,275 @@
+#!perl
+
+use strict;
+use warnings;
+
+use Test::More tests => 460;
+
+use Math::BigFloat;
+
+while (<DATA>) {
+    s/#.*$//;                   # remove comments
+    s/\s+$//;                   # remove trailing whitespace
+    next unless length;         # skip empty lines
+
+    my ($x_str, $expected) = split /:/;
+    my ($x, $str);
+
+        my $test = qq|\$x = Math::BigFloat -> new("$x_str");|
+                 . qq| \$str = \$x -> bsstr();|;
+
+        note "\n$test\n\n";
+        eval $test;
+
+        is($str, $expected, qq|input value is "$x_str"|);
+        is($x,   $x_str, "input object is unmodified");
+}
+
+__DATA__
+
+NaN:NaN
+
+inf:inf
+-inf:-inf
+
+0:0e+0
+
+# positive numbers
+
+0.000000000001:1e-12
+0.00000000001:1e-11
+0.0000000001:1e-10
+0.000000001:1e-9
+0.00000001:1e-8
+0.0000001:1e-7
+0.000001:1e-6
+0.00001:1e-5
+0.0001:1e-4
+0.001:1e-3
+0.01:1e-2
+0.1:1e-1
+1:1e+0
+10:1e+1
+100:1e+2
+1000:1e+3
+10000:1e+4
+100000:1e+5
+1000000:1e+6
+10000000:1e+7
+100000000:1e+8
+1000000000:1e+9
+10000000000:1e+10
+100000000000:1e+11
+1000000000000:1e+12
+
+0.0000000000012:12e-13
+0.000000000012:12e-12
+0.00000000012:12e-11
+0.0000000012:12e-10
+0.000000012:12e-9
+0.00000012:12e-8
+0.0000012:12e-7
+0.000012:12e-6
+0.00012:12e-5
+0.0012:12e-4
+0.012:12e-3
+0.12:12e-2
+1.2:12e-1
+12:12e+0
+120:12e+1
+1200:12e+2
+12000:12e+3
+120000:12e+4
+1200000:12e+5
+12000000:12e+6
+120000000:12e+7
+1200000000:12e+8
+12000000000:12e+9
+120000000000:12e+10
+1200000000000:12e+11
+
+0.00000000000123:123e-14
+0.0000000000123:123e-13
+0.000000000123:123e-12
+0.00000000123:123e-11
+0.0000000123:123e-10
+0.000000123:123e-9
+0.00000123:123e-8
+0.0000123:123e-7
+0.000123:123e-6
+0.00123:123e-5
+0.0123:123e-4
+0.123:123e-3
+1.23:123e-2
+12.3:123e-1
+123:123e+0
+1230:123e+1
+12300:123e+2
+123000:123e+3
+1230000:123e+4
+12300000:123e+5
+123000000:123e+6
+1230000000:123e+7
+12300000000:123e+8
+123000000000:123e+9
+1230000000000:123e+10
+
+0.000000000001234:1234e-15
+0.00000000001234:1234e-14
+0.0000000001234:1234e-13
+0.000000001234:1234e-12
+0.00000001234:1234e-11
+0.0000001234:1234e-10
+0.000001234:1234e-9
+0.00001234:1234e-8
+0.0001234:1234e-7
+0.001234:1234e-6
+0.01234:1234e-5
+0.1234:1234e-4
+1.234:1234e-3
+12.34:1234e-2
+123.4:1234e-1
+1234:1234e+0
+12340:1234e+1
+123400:1234e+2
+1234000:1234e+3
+12340000:1234e+4
+123400000:1234e+5
+1234000000:1234e+6
+12340000000:1234e+7
+123400000000:1234e+8
+1234000000000:1234e+9
+
+0.000003141592:3141592e-12
+0.00003141592:3141592e-11
+0.0003141592:3141592e-10
+0.003141592:3141592e-9
+0.03141592:3141592e-8
+0.3141592:3141592e-7
+3.141592:3141592e-6
+31.41592:3141592e-5
+314.1592:3141592e-4
+3141.592:3141592e-3
+31415.92:3141592e-2
+314159.2:3141592e-1
+3141592:3141592e+0
+
+# negative numbers
+
+-0.000000000001:-1e-12
+-0.00000000001:-1e-11
+-0.0000000001:-1e-10
+-0.000000001:-1e-9
+-0.00000001:-1e-8
+-0.0000001:-1e-7
+-0.000001:-1e-6
+-0.00001:-1e-5
+-0.0001:-1e-4
+-0.001:-1e-3
+-0.01:-1e-2
+-0.1:-1e-1
+-1:-1e+0
+-10:-1e+1
+-100:-1e+2
+-1000:-1e+3
+-10000:-1e+4
+-100000:-1e+5
+-1000000:-1e+6
+-10000000:-1e+7
+-100000000:-1e+8
+-1000000000:-1e+9
+-10000000000:-1e+10
+-100000000000:-1e+11
+-1000000000000:-1e+12
+
+-0.0000000000012:-12e-13
+-0.000000000012:-12e-12
+-0.00000000012:-12e-11
+-0.0000000012:-12e-10
+-0.000000012:-12e-9
+-0.00000012:-12e-8
+-0.0000012:-12e-7
+-0.000012:-12e-6
+-0.00012:-12e-5
+-0.0012:-12e-4
+-0.012:-12e-3
+-0.12:-12e-2
+-1.2:-12e-1
+-12:-12e+0
+-120:-12e+1
+-1200:-12e+2
+-12000:-12e+3
+-120000:-12e+4
+-1200000:-12e+5
+-12000000:-12e+6
+-120000000:-12e+7
+-1200000000:-12e+8
+-12000000000:-12e+9
+-120000000000:-12e+10
+-1200000000000:-12e+11
+
+-0.00000000000123:-123e-14
+-0.0000000000123:-123e-13
+-0.000000000123:-123e-12
+-0.00000000123:-123e-11
+-0.0000000123:-123e-10
+-0.000000123:-123e-9
+-0.00000123:-123e-8
+-0.0000123:-123e-7
+-0.000123:-123e-6
+-0.00123:-123e-5
+-0.0123:-123e-4
+-0.123:-123e-3
+-1.23:-123e-2
+-12.3:-123e-1
+-123:-123e+0
+-1230:-123e+1
+-12300:-123e+2
+-123000:-123e+3
+-1230000:-123e+4
+-12300000:-123e+5
+-123000000:-123e+6
+-1230000000:-123e+7
+-12300000000:-123e+8
+-123000000000:-123e+9
+-1230000000000:-123e+10
+
+-0.000000000001234:-1234e-15
+-0.00000000001234:-1234e-14
+-0.0000000001234:-1234e-13
+-0.000000001234:-1234e-12
+-0.00000001234:-1234e-11
+-0.0000001234:-1234e-10
+-0.000001234:-1234e-9
+-0.00001234:-1234e-8
+-0.0001234:-1234e-7
+-0.001234:-1234e-6
+-0.01234:-1234e-5
+-0.1234:-1234e-4
+-1.234:-1234e-3
+-12.34:-1234e-2
+-123.4:-1234e-1
+-1234:-1234e+0
+-12340:-1234e+1
+-123400:-1234e+2
+-1234000:-1234e+3
+-12340000:-1234e+4
+-123400000:-1234e+5
+-1234000000:-1234e+6
+-12340000000:-1234e+7
+-123400000000:-1234e+8
+-1234000000000:-1234e+9
+
+-0.000003141592:-3141592e-12
+-0.00003141592:-3141592e-11
+-0.0003141592:-3141592e-10
+-0.003141592:-3141592e-9
+-0.03141592:-3141592e-8
+-0.3141592:-3141592e-7
+-3.141592:-3141592e-6
+-31.41592:-3141592e-5
+-314.1592:-3141592e-4
+-3141.592:-3141592e-3
+-31415.92:-3141592e-2
+-314159.2:-3141592e-1
+-3141592:-3141592e+0
diff --git a/cpan/Math-BigInt/t/bsstr-mbi.t b/cpan/Math-BigInt/t/bsstr-mbi.t
new file mode 100644
index 0000000000..1422522d06
--- /dev/null
+++ b/cpan/Math-BigInt/t/bsstr-mbi.t
@@ -0,0 +1,158 @@
+#!perl
+
+use strict;
+use warnings;
+
+use Test::More tests => 220;
+
+use Math::BigInt;
+
+while (<DATA>) {
+    s/#.*$//;                   # remove comments
+    s/\s+$//;                   # remove trailing whitespace
+    next unless length;         # skip empty lines
+
+    my ($x_str, $expected) = split /:/;
+    my ($x, $str);
+
+    {
+        my $test = qq|\$x = Math::BigInt -> new("$x_str");|
+                 . qq| \$str = \$x -> bsstr();|;
+
+        note "\n$test\n\n";
+        eval $test;
+
+        is($str, $expected, qq|input value is "$x_str"|);
+        is($x,   $x_str, "input object is unmodified");
+    }
+
+}
+
+__DATA__
+
+NaN:NaN
+
+inf:inf
+-inf:-inf
+
+0:0e+0
+
+# positive numbers
+
+1:1e+0
+10:1e+1
+100:1e+2
+1000:1e+3
+10000:1e+4
+100000:1e+5
+1000000:1e+6
+10000000:1e+7
+100000000:1e+8
+1000000000:1e+9
+10000000000:1e+10
+100000000000:1e+11
+1000000000000:1e+12
+
+12:12e+0
+120:12e+1
+1200:12e+2
+12000:12e+3
+120000:12e+4
+1200000:12e+5
+12000000:12e+6
+120000000:12e+7
+1200000000:12e+8
+12000000000:12e+9
+120000000000:12e+10
+1200000000000:12e+11
+
+123:123e+0
+1230:123e+1
+12300:123e+2
+123000:123e+3
+1230000:123e+4
+12300000:123e+5
+123000000:123e+6
+1230000000:123e+7
+12300000000:123e+8
+123000000000:123e+9
+1230000000000:123e+10
+
+1234:1234e+0
+12340:1234e+1
+123400:1234e+2
+1234000:1234e+3
+12340000:1234e+4
+123400000:1234e+5
+1234000000:1234e+6
+12340000000:1234e+7
+123400000000:1234e+8
+1234000000000:1234e+9
+
+3:3e+0
+31:31e+0
+314:314e+0
+3141:3141e+0
+31415:31415e+0
+314159:314159e+0
+3141592:3141592e+0
+
+# negative numbers
+
+-1:-1e+0
+-10:-1e+1
+-100:-1e+2
+-1000:-1e+3
+-10000:-1e+4
+-100000:-1e+5
+-1000000:-1e+6
+-10000000:-1e+7
+-100000000:-1e+8
+-1000000000:-1e+9
+-10000000000:-1e+10
+-100000000000:-1e+11
+-1000000000000:-1e+12
+
+-12:-12e+0
+-120:-12e+1
+-1200:-12e+2
+-12000:-12e+3
+-120000:-12e+4
+-1200000:-12e+5
+-12000000:-12e+6
+-120000000:-12e+7
+-1200000000:-12e+8
+-12000000000:-12e+9
+-120000000000:-12e+10
+-1200000000000:-12e+11
+
+-123:-123e+0
+-1230:-123e+1
+-12300:-123e+2
+-123000:-123e+3
+-1230000:-123e+4
+-12300000:-123e+5
+-123000000:-123e+6
+-1230000000:-123e+7
+-12300000000:-123e+8
+-123000000000:-123e+9
+-1230000000000:-123e+10
+
+-1234:-1234e+0
+-12340:-1234e+1
+-123400:-1234e+2
+-1234000:-1234e+3
+-12340000:-1234e+4
+-123400000:-1234e+5
+-1234000000:-1234e+6
+-12340000000:-1234e+7
+-123400000000:-1234e+8
+-1234000000000:-1234e+9
+
+-3:-3e+0
+-31:-31e+0
+-314:-314e+0
+-3141:-3141e+0
+-31415:-31415e+0
+-314159:-314159e+0
+-3141592:-3141592e+0
diff --git a/cpan/Math-BigInt/t/calling-class-methods.t b/cpan/Math-BigInt/t/calling-class-methods.t
new file mode 100644
index 0000000000..1bc0f6a266
--- /dev/null
+++ b/cpan/Math-BigInt/t/calling-class-methods.t
@@ -0,0 +1,119 @@
+#!perl
+
+# test calling conventions, and :constant overloading
+
+use strict;
+use warnings;
+
+use Test::More tests => 148;
+
+##############################################################################
+
+package Math::BigInt::Test;
+
+use Math::BigInt;
+our @ISA = qw/Math::BigInt/;            # subclass of MBI
+use overload;
+
+##############################################################################
+
+package Math::BigFloat::Test;
+
+use Math::BigFloat;
+our @ISA = qw/Math::BigFloat/;          # subclass of MBI
+use overload;
+
+##############################################################################
+
+package main;
+
+use Math::BigInt try => 'Calc';
+use Math::BigFloat;
+
+my ($x, $y, $z, $u);
+
+###############################################################################
+# check whether op's accept normal strings, even when inherited by subclasses
+
+# do one positive and one negative test to avoid false positives by "accident"
+
+my ($method, $expected);
+while (<DATA>) {
+    s/#.*$//;                   # remove comments
+    s/\s+$//;                   # remove trailing whitespace
+    next unless length;         # skip empty lines
+
+    if (s/^&//) {
+        $method = $_;
+        next;
+    }
+
+    my @args = split /:/, $_, 99;
+    $expected = pop @args;
+    foreach my $class (qw/
+                             Math::BigInt Math::BigFloat
+                             Math::BigInt::Test Math::BigFloat::Test
+                         /)
+    {
+        my $arg = $args[0] =~ /"/ || $args[0] eq "" ? $args[0]
+                                                    : qq|"$args[0]"|;
+        my $try = "$class -> $method($arg);";
+        my $got = eval $try;
+        is($got, $expected, $try);
+    }
+}
+
+__END__
+&is_zero
+1:0
+0:1
+&is_one
+1:1
+0:0
+&is_positive
+1:1
+-1:0
+&is_negative
+1:0
+-1:1
+&is_nan
+abc:1
+1:0
+&is_inf
+inf:1
+0:0
+&bstr
+5:5
+10:10
+-10:-10
+abc:NaN
+"+inf":inf
+"-inf":-inf
+&bsstr
+1:1e+0
+0:0e+0
+2:2e+0
+200:2e+2
+-5:-5e+0
+-100:-1e+2
+abc:NaN
+"+inf":inf
+&babs
+-1:1
+1:1
+#&bnot
+#-2:1
+#1:-2
+&bzero
+:0
+&bnan
+:NaN
+abc:NaN
+&bone
+:1
+"+":1
+"-":-1
+&binf
+:inf
+"+":inf
+"-":-inf
diff --git a/cpan/Math-BigInt/t/calling-instance-methods.t b/cpan/Math-BigInt/t/calling-instance-methods.t
new file mode 100644
index 0000000000..8b0945e72a
--- /dev/null
+++ b/cpan/Math-BigInt/t/calling-instance-methods.t
@@ -0,0 +1,119 @@
+#!perl
+
+# test calling conventions, and :constant overloading
+
+use strict;
+use warnings;
+
+use Test::More tests => 140;
+
+##############################################################################
+
+package Math::BigInt::Test;
+
+use Math::BigInt;
+our @ISA = qw/Math::BigInt/;            # subclass of MBI
+use overload;
+
+##############################################################################
+
+package Math::BigFloat::Test;
+
+use Math::BigFloat;
+our @ISA = qw/Math::BigFloat/;          # subclass of MBI
+use overload;
+
+##############################################################################
+
+package main;
+
+use Math::BigInt try => 'Calc';
+use Math::BigFloat;
+
+my ($x, $y, $z, $u);
+
+###############################################################################
+# check whether op's accept normal strings, even when inherited by subclasses
+
+# do one positive and one negative test to avoid false positives by "accident"
+
+my ($method, $expected);
+while (<DATA>) {
+    s/#.*$//;                   # remove comments
+    s/\s+$//;                   # remove trailing whitespace
+    next unless length;         # skip empty lines
+
+    if (s/^&//) {
+        $method = $_;
+        next;
+    }
+
+    my @args = split /:/, $_, 99;
+    $expected = pop @args;
+    foreach my $class (qw/
+                             Math::BigInt Math::BigFloat
+                             Math::BigInt::Test Math::BigFloat::Test
+                         /)
+    {
+        my $arg = $args[0] =~ /"/ || $args[0] eq "" ? $args[0]
+                                                    : qq|"$args[0]"|;
+        my $try = "$class -> new($arg) -> $method();";
+        my $got = eval $try;
+        is($got, $expected, $try);
+    }
+}
+
+__END__
+&is_zero
+1:0
+0:1
+&is_one
+1:1
+0:0
+&is_positive
+1:1
+-1:0
+&is_negative
+1:0
+-1:1
+&is_nan
+abc:1
+1:0
+&is_inf
+inf:1
+0:0
+&bstr
+5:5
+10:10
+-10:-10
+abc:NaN
+"+inf":inf
+"-inf":-inf
+&bsstr
+1:1e+0
+0:0e+0
+2:2e+0
+200:2e+2
+-5:-5e+0
+-100:-1e+2
+abc:NaN
+"+inf":inf
+&babs
+-1:1
+1:1
+&bnot
+-2:1
+1:-2
+&bzero
+:0
+&bnan
+:NaN
+abc:NaN
+&bone
+:1
+#"+":1
+#"-":-1
+&binf
+:inf
+#"+":inf
+#"-":-inf
diff --git a/cpan/Math-BigInt/t/calling.t b/cpan/Math-BigInt/t/calling.t
index fb51e2b0d7..d19d6371e6 100644
--- a/cpan/Math-BigInt/t/calling.t
+++ b/cpan/Math-BigInt/t/calling.t
@@ -6,10 +6,10 @@ use strict;
 use warnings;
 use lib 't';
 
-my $VERSION = '1.999715';       # adjust manually to match latest release
+my $VERSION = '1.999724';       # adjust manually to match latest release
 $VERSION = eval $VERSION;
 
-use Test::More tests => 161;
+use Test::More tests => 5;
 
 ##############################################################################
 
@@ -34,43 +34,10 @@ package main;
 use Math::BigInt try => 'Calc';
 use Math::BigFloat;
 
-my ($x, $y, $z, $u);
-
-###############################################################################
-# check whether op's accept normal strings, even when inherited by subclasses
-
-# do one positive and one negative test to avoid false positives by "accident"
-
-my ($method, $expected);
-while (<DATA>) {
-    s/#.*$//;                   # remove comments
-    s/\s+$//;                   # remove trailing whitespace
-    next unless length;         # skip empty lines
-
-    if (s/^&//) {
-        $method = $_;
-        next;
-    }
-
-    my @args = split /:/, $_, 99;
-    $expected = pop @args;
-    foreach my $class (qw/
-                             Math::BigInt Math::BigFloat
-                             Math::BigInt::Test Math::BigFloat::Test
-                         /)
-    {
-        my $arg = $args[0] =~ /"/ || $args[0] eq "" ? $args[0]
-                                                    : qq|"$args[0]"|;
-        my $try = "$class\->$method($arg);";
-        my $got = eval $try;
-        is($got, $expected, $try);
-    }
-}
+my ($x, $expected, $try);
 
 my $class = 'Math::BigInt';
 
-my $try;
-
 # test whether use Math::BigInt qw/VERSION/ works
 $try = "use $class (" . ($VERSION . '1') .");";
 $try .= ' $x = $class->new(123); $x = "$x";';
@@ -102,60 +69,3 @@ $try = qq|use $class ($VERSION, "lib", "$class\::Scalar");|
      . q| $x = 2**10; $x = "$x";|;
 $expected = eval $try;
 is($expected, "1024", $try);
-
-# all done
-
-__END__
-&is_zero
-1:0
-0:1
-&is_one
-1:1
-0:0
-&is_positive
-1:1
--1:0
-&is_negative
-1:0
--1:1
-&is_nan
-abc:1
-1:0
-&is_inf
-inf:1
-0:0
-&bstr
-5:5
-10:10
--10:-10
-abc:NaN
-"+inf":inf
-"-inf":-inf
-&bsstr
-1:1e+0
-0:0e+0
-2:2e+0
-200:2e+2
--5:-5e+0
--100:-1e+2
-abc:NaN
-"+inf":inf
-&babs
--1:1
-1:1
-&bnot
--2:1
-1:-2
-&bzero
-:0
-&bnan
-:NaN
-abc:NaN
-&bone
-:1
-"+":1
-"-":-1
-&binf
-:inf
-"+":inf
-"-":-inf
diff --git a/cpan/Math-BigInt/t/dparts-mbf.t b/cpan/Math-BigInt/t/dparts-mbf.t
new file mode 100644
index 0000000000..90a29dd753
--- /dev/null
+++ b/cpan/Math-BigInt/t/dparts-mbf.t
@@ -0,0 +1,294 @@
+#!perl
+
+use strict;
+use warnings;
+
+use Test::More tests => 1840;
+
+use Math::BigFloat;
+
+while (<DATA>) {
+    s/#.*$//;                   # remove comments
+    s/\s+$//;                   # remove trailing whitespace
+    next unless length;         # skip empty lines
+
+    my ($x_str, $int_str, $frc_str) = split /:/;
+
+    note(qq|\n\$x = Math::BigFloat -> new("$x_str");|,
+         qq| (\$i, \$f) = \$x -> dparts();\n\n|);
+
+    {
+        my $x = Math::BigFloat -> new($x_str);
+        my ($int_got, $frc_got) = $x -> dparts();
+
+        isa_ok($int_got, "Math::BigFloat");
+        isa_ok($frc_got, "Math::BigFloat");
+
+        is($int_got, $int_str, "value of integer part");
+        is($frc_got, $frc_str, "value of fraction part");
+        is($x,       $x_str,   "input is unmodified");
+    }
+
+    note(qq|\n\$x = Math::BigFloat -> new("$x_str");|,
+         qq| \$i = \$x -> dparts();\n\n|);
+
+    {
+        my $x = Math::BigFloat -> new($x_str);
+        my $int_got = $x -> dparts();
+
+        isa_ok($int_got, "Math::BigFloat");
+
+        is($int_got, $int_str, "value of integer part");
+        is($x,       $x_str,   "input is unmodified");
+    }
+
+}
+
+__DATA__
+
+NaN:NaN:0
+
+inf:inf:0
+-inf:-inf:0
+
+0:0:0
+
+# positive numbers
+
+0.000000000001:0:0.000000000001
+0.00000000001:0:0.00000000001
+0.0000000001:0:0.0000000001
+0.000000001:0:0.000000001
+0.00000001:0:0.00000001
+0.0000001:0:0.0000001
+0.000001:0:0.000001
+0.00001:0:0.00001
+0.0001:0:0.0001
+0.001:0:0.001
+0.01:0:0.01
+0.1:0:0.1
+1:1:0
+10:10:0
+100:100:0
+1000:1000:0
+10000:10000:0
+100000:100000:0
+1000000:1000000:0
+10000000:10000000:0
+100000000:100000000:0
+1000000000:1000000000:0
+10000000000:10000000000:0
+100000000000:100000000000:0
+1000000000000:1000000000000:0
+
+0.0000000000012:0:0.0000000000012
+0.000000000012:0:0.000000000012
+0.00000000012:0:0.00000000012
+0.0000000012:0:0.0000000012
+0.000000012:0:0.000000012
+0.00000012:0:0.00000012
+0.0000012:0:0.0000012
+0.000012:0:0.000012
+0.00012:0:0.00012
+0.0012:0:0.0012
+0.012:0:0.012
+0.12:0:0.12
+1.2:1:0.2
+12:12:0
+120:120:0
+1200:1200:0
+12000:12000:0
+120000:120000:0
+1200000:1200000:0
+12000000:12000000:0
+120000000:120000000:0
+1200000000:1200000000:0
+12000000000:12000000000:0
+120000000000:120000000000:0
+1200000000000:1200000000000:0
+
+0.00000000000123:0:0.00000000000123
+0.0000000000123:0:0.0000000000123
+0.000000000123:0:0.000000000123
+0.00000000123:0:0.00000000123
+0.0000000123:0:0.0000000123
+0.000000123:0:0.000000123
+0.00000123:0:0.00000123
+0.0000123:0:0.0000123
+0.000123:0:0.000123
+0.00123:0:0.00123
+0.0123:0:0.0123
+0.123:0:0.123
+1.23:1:0.23
+12.3:12:0.3
+123:123:0
+1230:1230:0
+12300:12300:0
+123000:123000:0
+1230000:1230000:0
+12300000:12300000:0
+123000000:123000000:0
+1230000000:1230000000:0
+12300000000:12300000000:0
+123000000000:123000000000:0
+1230000000000:1230000000000:0
+
+0.000000000001234:0:0.000000000001234
+0.00000000001234:0:0.00000000001234
+0.0000000001234:0:0.0000000001234
+0.000000001234:0:0.000000001234
+0.00000001234:0:0.00000001234
+0.0000001234:0:0.0000001234
+0.000001234:0:0.000001234
+0.00001234:0:0.00001234
+0.0001234:0:0.0001234
+0.001234:0:0.001234
+0.01234:0:0.01234
+0.1234:0:0.1234
+1.234:1:0.234
+12.34:12:0.34
+123.4:123:0.4
+1234:1234:0
+12340:12340:0
+123400:123400:0
+1234000:1234000:0
+12340000:12340000:0
+123400000:123400000:0
+1234000000:1234000000:0
+12340000000:12340000000:0
+123400000000:123400000000:0
+1234000000000:1234000000000:0
+
+0.000003141592:0:0.000003141592
+0.00003141592:0:0.00003141592
+0.0003141592:0:0.0003141592
+0.003141592:0:0.003141592
+0.03141592:0:0.03141592
+0.3141592:0:0.3141592
+3.141592:3:0.141592
+31.41592:31:0.41592
+314.1592:314:0.1592
+3141.592:3141:0.592
+31415.92:31415:0.92
+314159.2:314159:0.2
+3141592:3141592:0
+
+# negative numbers
+
+-0.000000000001:0:-0.000000000001
+-0.00000000001:0:-0.00000000001
+-0.0000000001:0:-0.0000000001
+-0.000000001:0:-0.000000001
+-0.00000001:0:-0.00000001
+-0.0000001:0:-0.0000001
+-0.000001:0:-0.000001
+-0.00001:0:-0.00001
+-0.0001:0:-0.0001
+-0.001:0:-0.001
+-0.01:0:-0.01
+-0.1:0:-0.1
+-1:-1:0
+-10:-10:0
+-100:-100:0
+-1000:-1000:0
+-10000:-10000:0
+-100000:-100000:0
+-1000000:-1000000:0
+-10000000:-10000000:0
+-100000000:-100000000:0
+-1000000000:-1000000000:0
+-10000000000:-10000000000:0
+-100000000000:-100000000000:0
+-1000000000000:-1000000000000:0
+
+-0.0000000000012:0:-0.0000000000012
+-0.000000000012:0:-0.000000000012
+-0.00000000012:0:-0.00000000012
+-0.0000000012:0:-0.0000000012
+-0.000000012:0:-0.000000012
+-0.00000012:0:-0.00000012
+-0.0000012:0:-0.0000012
+-0.000012:0:-0.000012
+-0.00012:0:-0.00012
+-0.0012:0:-0.0012
+-0.012:0:-0.012
+-0.12:0:-0.12
+-1.2:-1:-0.2
+-12:-12:0
+-120:-120:0
+-1200:-1200:0
+-12000:-12000:0
+-120000:-120000:0
+-1200000:-1200000:0
+-12000000:-12000000:0
+-120000000:-120000000:0
+-1200000000:-1200000000:0
+-12000000000:-12000000000:0
+-120000000000:-120000000000:0
+-1200000000000:-1200000000000:0
+
+-0.00000000000123:0:-0.00000000000123
+-0.0000000000123:0:-0.0000000000123
+-0.000000000123:0:-0.000000000123
+-0.00000000123:0:-0.00000000123
+-0.0000000123:0:-0.0000000123
+-0.000000123:0:-0.000000123
+-0.00000123:0:-0.00000123
+-0.0000123:0:-0.0000123
+-0.000123:0:-0.000123
+-0.00123:0:-0.00123
+-0.0123:0:-0.0123
+-0.123:0:-0.123
+-1.23:-1:-0.23
+-12.3:-12:-0.3
+-123:-123:0
+-1230:-1230:0
+-12300:-12300:0
+-123000:-123000:0
+-1230000:-1230000:0
+-12300000:-12300000:0
+-123000000:-123000000:0
+-1230000000:-1230000000:0
+-12300000000:-12300000000:0
+-123000000000:-123000000000:0
+-1230000000000:-1230000000000:0
+
+-0.000000000001234:0:-0.000000000001234
+-0.00000000001234:0:-0.00000000001234
+-0.0000000001234:0:-0.0000000001234
+-0.000000001234:0:-0.000000001234
+-0.00000001234:0:-0.00000001234
+-0.0000001234:0:-0.0000001234
+-0.000001234:0:-0.000001234
+-0.00001234:0:-0.00001234
+-0.0001234:0:-0.0001234
+-0.001234:0:-0.001234
+-0.01234:0:-0.01234
+-0.1234:0:-0.1234
+-1.234:-1:-0.234
+-12.34:-12:-0.34
+-123.4:-123:-0.4
+-1234:-1234:0
+-12340:-12340:0
+-123400:-123400:0
+-1234000:-1234000:0
+-12340000:-12340000:0
+-123400000:-123400000:0
+-1234000000:-1234000000:0
+-12340000000:-12340000000:0
+-123400000000:-123400000000:0
+-1234000000000:-1234000000000:0
+
+-0.000003141592:0:-0.000003141592
+-0.00003141592:0:-0.00003141592
+-0.0003141592:0:-0.0003141592
+-0.003141592:0:-0.003141592
+-0.03141592:0:-0.03141592
+-0.3141592:0:-0.3141592
+-3.141592:-3:-0.141592
+-31.41592:-31:-0.41592
+-314.1592:-314:-0.1592
+-3141.592:-3141:-0.592
+-31415.92:-31415:-0.92
+-314159.2:-314159:-0.2
+-3141592:-3141592:0
diff --git a/cpan/Math-BigInt/t/dparts-mbi.t b/cpan/Math-BigInt/t/dparts-mbi.t
new file mode 100644
index 0000000000..4488b2e597
--- /dev/null
+++ b/cpan/Math-BigInt/t/dparts-mbi.t
@@ -0,0 +1,162 @@
+#!perl
+
+use strict;
+use warnings;
+
+use Test::More tests => 784;
+
+use Math::BigInt;
+
+while (<DATA>) {
+    s/#.*$//;                   # remove comments
+    s/\s+$//;                   # remove trailing whitespace
+    next unless length;         # skip empty lines
+
+    my ($x_str, $int_str, $frc_str) = split /:/;
+
+    note(qq|\n\$x = Math::BigInt -> new("$x_str");|,
+         qq| (\$i, \$f) = \$x -> dparts();\n\n|);
+
+    {
+        my $x = Math::BigInt -> new($x_str);
+        my ($int_got, $frc_got) = $x -> dparts();
+
+        isa_ok($int_got, "Math::BigInt");
+        isa_ok($frc_got, "Math::BigInt");
+
+        is($int_got, $int_str, "value of integer part");
+        is($frc_got, $frc_str, "value of fraction part");
+        is($x,       $x_str,   "input is unmodified");
+    }
+
+    note(qq|\n\$x = Math::BigInt -> new("$x_str");|,
+         qq| \$i = \$x -> dparts();\n\n|);
+
+    {
+        my $x = Math::BigInt -> new($x_str);
+        my $int_got = $x -> dparts();
+
+        isa_ok($int_got, "Math::BigInt");
+
+        is($int_got, $int_str, "value of integer part");
+        is($x,       $x_str,   "input is unmodified");
+    }
+
+}
+
+__DATA__
+
+NaN:NaN:0
+
+inf:inf:0
+-inf:-inf:0
+
+0:0:0
+
+# positive numbers
+
+1:1:0
+10:10:0
+100:100:0
+1000:1000:0
+10000:10000:0
+100000:100000:0
+1000000:1000000:0
+10000000:10000000:0
+100000000:100000000:0
+1000000000:1000000000:0
+10000000000:10000000000:0
+100000000000:100000000000:0
+1000000000000:1000000000000:0
+
+12:12:0
+120:120:0
+1200:1200:0
+12000:12000:0
+120000:120000:0
+1200000:1200000:0
+12000000:12000000:0
+120000000:120000000:0
+1200000000:1200000000:0
+12000000000:12000000000:0
+120000000000:120000000000:0
+1200000000000:1200000000000:0
+
+123:123:0
+1230:1230:0
+12300:12300:0
+123000:123000:0
+1230000:1230000:0
+12300000:12300000:0
+123000000:123000000:0
+1230000000:1230000000:0
+12300000000:12300000000:0
+123000000000:123000000000:0
+1230000000000:1230000000000:0
+
+1234:1234:0
+12340:12340:0
+123400:123400:0
+1234000:1234000:0
+12340000:12340000:0
+123400000:123400000:0
+1234000000:1234000000:0
+12340000000:12340000000:0
+123400000000:123400000000:0
+1234000000000:1234000000000:0
+
+3141592:3141592:0
+
+# negative numbers
+
+-1:-1:0
+-10:-10:0
+-100:-100:0
+-1000:-1000:0
+-10000:-10000:0
+-100000:-100000:0
+-1000000:-1000000:0
+-10000000:-10000000:0
+-100000000:-100000000:0
+-1000000000:-1000000000:0
+-10000000000:-10000000000:0
+-100000000000:-100000000000:0
+-1000000000000:-1000000000000:0
+
+-12:-12:0
+-120:-120:0
+-1200:-1200:0
+-12000:-12000:0
+-120000:-120000:0
+-1200000:-1200000:0
+-12000000:-12000000:0
+-120000000:-120000000:0
+-1200000000:-1200000000:0
+-12000000000:-12000000000:0
+-120000000000:-120000000000:0
+-1200000000000:-1200000000000:0
+
+-123:-123:0
+-1230:-1230:0
+-12300:-12300:0
+-123000:-123000:0
+-1230000:-1230000:0
+-12300000:-12300000:0
+-123000000:-123000000:0
+-1230000000:-1230000000:0
+-12300000000:-12300000000:0
+-123000000000:-123000000000:0
+-1230000000000:-1230000000000:0
+
+-1234:-1234:0
+-12340:-12340:0
+-123400:-123400:0
+-1234000:-1234000:0
+-12340000:-12340000:0
+-123400000:-123400000:0
+-1234000000:-1234000000:0
+-12340000000:-12340000000:0
+-123400000000:-123400000000:0
+-1234000000000:-1234000000000:0
+
+-3141592:-3141592:0
diff --git a/cpan/Math-BigInt/t/eparts-mbf.t b/cpan/Math-BigInt/t/eparts-mbf.t
new file mode 100644
index 0000000000..0c84ac6662
--- /dev/null
+++ b/cpan/Math-BigInt/t/eparts-mbf.t
@@ -0,0 +1,294 @@
+#!perl
+
+use strict;
+use warnings;
+
+use Test::More tests => 1840;
+
+use Math::BigFloat;
+
+while (<DATA>) {
+    s/#.*$//;                   # remove comments
+    s/\s+$//;                   # remove trailing whitespace
+    next unless length;         # skip empty lines
+
+    my ($x_str, $mant_str, $expo_str) = split /:/;
+
+    note(qq|\n\$x = Math::BigFloat -> new("$x_str");|,
+         qq| (\$m, \$e) = \$x -> eparts();\n\n|);
+
+    {
+        my $x = Math::BigFloat -> new($x_str);
+        my ($mant_got, $expo_got) = $x -> eparts();
+
+        isa_ok($mant_got, "Math::BigFloat");
+        isa_ok($expo_got, "Math::BigFloat");
+
+        is($mant_got, $mant_str, "value of mantissa");
+        is($expo_got, $expo_str, "value of exponent");
+        is($x,        $x_str,    "input is unmodified");
+    }
+
+    note(qq|\n\$x = Math::BigFloat -> new("$x_str");|,
+         qq| \$m = \$x -> eparts();\n\n|);
+
+    {
+        my $x = Math::BigFloat -> new($x_str);
+        my $mant_got = $x -> eparts();
+
+        isa_ok($mant_got, "Math::BigFloat");
+
+        is($mant_got, $mant_str, "value of mantissa");
+        is($x,        $x_str,    "input is unmodified");
+    }
+
+}
+
+__DATA__
+
+NaN:NaN:NaN
+
+inf:inf:inf
+-inf:-inf:inf
+
+0:0:0
+
+# positive numbers
+
+0.000000000001:1:-12
+0.00000000001:10:-12
+0.0000000001:100:-12
+0.000000001:1:-9
+0.00000001:10:-9
+0.0000001:100:-9
+0.000001:1:-6
+0.00001:10:-6
+0.0001:100:-6
+0.001:1:-3
+0.01:10:-3
+0.1:100:-3
+1:1:0
+10:10:0
+100:100:0
+1000:1:3
+10000:10:3
+100000:100:3
+1000000:1:6
+10000000:10:6
+100000000:100:6
+1000000000:1:9
+10000000000:10:9
+100000000000:100:9
+1000000000000:1:12
+
+0.0000000000012:1.2:-12
+0.000000000012:12:-12
+0.00000000012:120:-12
+0.0000000012:1.2:-9
+0.000000012:12:-9
+0.00000012:120:-9
+0.0000012:1.2:-6
+0.000012:12:-6
+0.00012:120:-6
+0.0012:1.2:-3
+0.012:12:-3
+0.12:120:-3
+1.2:1.2:0
+12:12:0
+120:120:0
+1200:1.2:3
+12000:12:3
+120000:120:3
+1200000:1.2:6
+12000000:12:6
+120000000:120:6
+1200000000:1.2:9
+12000000000:12:9
+120000000000:120:9
+1200000000000:1.2:12
+
+0.00000000000123:1.23:-12
+0.0000000000123:12.3:-12
+0.000000000123:123:-12
+0.00000000123:1.23:-9
+0.0000000123:12.3:-9
+0.000000123:123:-9
+0.00000123:1.23:-6
+0.0000123:12.3:-6
+0.000123:123:-6
+0.00123:1.23:-3
+0.0123:12.3:-3
+0.123:123:-3
+1.23:1.23:0
+12.3:12.3:0
+123:123:0
+1230:1.23:3
+12300:12.3:3
+123000:123:3
+1230000:1.23:6
+12300000:12.3:6
+123000000:123:6
+1230000000:1.23:9
+12300000000:12.3:9
+123000000000:123:9
+1230000000000:1.23:12
+
+0.000000000001234:1.234:-12
+0.00000000001234:12.34:-12
+0.0000000001234:123.4:-12
+0.000000001234:1.234:-9
+0.00000001234:12.34:-9
+0.0000001234:123.4:-9
+0.000001234:1.234:-6
+0.00001234:12.34:-6
+0.0001234:123.4:-6
+0.001234:1.234:-3
+0.01234:12.34:-3
+0.1234:123.4:-3
+1.234:1.234:0
+12.34:12.34:0
+123.4:123.4:0
+1234:1.234:3
+12340:12.34:3
+123400:123.4:3
+1234000:1.234:6
+12340000:12.34:6
+123400000:123.4:6
+1234000000:1.234:9
+12340000000:12.34:9
+123400000000:123.4:9
+1234000000000:1.234:12
+
+0.000003141592:3.141592:-6
+0.00003141592:31.41592:-6
+0.0003141592:314.1592:-6
+0.003141592:3.141592:-3
+0.03141592:31.41592:-3
+0.3141592:314.1592:-3
+3.141592:3.141592:0
+31.41592:31.41592:0
+314.1592:314.1592:0
+3141.592:3.141592:3
+31415.92:31.41592:3
+314159.2:314.1592:3
+3141592:3.141592:6
+
+# negativ: numbers
+
+-0.000000000001:-1:-12
+-0.00000000001:-10:-12
+-0.0000000001:-100:-12
+-0.000000001:-1:-9
+-0.00000001:-10:-9
+-0.0000001:-100:-9
+-0.000001:-1:-6
+-0.00001:-10:-6
+-0.0001:-100:-6
+-0.001:-1:-3
+-0.01:-10:-3
+-0.1:-100:-3
+-1:-1:0
+-10:-10:0
+-100:-100:0
+-1000:-1:3
+-10000:-10:3
+-100000:-100:3
+-1000000:-1:6
+-10000000:-10:6
+-100000000:-100:6
+-1000000000:-1:9
+-10000000000:-10:9
+-100000000000:-100:9
+-1000000000000:-1:12
+
+-0.0000000000012:-1.2:-12
+-0.000000000012:-12:-12
+-0.00000000012:-120:-12
+-0.0000000012:-1.2:-9
+-0.000000012:-12:-9
+-0.00000012:-120:-9
+-0.0000012:-1.2:-6
+-0.000012:-12:-6
+-0.00012:-120:-6
+-0.0012:-1.2:-3
+-0.012:-12:-3
+-0.12:-120:-3
+-1.2:-1.2:0
+-12:-12:0
+-120:-120:0
+-1200:-1.2:3
+-12000:-12:3
+-120000:-120:3
+-1200000:-1.2:6
+-12000000:-12:6
+-120000000:-120:6
+-1200000000:-1.2:9
+-12000000000:-12:9
+-120000000000:-120:9
+-1200000000000:-1.2:12
+
+-0.00000000000123:-1.23:-12
+-0.0000000000123:-12.3:-12
+-0.000000000123:-123:-12
+-0.00000000123:-1.23:-9
+-0.0000000123:-12.3:-9
+-0.000000123:-123:-9
+-0.00000123:-1.23:-6
+-0.0000123:-12.3:-6
+-0.000123:-123:-6
+-0.00123:-1.23:-3
+-0.0123:-12.3:-3
+-0.123:-123:-3
+-1.23:-1.23:0
+-12.3:-12.3:0
+-123:-123:0
+-1230:-1.23:3
+-12300:-12.3:3
+-123000:-123:3
+-1230000:-1.23:6
+-12300000:-12.3:6
+-123000000:-123:6
+-1230000000:-1.23:9
+-12300000000:-12.3:9
+-123000000000:-123:9
+-1230000000000:-1.23:12
+
+-0.000000000001234:-1.234:-12
+-0.00000000001234:-12.34:-12
+-0.0000000001234:-123.4:-12
+-0.000000001234:-1.234:-9
+-0.00000001234:-12.34:-9
+-0.0000001234:-123.4:-9
+-0.000001234:-1.234:-6
+-0.00001234:-12.34:-6
+-0.0001234:-123.4:-6
+-0.001234:-1.234:-3
+-0.01234:-12.34:-3
+-0.1234:-123.4:-3
+-1.234:-1.234:0
+-12.34:-12.34:0
+-123.4:-123.4:0
+-1234:-1.234:3
+-12340:-12.34:3
+-123400:-123.4:3
+-1234000:-1.234:6
+-12340000:-12.34:6
+-123400000:-123.4:6
+-1234000000:-1.234:9
+-12340000000:-12.34:9
+-123400000000:-123.4:9
+-1234000000000:-1.234:12
+
+-0.000003141592:-3.141592:-6
+-0.00003141592:-31.41592:-6
+-0.0003141592:-314.1592:-6
+-0.003141592:-3.141592:-3
+-0.03141592:-31.41592:-3
+-0.3141592:-314.1592:-3
+-3.141592:-3.141592:0
+-31.41592:-31.41592:0
+-314.1592:-314.1592:0
+-3141.592:-3.141592:3
+-31415.92:-31.41592:3
+-314159.2:-314.1592:3
+-3141592:-3.141592:6
diff --git a/cpan/Math-BigInt/t/eparts-mbi.t b/cpan/Math-BigInt/t/eparts-mbi.t
new file mode 100644
index 0000000000..5c84e28c2d
--- /dev/null
+++ b/cpan/Math-BigInt/t/eparts-mbi.t
@@ -0,0 +1,162 @@
+#!perl
+
+use strict;
+use warnings;
+
+use Test::More tests => 784;
+
+use Math::BigInt;
+
+while (<DATA>) {
+    s/#.*$//;                   # remove comments
+    s/\s+$//;                   # remove trailing whitespace
+    next unless length;         # skip empty lines
+
+    my ($x_str, $mant_str, $expo_str) = split /:/;
+
+    note(qq|\n\$x = Math::BigInt -> new("$x_str");|,
+         qq| (\$m, \$e) = \$x -> eparts();\n\n|);
+
+    {
+        my $x = Math::BigInt -> new($x_str);
+        my ($mant_got, $expo_got) = $x -> eparts();
+
+        isa_ok($mant_got, "Math::BigInt");
+        isa_ok($expo_got, "Math::BigInt");
+
+        is($mant_got, $mant_str, "value of mantissa");
+        is($expo_got, $expo_str, "value of exponent");
+        is($x,        $x_str,    "input is unmodified");
+    }
+
+    note(qq|\n\$x = Math::BigInt -> new("$x_str");|,
+         qq| \$m = \$x -> eparts();\n\n|);
+
+    {
+        my $x = Math::BigInt -> new($x_str);
+        my $mant_got = $x -> eparts();
+
+        isa_ok($mant_got, "Math::BigInt");
+
+        is($mant_got, $mant_str, "value of mantissa");
+        is($x,        $x_str,    "input is unmodified");
+    }
+
+}
+
+__DATA__
+
+NaN:NaN:NaN
+
+inf:inf:inf
+-inf:-inf:inf
+
+0:0:0
+
+# positive numbers
+
+1:1:0
+10:10:0
+100:100:0
+1000:1:3
+10000:10:3
+100000:100:3
+1000000:1:6
+10000000:10:6
+100000000:100:6
+1000000000:1:9
+10000000000:10:9
+100000000000:100:9
+1000000000000:1:12
+
+12:12:0
+120:120:0
+1200:NaN:3
+12000:12:3
+120000:120:3
+1200000:NaN:6
+12000000:12:6
+120000000:120:6
+1200000000:NaN:9
+12000000000:12:9
+120000000000:120:9
+1200000000000:NaN:12
+
+123:123:0
+1230:NaN:3
+12300:NaN:3
+123000:123:3
+1230000:NaN:6
+12300000:NaN:6
+123000000:123:6
+1230000000:NaN:9
+12300000000:NaN:9
+123000000000:123:9
+1230000000000:NaN:12
+
+1234:NaN:3
+12340:NaN:3
+123400:NaN:3
+1234000:NaN:6
+12340000:NaN:6
+123400000:NaN:6
+1234000000:NaN:9
+12340000000:NaN:9
+123400000000:NaN:9
+1234000000000:NaN:12
+
+3141592:NaN:6
+
+# negativ: numbers
+
+-1:-1:0
+-10:-10:0
+-100:-100:0
+-1000:-1:3
+-10000:-10:3
+-100000:-100:3
+-1000000:-1:6
+-10000000:-10:6
+-100000000:-100:6
+-1000000000:-1:9
+-10000000000:-10:9
+-100000000000:-100:9
+-1000000000000:-1:12
+
+-12:-12:0
+-120:-120:0
+-1200:NaN:3
+-12000:-12:3
+-120000:-120:3
+-1200000:NaN:6
+-12000000:-12:6
+-120000000:-120:6
+-1200000000:NaN:9
+-12000000000:-12:9
+-120000000000:-120:9
+-1200000000000:NaN:12
+
+-123:-123:0
+-1230:NaN:3
+-12300:NaN:3
+-123000:-123:3
+-1230000:NaN:6
+-12300000:NaN:6
+-123000000:-123:6
+-1230000000:NaN:9
+-12300000000:NaN:9
+-123000000000:-123:9
+-1230000000000:NaN:12
+
+-1234:NaN:3
+-12340:NaN:3
+-123400:NaN:3
+-1234000:NaN:6
+-12340000:NaN:6
+-123400000:NaN:6
+-1234000000:NaN:9
+-12340000000:NaN:9
+-123400000000:NaN:9
+-1234000000000:NaN:12
+
+-3141592:NaN:6
diff --git a/cpan/Math-BigInt/t/from_bin-mbf.t b/cpan/Math-BigInt/t/from_bin-mbf.t
new file mode 100644
index 0000000000..a8c7527e8a
--- /dev/null
+++ b/cpan/Math-BigInt/t/from_bin-mbf.t
@@ -0,0 +1,70 @@
+#!perl
+
+use strict;
+use warnings;
+
+use Test::More tests => 27;
+
+my $class;
+
+BEGIN { $class = 'Math::BigFloat'; }
+BEGIN { use_ok($class, '1.999710'); }
+
+while (<DATA>) {
+    s/#.*$//;           # remove comments
+    s/\s+$//;           # remove trailing whitespace
+    next unless length; # skip empty lines
+
+    my ($in0, $out0) = split /:/;
+    my $x;
+
+    my $test = qq|\$x = $class -> from_bin("$in0");|;
+    my $desc = $test;
+
+    eval $test;
+    die $@ if $@;       # this should never happen
+
+    subtest $desc, sub {
+        plan tests => 2,
+
+        # Check output.
+
+        is(ref($x), $class, "output arg is a $class");
+        is($x, $out0, 'output arg has the right value');
+    };
+
+}
+
+__END__
+
+0b1p+0:1
+0b.1p+1:1
+0b.01p+2:1
+0b.001p+3:1
+0b.0001p+4:1
+0b10p-1:1
+0b100p-2:1
+0b1000p-3:1
+
+-0b1p+0:-1
+
+0b0p+0:0
+0b0p+7:0
+0b0p-7:0
+0b0.p+0:0
+0b.0p+0:0
+0b0.0p+0:0
+
+0b1100101011111110:51966
+b1100101011111110:51966
+1100101011111110:51966
+
+0b1.1001p+3:12.5
+0b10010.001101p-1:9.1015625
+-0b.11110001001101010111100110111101111p+31:-2023406814.9375
+0b10.0100011010001010110011110001001101p+34:39093746765
+
+NaN:NaN
++inf:NaN
+-inf:NaN
+0b.p+0:NaN
diff --git a/cpan/Math-BigInt/t/from_hex-mbf.t b/cpan/Math-BigInt/t/from_hex-mbf.t
index a15e4fddb1..b45917acff 100644
--- a/cpan/Math-BigInt/t/from_hex-mbf.t
+++ b/cpan/Math-BigInt/t/from_hex-mbf.t
@@ -36,6 +36,7 @@ while (<DATA>) {
 }
 
 __END__
+
 0x1p+0:1
 0x.8p+1:1
 0x.4p+2:1
diff --git a/cpan/Math-BigInt/t/from_oct-mbf.t b/cpan/Math-BigInt/t/from_oct-mbf.t
new file mode 100644
index 0000000000..7e584549af
--- /dev/null
+++ b/cpan/Math-BigInt/t/from_oct-mbf.t
@@ -0,0 +1,70 @@
+#!perl
+
+use strict;
+use warnings;
+
+use Test::More tests => 27;
+
+my $class;
+
+BEGIN { $class = 'Math::BigFloat'; }
+BEGIN { use_ok($class, '1.999710'); }
+
+while (<DATA>) {
+    s/#.*$//;           # remove comments
+    s/\s+$//;           # remove trailing whitespace
+    next unless length; # skip empty lines
+
+    my ($in0, $out0) = split /:/;
+    my $x;
+
+    my $test = qq|\$x = $class -> from_oct("$in0");|;
+    my $desc = $test;
+
+    eval $test;
+    die $@ if $@;       # this should never happen
+
+    subtest $desc, sub {
+        plan tests => 2,
+
+        # Check output.
+
+        is(ref($x), $class, "output arg is a $class");
+        is($x, $out0, 'output arg has the right value');
+    };
+
+}
+
+__END__
+
+01p+0:1
+0.4p+1:1
+0.2p+2:1
+0.1p+3:1
+0.04p+4:1
+02p-1:1
+04p-2:1
+010p-3:1
+
+-1p+0:-1
+
+0p+0:0
+0p+7:0
+0p-7:0
+0.p+0:0
+.0p+0:0
+0.0p+0:0
+
+145376:51966
+0145376:51966
+00145376:51966
+
+3.1p+2:12.5
+22.15p-1:9.1015625
+-0.361152746757p+32:-2023406814.9375
+44.3212636115p+30:39093746765
+
+NaN:NaN
++inf:NaN
+-inf:NaN
+.p+0:NaN
diff --git a/cpan/Math-BigInt/t/mbimbf.inc b/cpan/Math-BigInt/t/mbimbf.inc
index 0e1a42c4f0..404fbf95db 100644
--- a/cpan/Math-BigInt/t/mbimbf.inc
+++ b/cpan/Math-BigInt/t/mbimbf.inc
@@ -944,114 +944,249 @@ is($params[0], $x, q|$params[0] = $x|);               # self
 
 foreach my $class ($mbi, $mbf) {
     $x = $class->new(2)->bzero();
-    is($x->{_a}, undef, q|$x->{_a} = undef|);
-    is($x->{_p}, undef, q|$x->{_p} = undef|);
+    is($x->{_a}, undef, qq|\$x = $class->new(2)->bzero(); \$x->{_a}|);
+    is($x->{_p}, undef, qq|\$x = $class->new(2)->bzero(); \$x->{_p}|);
 
     $x = $class->new(2)->bone();
-    is($x->{_a}, undef, q|$x->{_a} = undef|);
-    is($x->{_p}, undef, q|$x->{_p} = undef|);
+    is($x->{_a}, undef, qq|\$x = $class->new(2)->bone(); \$x->{_a}|);
+    is($x->{_p}, undef, qq|\$x = $class->new(2)->bone(); \$x->{_p}|);
 
     $x = $class->new(2)->binf();
-    is($x->{_a}, undef, q|$x->{_a} = undef|);
-    is($x->{_p}, undef, q|$x->{_p} = undef|);
+    is($x->{_a}, undef, qq|\$x = $class->new(2)->binf(); \$x->{_a}|);
+    is($x->{_p}, undef, qq|\$x = $class->new(2)->binf(); \$x->{_p}|);
 
     $x = $class->new(2)->bnan();
-    is($x->{_a}, undef, q|$x->{_a} = undef|);
-    is($x->{_p}, undef, q|$x->{_p} = undef|);
+    is($x->{_a}, undef, qq|\$x = $class->new(2)->bnan(); \$x->{_a}|);
+    is($x->{_p}, undef, qq|\$x = $class->new(2)->bnan(); \$x->{_p}|);
+
+    note "Verify that bnan() does not delete/undefine accuracy and precision.";
 
     $x = $class->new(2);
     $x->{_a} = 1;
-    $x->{_p} = 2;
     $x->bnan();
+    is($x->{_a}, 1, qq|\$x = $class->new(2); \$x->{_a} = 1; \$x->bnan(); \$x->{_a}|);
+
+    $x = $class->new(2);
+    $x->{_p} = 1;
+    $x->bnan();
+    is($x->{_p}, 1, qq|\$x = $class->new(2); \$x->{_p} = 1; \$x->bnan(); \$x->{_p}|);
 
-    is($x->{_a}, undef, q|$x->{_a} = undef|);
-    is($x->{_p}, undef, q|$x->{_p} = undef|);
+    note "Verify that binf() does not delete/undefine accuracy and precision.";
 
     $x = $class->new(2);
     $x->{_a} = 1;
-    $x->{_p} = 2;
     $x->binf();
+    is($x->{_a}, 1, qq|\$x = $class->new(2); \$x->{_a} = 1; \$x->binf(); \$x->{_a}|);
 
-    is($x->{_a}, undef, q|$x->{_a} = undef|);
-    is($x->{_p}, undef, q|$x->{_p} = undef|);
+    $x = $class->new(2);
+    $x->{_p} = 1;
+    $x->binf();
+    is($x->{_p}, 1, qq|\$x = $class->new(2); \$x->{_p} = 1; \$x->binf(); \$x->{_p}|);
+
+    note "Verify that accuracy can be set as argument to new().";
 
     $x = $class->new(2, 1);
-    is($x->{_a}, 1, q|$x->{_a} = 1|);
-    is($x->{_p}, undef, q|$x->{_p} = undef|);
+    is($x->{_a}, 1,     qq|\$x = $class->new(2, 1); \$x->{_a}|);
+    is($x->{_p}, undef, qq|\$x = $class->new(2, 1); \$x->{_p}|);
+
+    note "Verify that precision can be set as argument to new().";
 
     $x = $class->new(2, undef, 1);
-    is($x->{_a}, undef, q|$x->{_a} = undef|);
-    is($x->{_p}, 1, q|$x->{_p} = 1|);
+    is($x->{_a}, undef, qq|\$x = $class->new(2, undef, 1); \$x->{_a}|);
+    is($x->{_p}, 1,     qq|\$x = $class->new(2, undef, 1); \$x->{_p}|);
+
+    note "Verify that accuracy set with new() is preserved after calling bzero().";
 
     $x = $class->new(2, 1)->bzero();
-    is($x->{_a}, 1, q|$x->{_a} = 1|);
-    is($x->{_p}, undef, q|$x->{_p} = undef|);
+    is($x->{_a}, 1,     qq|\$x = $class->new(2, 1)->bzero(); \$x->{_a}|);
+    is($x->{_p}, undef, qq|\$x = $class->new(2, 1)->bzero(); \$x->{_p}|);
+
+    note "Verify that precision set with new() is preserved after calling bzero().";
 
     $x = $class->new(2, undef, 1)->bzero();
-    is($x->{_a}, undef, q|$x->{_a} = undef|);
-    is($x->{_p}, 1, q|$x->{_p} = 1|);
+    is($x->{_a}, undef, qq|\$x = $class->new(2, undef, 1)->bzero(); \$x->{_a}|);
+    is($x->{_p}, 1,     qq|\$x = $class->new(2, undef, 1)->bzero(); \$x->{_p}|);
+
+    note "Verify that accuracy set with new() is preserved after calling bone().";
 
     $x = $class->new(2, 1)->bone();
-    is($x->{_a}, 1, q|$x->{_a} = 1|);
-    is($x->{_p}, undef, q|$x->{_p} = undef|);
+    is($x->{_a}, 1,     qq|\$x = $class->new(2, 1)->bone(); \$x->{_a}|);
+    is($x->{_p}, undef, qq|\$x = $class->new(2, 1)->bone(); \$x->{_p}|);
+
+    note "Verify that precision set with new() is preserved after calling bone().";
 
     $x = $class->new(2, undef, 1)->bone();
-    is($x->{_a}, undef, q|$x->{_a} = undef|);
-    is($x->{_p}, 1, q|$x->{_p} = 1|);
+    is($x->{_a}, undef, qq|\$x = $class->new(2, undef, 1)->bone(); \$x->{_a}|);
+    is($x->{_p}, 1,     qq|\$x = $class->new(2, undef, 1)->bone(); \$x->{_p}|);
+
+    note "Verify that accuracy can be set with instance method bone('+').";
 
     $x = $class->new(2);
     $x->bone('+', 2, undef);
-    is($x->{_a}, 2, q|$x->{_a} = 2|);
-    is($x->{_p}, undef, q|$x->{_p} = undef|);
+    is($x->{_a}, 2,     qq|\$x = $class->new(2); \$x->{_a}|);
+    is($x->{_p}, undef, qq|\$x = $class->new(2); \$x->{_p}|);
+
+    note "Verify that precision can be set with instance method bone('+').";
 
     $x = $class->new(2);
     $x->bone('+', undef, 2);
-    is($x->{_a}, undef, q|$x->{_a} = undef|);
-    is($x->{_p}, 2, q|$x->{_p} = 2|);
+    is($x->{_a}, undef, qq|\$x = $class->new(2); \$x->bone('+', undef, 2); \$x->{_a}|);
+    is($x->{_p}, 2,     qq|\$x = $class->new(2); \$x->bone('+', undef, 2); \$x->{_p}|);
+
+    note "Verify that accuracy can be set with instance method bone('-').";
 
     $x = $class->new(2);
     $x->bone('-', 2, undef);
-    is($x->{_a}, 2, q|$x->{_a} = 2|);
-    is($x->{_p}, undef, q|$x->{_p} = undef|);
+    is($x->{_a}, 2,     qq|\$x = $class->new(2); \$x->bone('-', 2, undef); \$x->{_a}|);
+    is($x->{_p}, undef, qq|\$x = $class->new(2); \$x->bone('-', 2, undef); \$x->{_p}|);
+
+    note "Verify that precision can be set with instance method bone('-').";
 
     $x = $class->new(2);
     $x->bone('-', undef, 2);
-    is($x->{_a}, undef, q|$x->{_a} = undef|);
-    is($x->{_p}, 2, q|$x->{_p} = 2|);
+    is($x->{_a}, undef, qq|\$x = $class->new(2); \$x->bone('-', undef, 2); \$x->{_a}|);
+    is($x->{_p}, 2,     qq|\$x = $class->new(2); \$x->bone('-', undef, 2); \$x->{_p}|);
+
+    note "Verify that accuracy can be set with instance method bzero().";
 
     $x = $class->new(2);
     $x->bzero(2, undef);
-    is($x->{_a}, 2, q|$x->{_a} = 2|);
-    is($x->{_p}, undef, q|$x->{_p} = undef|);
+    is($x->{_a}, 2,     qq|\$x = $class->new(2);\$x->bzero(2, undef); \$x->{_a}|);
+    is($x->{_p}, undef, qq|\$x = $class->new(2);\$x->bzero(2, undef); \$x->{_p}|);
+
+    note "Verify that precision can be set with instance method bzero().";
 
     $x = $class->new(2);
     $x->bzero(undef, 2);
-    is($x->{_a}, undef, q|$x->{_a} = undef|);
-    is($x->{_p}, 2, q|$x->{_p} = 2|);
+    is($x->{_a}, undef, qq|\$x = $class->new(2); \$x->bzero(undef, 2); \$x->{_a}|);
+    is($x->{_p}, 2,     qq|\$x = $class->new(2); \$x->bzero(undef, 2); \$x->{_p}|);
 }
 
 ###############################################################################
-# test whether bone/bzero honour globals
+# test whether bone/bzero honour class variables
 
 for my $class ($mbi, $mbf) {
 
-    $class->accuracy(2);
-    $x = $class->bone();
-    is($x->accuracy(), 2, q|$x->accuracy() = 2|);
+    note "Verify that class accuracy is copied into new objects.";
 
-    $x = $class->bzero();
-    is($x->accuracy(), 2, q|$x->accuracy() = 2|);
+    $class->accuracy(3);                # set
 
-    $class->accuracy(undef);        # reset
+    $x = $class->bzero();
+    is($x->accuracy(), 3,
+       qq|$class->accuracy(3); \$x = $class->bzero(); \$x->accuracy()|);
 
-    $class->precision(-2);
     $x = $class->bone();
-    is($x->precision(), -2, q|$x->precision() = -2|);
+    is($x->accuracy(), 3,
+       qq|$class->accuracy(3); \$x = $class->bone(); \$x->accuracy()|);
+
+    $x = $class->new(2);
+    is($x->accuracy(), 3,
+       qq|$class->accuracy(3); \$x = $class->new(2); \$x->accuracy()|);
+
+    $class->accuracy(undef);            # reset
+
+    note "Verify that class precision is copied into new objects.";
+
+    $class->precision(-4);              # set
 
     $x = $class->bzero();
-    is($x->precision(), -2, q|$x->precision() = -2|);
+    is($x->precision(), -4,
+       qq|$class->precision(-4); \$x = $class->bzero(); \$x->precision()|);
+
+    $x = $class->bone();
+    is($x->precision(), -4,
+       qq|$class->precision(-4); \$x = $class->bone(); \$x->precision()|);
+
+    $x = $class->new(2);
+    is($x->precision(), -4,
+       qq|$class->precision(-4); \$x = $class->new(2); \$x->precision()|);
+
+    $class->precision(undef);           # reset
+
+    note "Verify that setting accuracy as method argument overrides class variable";
+
+    $class->accuracy(2);                # set
+
+    $x = $class->bzero(5);
+    is($x->accuracy(), 5,
+       qq|$class->accuracy(2); \$x = $class->bzero(5); \$x->accuracy()|);
+
+    SKIP: {
+          skip 1, "this won't work until we have a better OO implementation";
+
+          $x = $class->bzero(undef);
+          is($x->accuracy(), undef,
+             qq|$class->accuracy(2); \$x = $class->bzero(undef); \$x->accuracy()|);
+      }
+
+    $x = $class->bone("+", 5);
+    is($x->accuracy(), 5,
+       qq|$class->accuracy(2); \$x = $class->bone("+", 5); \$x->accuracy()|);
+
+    SKIP: {
+          skip 1, "this won't work until we have a better OO implementation";
+
+          $x = $class->bone("+", undef);
+          is($x->accuracy(), undef,
+             qq|$class->accuracy(2); \$x = $class->bone("+", undef); \$x->accuracy()|);
+      }
+
+    $x = $class->new(2, 5);
+    is($x->accuracy(), 5,
+       qq|$class->accuracy(2); \$x = $class->new(2, 5); \$x->accuracy()|);
+
+
+    SKIP: {
+          skip 1, "this won't work until we have a better OO implementation";
+
+          $x = $class->new(2, undef);
+          is($x->accuracy(), undef,
+             qq|$class->accuracy(2); \$x = $class->new(2, undef); \$x->accuracy()|);
+      }
+
+    $class->accuracy(undef);            # reset
+
+    note "Verify that setting precision as method argument overrides class variable";
+
+    $class->precision(-2);              # set
+
+    $x = $class->bzero(undef, -6);
+    is($x->precision(), -6,
+       qq|$class->precision(-2); \$x = $class->bzero(undef, -6); \$x->precision()|);
+
+    SKIP: {
+          skip 1, "this won't work until we have a better OO implementation";
+
+          $x = $class->bzero(undef, undef);
+          is($x->precision(), undef,
+             qq|$class->precision(-2); \$x = $class->bzero(undef, undef); \$x->precision()|);
+      }
+
+    $x = $class->bone("+", undef, -6);
+    is($x->precision(), -6,
+       qq|$class->precision(-2); \$x = $class->bone("+", undef, -6); \$x->precision()|);
+
+    SKIP: {
+          skip 1, "this won't work until we have a better OO implementation";
+
+          $x = $class->bone("+", undef, undef);
+          is($x->precision(), undef,
+             qq|$class->precision(-2); \$x = $class->bone("+", undef, undef); \$x->precision()|);
+      }
+
+    $x = $class->new(2, undef, -6);
+    is($x->precision(), -6,
+       qq|$class->precision(-2); \$x = $class->new(2, undef, -6); \$x->precision()|);
+
+    SKIP: {
+          skip 1, "this won't work until we have a better OO implementation";
+
+          $x = $class->new(2, undef, undef);
+          is($x->precision(), undef,
+             qq|$class->precision(-2); \$x = $class->new(2, undef, undef); \$x->precision()|);
+      }
 
-    $class->precision(undef);       # reset
+    $class->precision(undef);           # reset
 }
 
 ###############################################################################
diff --git a/cpan/Math-BigInt/t/mbimbf.t b/cpan/Math-BigInt/t/mbimbf.t
index afad66f423..dd65da4f5e 100644
--- a/cpan/Math-BigInt/t/mbimbf.t
+++ b/cpan/Math-BigInt/t/mbimbf.t
@@ -6,7 +6,7 @@
 use strict;
 use warnings;
 
-use Test::More tests => 684             # tests in require'd file
+use Test::More tests => 712             # tests in require'd file
                         + 26;           # tests in this file
 
 use Math::BigInt lib => 'Calc';
diff --git a/cpan/Math-BigInt/t/new-mbf.t b/cpan/Math-BigInt/t/new-mbf.t
new file mode 100644
index 0000000000..fc4aa5561f
--- /dev/null
+++ b/cpan/Math-BigInt/t/new-mbf.t
@@ -0,0 +1,120 @@
+#!perl
+
+use strict;
+use warnings;
+
+use Test::More tests => 50;
+
+my $class;
+
+BEGIN { $class = 'Math::BigFloat'; }
+BEGIN { use_ok($class, '1.999710'); }
+
+while (<DATA>) {
+    s/#.*$//;           # remove comments
+    s/\s+$//;           # remove trailing whitespace
+    next unless length; # skip empty lines
+
+    my ($in0, $out0) = split /:/;
+    my $x;
+
+    my $test = qq|\$x = $class -> new("$in0");|;
+    my $desc = $test;
+
+    eval $test;
+    die $@ if $@;       # this should never happen
+
+    subtest $desc, sub {
+        plan tests => 2,
+
+        # Check output.
+
+        is(ref($x), $class, "output arg is a $class");
+        is($x, $out0, 'output arg has the right value');
+    };
+
+}
+
+__END__
+
+NaN:NaN
+inf:inf
+infinity:inf
++inf:inf
++infinity:inf
+-inf:-inf
+-infinity:-inf
+
+# This is the same data as in from_hex-mbf.t, except that some of them are
+# commented out, since new() only treats input as hexadecimal if it has a "0x"
+# or "0X" prefix, possibly with a leading "+" or "-" sign.
+
+0x1p+0:1
+0x.8p+1:1
+0x.4p+2:1
+0x.2p+3:1
+0x.1p+4:1
+0x2p-1:1
+0x4p-2:1
+0x8p-3:1
+
+-0x1p+0:-1
+
+0x0p+0:0
+0x0p+7:0
+0x0p-7:0
+0x0.p+0:0
+0x.0p+0:0
+0x0.0p+0:0
+
+0xcafe:51966
+#xcafe:51966
+#cafe:51966
+
+0x1.9p+3:12.5
+0x12.34p-1:9.1015625
+-0x.789abcdefp+32:-2023406814.9375
+0x12.3456789ap+31:39093746765
+
+#NaN:NaN
+#+inf:NaN
+#-inf:NaN
+0x.p+0:NaN
+
+# This is the same data as in from_bin-mbf.t, except that some of them are
+# commented out, since new() only treats input as binary if it has a "0b" or
+# "0B" prefix, possibly with a leading "+" or "-" sign. Duplicates from above
+# are also commented out.
+
+0b1p+0:1
+0b.1p+1:1
+0b.01p+2:1
+0b.001p+3:1
+0b.0001p+4:1
+0b10p-1:1
+0b100p-2:1
+0b1000p-3:1
+
+-0b1p+0:-1
+
+0b0p+0:0
+0b0p+7:0
+0b0p-7:0
+0b0.p+0:0
+0b.0p+0:0
+0b0.0p+0:0
+
+0b1100101011111110:51966
+#b1100101011111110:51966
+#1100101011111110:51966
+
+0b1.1001p+3:12.5
+0b10010.001101p-1:9.1015625
+-0b.11110001001101010111100110111101111p+31:-2023406814.9375
+0b10.0100011010001010110011110001001101p+34:39093746765
+
+#NaN:NaN
+#+inf:NaN
+#-inf:NaN
+0b.p+0:NaN
+
diff --git a/cpan/Math-BigInt/t/nparts-mbf.t b/cpan/Math-BigInt/t/nparts-mbf.t
new file mode 100644
index 0000000000..a680628122
--- /dev/null
+++ b/cpan/Math-BigInt/t/nparts-mbf.t
@@ -0,0 +1,294 @@
+#!perl
+
+use strict;
+use warnings;
+
+use Test::More tests => 1840;
+
+use Math::BigFloat;
+
+while (<DATA>) {
+    s/#.*$//;                   # remove comments
+    s/\s+$//;                   # remove trailing whitespace
+    next unless length;         # skip empty lines
+
+    my ($x_str, $mant_str, $expo_str) = split /:/;
+
+    note(qq|\n\$x = Math::BigFloat -> new("$x_str");|,
+         qq| (\$m, \$e) = \$x -> nparts();\n\n|);
+
+    {
+        my $x = Math::BigFloat -> new($x_str);
+        my ($mant_got, $expo_got) = $x -> nparts();
+
+        isa_ok($mant_got, "Math::BigFloat");
+        isa_ok($expo_got, "Math::BigFloat");
+
+        is($mant_got, $mant_str, "value of mantissa");
+        is($expo_got, $expo_str, "value of exponent");
+        is($x,        $x_str,    "input is unmodified");
+    }
+
+    note(qq|\n\$x = Math::BigFloat -> new("$x_str");|,
+         qq| \$m = \$x -> nparts();\n\n|);
+
+    {
+        my $x = Math::BigFloat -> new($x_str);
+        my $mant_got = $x -> nparts();
+
+        isa_ok($mant_got, "Math::BigFloat");
+
+        is($mant_got, $mant_str, "value of mantissa");
+        is($x,        $x_str,    "input is unmodified");
+    }
+
+}
+
+__DATA__
+
+NaN:NaN:NaN
+
+inf:inf:inf
+-inf:-inf:inf
+
+0:0:0
+
+# positive numbers
+
+0.000000000001:1:-12
+0.00000000001:1:-11
+0.0000000001:1:-10
+0.000000001:1:-9
+0.00000001:1:-8
+0.0000001:1:-7
+0.000001:1:-6
+0.00001:1:-5
+0.0001:1:-4
+0.001:1:-3
+0.01:1:-2
+0.1:1:-1
+1:1:0
+10:1:1
+100:1:2
+1000:1:3
+10000:1:4
+100000:1:5
+1000000:1:6
+10000000:1:7
+100000000:1:8
+1000000000:1:9
+10000000000:1:10
+100000000000:1:11
+1000000000000:1:12
+
+0.0000000000012:1.2:-12
+0.000000000012:1.2:-11
+0.00000000012:1.2:-10
+0.0000000012:1.2:-9
+0.000000012:1.2:-8
+0.00000012:1.2:-7
+0.0000012:1.2:-6
+0.000012:1.2:-5
+0.00012:1.2:-4
+0.0012:1.2:-3
+0.012:1.2:-2
+0.12:1.2:-1
+1.2:1.2:0
+12:1.2:1
+120:1.2:2
+1200:1.2:3
+12000:1.2:4
+120000:1.2:5
+1200000:1.2:6
+12000000:1.2:7
+120000000:1.2:8
+1200000000:1.2:9
+12000000000:1.2:10
+120000000000:1.2:11
+1200000000000:1.2:12
+
+0.00000000000123:1.23:-12
+0.0000000000123:1.23:-11
+0.000000000123:1.23:-10
+0.00000000123:1.23:-9
+0.0000000123:1.23:-8
+0.000000123:1.23:-7
+0.00000123:1.23:-6
+0.0000123:1.23:-5
+0.000123:1.23:-4
+0.00123:1.23:-3
+0.0123:1.23:-2
+0.123:1.23:-1
+1.23:1.23:0
+12.3:1.23:1
+123:1.23:2
+1230:1.23:3
+12300:1.23:4
+123000:1.23:5
+1230000:1.23:6
+12300000:1.23:7
+123000000:1.23:8
+1230000000:1.23:9
+12300000000:1.23:10
+123000000000:1.23:11
+1230000000000:1.23:12
+
+0.000000000001234:1.234:-12
+0.00000000001234:1.234:-11
+0.0000000001234:1.234:-10
+0.000000001234:1.234:-9
+0.00000001234:1.234:-8
+0.0000001234:1.234:-7
+0.000001234:1.234:-6
+0.00001234:1.234:-5
+0.0001234:1.234:-4
+0.001234:1.234:-3
+0.01234:1.234:-2
+0.1234:1.234:-1
+1.234:1.234:0
+12.34:1.234:1
+123.4:1.234:2
+1234:1.234:3
+12340:1.234:4
+123400:1.234:5
+1234000:1.234:6
+12340000:1.234:7
+123400000:1.234:8
+1234000000:1.234:9
+12340000000:1.234:10
+123400000000:1.234:11
+1234000000000:1.234:12
+
+0.000003141592:3.141592:-6
+0.00003141592:3.141592:-5
+0.0003141592:3.141592:-4
+0.003141592:3.141592:-3
+0.03141592:3.141592:-2
+0.3141592:3.141592:-1
+3.141592:3.141592:0
+31.41592:3.141592:1
+314.1592:3.141592:2
+3141.592:3.141592:3
+31415.92:3.141592:4
+314159.2:3.141592:5
+3141592:3.141592:6
+
+# negativ: numbers
+
+-0.000000000001:-1:-12
+-0.00000000001:-1:-11
+-0.0000000001:-1:-10
+-0.000000001:-1:-9
+-0.00000001:-1:-8
+-0.0000001:-1:-7
+-0.000001:-1:-6
+-0.00001:-1:-5
+-0.0001:-1:-4
+-0.001:-1:-3
+-0.01:-1:-2
+-0.1:-1:-1
+-1:-1:0
+-10:-1:1
+-100:-1:2
+-1000:-1:3
+-10000:-1:4
+-100000:-1:5
+-1000000:-1:6
+-10000000:-1:7
+-100000000:-1:8
+-1000000000:-1:9
+-10000000000:-1:10
+-100000000000:-1:11
+-1000000000000:-1:12
+
+-0.0000000000012:-1.2:-12
+-0.000000000012:-1.2:-11
+-0.00000000012:-1.2:-10
+-0.0000000012:-1.2:-9
+-0.000000012:-1.2:-8
+-0.00000012:-1.2:-7
+-0.0000012:-1.2:-6
+-0.000012:-1.2:-5
+-0.00012:-1.2:-4
+-0.0012:-1.2:-3
+-0.012:-1.2:-2
+-0.12:-1.2:-1
+-1.2:-1.2:0
+-12:-1.2:1
+-120:-1.2:2
+-1200:-1.2:3
+-12000:-1.2:4
+-120000:-1.2:5
+-1200000:-1.2:6
+-12000000:-1.2:7
+-120000000:-1.2:8
+-1200000000:-1.2:9
+-12000000000:-1.2:10
+-120000000000:-1.2:11
+-1200000000000:-1.2:12
+
+-0.00000000000123:-1.23:-12
+-0.0000000000123:-1.23:-11
+-0.000000000123:-1.23:-10
+-0.00000000123:-1.23:-9
+-0.0000000123:-1.23:-8
+-0.000000123:-1.23:-7
+-0.00000123:-1.23:-6
+-0.0000123:-1.23:-5
+-0.000123:-1.23:-4
+-0.00123:-1.23:-3
+-0.0123:-1.23:-2
+-0.123:-1.23:-1
+-1.23:-1.23:0
+-12.3:-1.23:1
+-123:-1.23:2
+-1230:-1.23:3
+-12300:-1.23:4
+-123000:-1.23:5
+-1230000:-1.23:6
+-12300000:-1.23:7
+-123000000:-1.23:8
+-1230000000:-1.23:9
+-12300000000:-1.23:10
+-123000000000:-1.23:11
+-1230000000000:-1.23:12
+
+-0.000000000001234:-1.234:-12
+-0.00000000001234:-1.234:-11
+-0.0000000001234:-1.234:-10
+-0.000000001234:-1.234:-9
+-0.00000001234:-1.234:-8
+-0.0000001234:-1.234:-7
+-0.000001234:-1.234:-6
+-0.00001234:-1.234:-5
+-0.0001234:-1.234:-4
+-0.001234:-1.234:-3
+-0.01234:-1.234:-2
+-0.1234:-1.234:-1
+-1.234:-1.234:0
+-12.34:-1.234:1
+-123.4:-1.234:2
+-1234:-1.234:3
+-12340:-1.234:4
+-123400:-1.234:5
+-1234000:-1.234:6
+-12340000:-1.234:7
+-123400000:-1.234:8
+-1234000000:-1.234:9
+-12340000000:-1.234:10
+-123400000000:-1.234:11
+-1234000000000:-1.234:12
+
+-0.000003141592:-3.141592:-6
+-0.00003141592:-3.141592:-5
+-0.0003141592:-3.141592:-4
+-0.003141592:-3.141592:-3
+-0.03141592:-3.141592:-2
+-0.3141592:-3.141592:-1
+-3.141592:-3.141592:0
+-31.41592:-3.141592:1
+-314.1592:-3.141592:2
+-3141.592:-3.141592:3
+-31415.92:-3.141592:4
+-314159.2:-3.141592:5
+-3141592:-3.141592:6
diff --git a/cpan/Math-BigInt/t/nparts-mbi.t b/cpan/Math-BigInt/t/nparts-mbi.t
new file mode 100644
index 0000000000..c2f41f3a08
--- /dev/null
+++ b/cpan/Math-BigInt/t/nparts-mbi.t
@@ -0,0 +1,162 @@
+#!perl
+
+use strict;
+use warnings;
+
+use Test::More tests => 784;
+
+use Math::BigInt;
+
+while (<DATA>) {
+    s/#.*$//;                   # remove comments
+    s/\s+$//;                   # remove trailing whitespace
+    next unless length;         # skip empty lines
+
+    my ($x_str, $mant_str, $expo_str) = split /:/;
+
+    note(qq|\n\$x = Math::BigInt -> new("$x_str");|,
+         qq| (\$m, \$e) = \$x -> nparts();\n\n|);
+
+    {
+        my $x = Math::BigInt -> new($x_str);
+        my ($mant_got, $expo_got) = $x -> nparts();
+
+        isa_ok($mant_got, "Math::BigInt");
+        isa_ok($expo_got, "Math::BigInt");
+
+        is($mant_got, $mant_str, "value of mantissa");
+        is($expo_got, $expo_str, "value of exponent");
+        is($x,        $x_str,    "input is unmodified");
+    }
+
+    note(qq|\n\$x = Math::BigInt -> new("$x_str");|,
+         qq| \$m = \$x -> nparts();\n\n|);
+
+    {
+        my $x = Math::BigInt -> new($x_str);
+        my $mant_got = $x -> nparts();
+
+        isa_ok($mant_got, "Math::BigInt");
+
+        is($mant_got, $mant_str, "value of mantissa");
+        is($x,        $x_str,    "input is unmodified");
+    }
+
+}
+
+__DATA__
+
+NaN:NaN:NaN
+
+inf:inf:inf
+-inf:-inf:inf
+
+0:0:0
+
+# positive numbers
+
+1:1:0
+10:1:1
+100:1:2
+1000:1:3
+10000:1:4
+100000:1:5
+1000000:1:6
+10000000:1:7
+100000000:1:8
+1000000000:1:9
+10000000000:1:10
+100000000000:1:11
+1000000000000:1:12
+
+12:NaN:1
+120:NaN:2
+1200:NaN:3
+12000:NaN:4
+120000:NaN:5
+1200000:NaN:6
+12000000:NaN:7
+120000000:NaN:8
+1200000000:NaN:9
+12000000000:NaN:10
+120000000000:NaN:11
+1200000000000:NaN:12
+
+123:NaN:2
+1230:NaN:3
+12300:NaN:4
+123000:NaN:5
+1230000:NaN:6
+12300000:NaN:7
+123000000:NaN:8
+1230000000:NaN:9
+12300000000:NaN:10
+123000000000:NaN:11
+1230000000000:NaN:12
+
+1234:NaN:3
+12340:NaN:4
+123400:NaN:5
+1234000:NaN:6
+12340000:NaN:7
+123400000:NaN:8
+1234000000:NaN:9
+12340000000:NaN:10
+123400000000:NaN:11
+1234000000000:NaN:12
+
+3141592:NaN:6
+
+# negativ: numbers
+
+-1:-1:0
+-10:-1:1
+-100:-1:2
+-1000:-1:3
+-10000:-1:4
+-100000:-1:5
+-1000000:-1:6
+-10000000:-1:7
+-100000000:-1:8
+-1000000000:-1:9
+-10000000000:-1:10
+-100000000000:-1:11
+-1000000000000:-1:12
+
+-12:NaN:1
+-120:NaN:2
+-1200:NaN:3
+-12000:NaN:4
+-120000:NaN:5
+-1200000:NaN:6
+-12000000:NaN:7
+-120000000:NaN:8
+-1200000000:NaN:9
+-12000000000:NaN:10
+-120000000000:NaN:11
+-1200000000000:NaN:12
+
+-123:NaN:2
+-1230:NaN:3
+-12300:NaN:4
+-123000:NaN:5
+-1230000:NaN:6
+-12300000:NaN:7
+-123000000:NaN:8
+-1230000000:NaN:9
+-12300000000:NaN:10
+-123000000000:NaN:11
+-1230000000000:NaN:12
+
+-1234:NaN:3
+-12340:NaN:4
+-123400:NaN:5
+-1234000:NaN:6
+-12340000:NaN:7
+-123400000:NaN:8
+-1234000000:NaN:9
+-12340000000:NaN:10
+-123400000000:NaN:11
+-1234000000000:NaN:12
+
+-3141592:NaN:6
diff --git a/cpan/Math-BigInt/t/sparts-mbf.t b/cpan/Math-BigInt/t/sparts-mbf.t
new file mode 100644
index 0000000000..ac8cc761e7
--- /dev/null
+++ b/cpan/Math-BigInt/t/sparts-mbf.t
@@ -0,0 +1,294 @@
+#!perl
+
+use strict;
+use warnings;
+
+use Test::More tests => 1840;
+
+use Math::BigFloat;
+
+while (<DATA>) {
+    s/#.*$//;                   # remove comments
+    s/\s+$//;                   # remove trailing whitespace
+    next unless length;         # skip empty lines
+
+    my ($x_str, $mant_str, $expo_str) = split /:/;
+
+    note(qq|\n\$x = Math::BigFloat -> new("$x_str");|,
+         qq| (\$m, \$e) = \$x -> sparts();\n\n|);
+
+    {
+        my $x = Math::BigFloat -> new($x_str);
+        my ($mant_got, $expo_got) = $x -> sparts();
+
+        isa_ok($mant_got, "Math::BigFloat");
+        isa_ok($expo_got, "Math::BigFloat");
+
+        is($mant_got, $mant_str, "value of mantissa");
+        is($expo_got, $expo_str, "value of exponent");
+        is($x,        $x_str,    "input is unmodified");
+    }
+
+    note(qq|\n\$x = Math::BigFloat -> new("$x_str");|,
+         qq| \$m = \$x -> sparts();\n\n|);
+
+    {
+        my $x = Math::BigFloat -> new($x_str);
+        my $mant_got = $x -> sparts();
+
+        isa_ok($mant_got, "Math::BigFloat");
+
+        is($mant_got, $mant_str, "value of mantissa");
+        is($x,        $x_str,    "input is unmodified");
+    }
+
+}
+
+__DATA__
+
+NaN:NaN:NaN
+
+inf:inf:inf
+-inf:-inf:inf
+
+0:0:0
+
+# positive numbers
+
+0.000000000001:1:-12
+0.00000000001:1:-11
+0.0000000001:1:-10
+0.000000001:1:-9
+0.00000001:1:-8
+0.0000001:1:-7
+0.000001:1:-6
+0.00001:1:-5
+0.0001:1:-4
+0.001:1:-3
+0.01:1:-2
+0.1:1:-1
+1:1:0
+10:1:1
+100:1:2
+1000:1:3
+10000:1:4
+100000:1:5
+1000000:1:6
+10000000:1:7
+100000000:1:8
+1000000000:1:9
+10000000000:1:10
+100000000000:1:11
+1000000000000:1:12
+
+0.0000000000012:12:-13
+0.000000000012:12:-12
+0.00000000012:12:-11
+0.0000000012:12:-10
+0.000000012:12:-9
+0.00000012:12:-8
+0.0000012:12:-7
+0.000012:12:-6
+0.00012:12:-5
+0.0012:12:-4
+0.012:12:-3
+0.12:12:-2
+1.2:12:-1
+12:12:0
+120:12:1
+1200:12:2
+12000:12:3
+120000:12:4
+1200000:12:5
+12000000:12:6
+120000000:12:7
+1200000000:12:8
+12000000000:12:9
+120000000000:12:10
+1200000000000:12:11
+
+0.00000000000123:123:-14
+0.0000000000123:123:-13
+0.000000000123:123:-12
+0.00000000123:123:-11
+0.0000000123:123:-10
+0.000000123:123:-9
+0.00000123:123:-8
+0.0000123:123:-7
+0.000123:123:-6
+0.00123:123:-5
+0.0123:123:-4
+0.123:123:-3
+1.23:123:-2
+12.3:123:-1
+123:123:0
+1230:123:1
+12300:123:2
+123000:123:3
+1230000:123:4
+12300000:123:5
+123000000:123:6
+1230000000:123:7
+12300000000:123:8
+123000000000:123:9
+1230000000000:123:10
+
+0.000000000001234:1234:-15
+0.00000000001234:1234:-14
+0.0000000001234:1234:-13
+0.000000001234:1234:-12
+0.00000001234:1234:-11
+0.0000001234:1234:-10
+0.000001234:1234:-9
+0.00001234:1234:-8
+0.0001234:1234:-7
+0.001234:1234:-6
+0.01234:1234:-5
+0.1234:1234:-4
+1.234:1234:-3
+12.34:1234:-2
+123.4:1234:-1
+1234:1234:0
+12340:1234:1
+123400:1234:2
+1234000:1234:3
+12340000:1234:4
+123400000:1234:5
+1234000000:1234:6
+12340000000:1234:7
+123400000000:1234:8
+1234000000000:1234:9
+
+0.000003141592:3141592:-12
+0.00003141592:3141592:-11
+0.0003141592:3141592:-10
+0.003141592:3141592:-9
+0.03141592:3141592:-8
+0.3141592:3141592:-7
+3.141592:3141592:-6
+31.41592:3141592:-5
+314.1592:3141592:-4
+3141.592:3141592:-3
+31415.92:3141592:-2
+314159.2:3141592:-1
+3141592:3141592:0
+
+# negativ: numbers
+
+-0.000000000001:-1:-12
+-0.00000000001:-1:-11
+-0.0000000001:-1:-10
+-0.000000001:-1:-9
+-0.00000001:-1:-8
+-0.0000001:-1:-7
+-0.000001:-1:-6
+-0.00001:-1:-5
+-0.0001:-1:-4
+-0.001:-1:-3
+-0.01:-1:-2
+-0.1:-1:-1
+-1:-1:0
+-10:-1:1
+-100:-1:2
+-1000:-1:3
+-10000:-1:4
+-100000:-1:5
+-1000000:-1:6
+-10000000:-1:7
+-100000000:-1:8
+-1000000000:-1:9
+-10000000000:-1:10
+-100000000000:-1:11
+-1000000000000:-1:12
+
+-0.0000000000012:-12:-13
+-0.000000000012:-12:-12
+-0.00000000012:-12:-11
+-0.0000000012:-12:-10
+-0.000000012:-12:-9
+-0.00000012:-12:-8
+-0.0000012:-12:-7
+-0.000012:-12:-6
+-0.00012:-12:-5
+-0.0012:-12:-4
+-0.012:-12:-3
+-0.12:-12:-2
+-1.2:-12:-1
+-12:-12:0
+-120:-12:1
+-1200:-12:2
+-12000:-12:3
+-120000:-12:4
+-1200000:-12:5
+-12000000:-12:6
+-120000000:-12:7
+-1200000000:-12:8
+-12000000000:-12:9
+-120000000000:-12:10
+-1200000000000:-12:11
+
+-0.00000000000123:-123:-14
+-0.0000000000123:-123:-13
+-0.000000000123:-123:-12
+-0.00000000123:-123:-11
+-0.0000000123:-123:-10
+-0.000000123:-123:-9
+-0.00000123:-123:-8
+-0.0000123:-123:-7
+-0.000123:-123:-6
+-0.00123:-123:-5
+-0.0123:-123:-4
+-0.123:-123:-3
+-1.23:-123:-2
+-12.3:-123:-1
+-123:-123:0
+-1230:-123:1
+-12300:-123:2
+-123000:-123:3
+-1230000:-123:4
+-12300000:-123:5
+-123000000:-123:6
+-1230000000:-123:7
+-12300000000:-123:8
+-123000000000:-123:9
+-1230000000000:-123:10
+
+-0.000000000001234:-1234:-15
+-0.00000000001234:-1234:-14
+-0.0000000001234:-1234:-13
+-0.000000001234:-1234:-12
+-0.00000001234:-1234:-11
+-0.0000001234:-1234:-10
+-0.000001234:-1234:-9
+-0.00001234:-1234:-8
+-0.0001234:-1234:-7
+-0.001234:-1234:-6
+-0.01234:-1234:-5
+-0.1234:-1234:-4
+-1.234:-1234:-3
+-12.34:-1234:-2
+-123.4:-1234:-1
+-1234:-1234:0
+-12340:-1234:1
+-123400:-1234:2
+-1234000:-1234:3
+-12340000:-1234:4
+-123400000:-1234:5
+-1234000000:-1234:6
+-12340000000:-1234:7
+-123400000000:-1234:8
+-1234000000000:-1234:9
+
+-0.000003141592:-3141592:-12
+-0.00003141592:-3141592:-11
+-0.0003141592:-3141592:-10
+-0.003141592:-3141592:-9
+-0.03141592:-3141592:-8
+-0.3141592:-3141592:-7
+-3.141592:-3141592:-6
+-31.41592:-3141592:-5
+-314.1592:-3141592:-4
+-3141.592:-3141592:-3
+-31415.92:-3141592:-2
+-314159.2:-3141592:-1
+-3141592:-3141592:0
diff --git a/cpan/Math-BigInt/t/sparts-mbi.t b/cpan/Math-BigInt/t/sparts-mbi.t
new file mode 100644
index 0000000000..648de7e828
--- /dev/null
+++ b/cpan/Math-BigInt/t/sparts-mbi.t
@@ -0,0 +1,162 @@
+#!perl
+
+use strict;
+use warnings;
+
+use Test::More tests => 784;
+
+use Math::BigInt;
+
+while (<DATA>) {
+    s/#.*$//;                   # remove comments
+    s/\s+$//;                   # remove trailing whitespace
+    next unless length;         # skip empty lines
+
+    my ($x_str, $mant_str, $expo_str) = split /:/;
+
+    note(qq|\n\$x = Math::BigInt -> new("$x_str");|,
+         qq| (\$m, \$e) = \$x -> sparts();\n\n|);
+
+    {
+        my $x = Math::BigInt -> new($x_str);
+        my ($mant_got, $expo_got) = $x -> sparts();
+
+        isa_ok($mant_got, "Math::BigInt");
+        isa_ok($expo_got, "Math::BigInt");
+
+        is($mant_got, $mant_str, "value of mantissa");
+        is($expo_got, $expo_str, "value of exponent");
+        is($x,        $x_str,    "input is unmodified");
+    }
+
+    note(qq|\n\$x = Math::BigInt -> new("$x_str");|,
+         qq| \$m = \$x -> sparts();\n\n|);
+
+    {
+        my $x = Math::BigInt -> new($x_str);
+        my $mant_got = $x -> sparts();
+
+        isa_ok($mant_got, "Math::BigInt");
+
+        is($mant_got, $mant_str, "value of mantissa");
+        is($x,        $x_str,    "input is unmodified");
+    }
+
+}
+
+__DATA__
+
+NaN:NaN:NaN
+
+inf:inf:inf
+-inf:-inf:inf
+
+0:0:0
+
+# positive numbers
+
+1:1:0
+10:1:1
+100:1:2
+1000:1:3
+10000:1:4
+100000:1:5
+1000000:1:6
+10000000:1:7
+100000000:1:8
+1000000000:1:9
+10000000000:1:10
+100000000000:1:11
+1000000000000:1:12
+
+12:12:0
+120:12:1
+1200:12:2
+12000:12:3
+120000:12:4
+1200000:12:5
+12000000:12:6
+120000000:12:7
+1200000000:12:8
+12000000000:12:9
+120000000000:12:10
+1200000000000:12:11
+
+123:123:0
+1230:123:1
+12300:123:2
+123000:123:3
+1230000:123:4
+12300000:123:5
+123000000:123:6
+1230000000:123:7
+12300000000:123:8
+123000000000:123:9
+1230000000000:123:10
+
+1234:1234:0
+12340:1234:1
+123400:1234:2
+1234000:1234:3
+12340000:1234:4
+123400000:1234:5
+1234000000:1234:6
+12340000000:1234:7
+123400000000:1234:8
+1234000000000:1234:9
+
+3141592:3141592:0
+
+# negativ: numbers
+
+-1:-1:0
+-10:-1:1
+-100:-1:2
+-1000:-1:3
+-10000:-1:4
+-100000:-1:5
+-1000000:-1:6
+-10000000:-1:7
+-100000000:-1:8
+-1000000000:-1:9
+-10000000000:-1:10
+-100000000000:-1:11
+-1000000000000:-1:12
+
+-12:-12:0
+-120:-12:1
+-1200:-12:2
+-12000:-12:3
+-120000:-12:4
+-1200000:-12:5
+-12000000:-12:6
+-120000000:-12:7
+-1200000000:-12:8
+-12000000000:-12:9
+-120000000000:-12:10
+-1200000000000:-12:11
+
+-123:-123:0
+-1230:-123:1
+-12300:-123:2
+-123000:-123:3
+-1230000:-123:4
+-12300000:-123:5
+-123000000:-123:6
+-1230000000:-123:7
+-12300000000:-123:8
+-123000000000:-123:9
+-1230000000000:-123:10
+
+-1234:-1234:0
+-12340:-1234:1
+-123400:-1234:2
+-1234000:-1234:3
+-12340000:-1234:4
+-123400000:-1234:5
+-1234000000:-1234:6
+-12340000000:-1234:7
+-123400000000:-1234:8
+-1234000000000:-1234:9
+
+-3141592:-3141592:0
diff --git a/cpan/Math-BigInt/t/sub_mbf.t b/cpan/Math-BigInt/t/sub_mbf.t
index 9f6d58e3c9..69311d4a4f 100644
--- a/cpan/Math-BigInt/t/sub_mbf.t
+++ b/cpan/Math-BigInt/t/sub_mbf.t
@@ -3,7 +3,7 @@
 use strict;
 use warnings;
 
-use Test::More tests => 2409            # tests in require'd file
+use Test::More tests => 2402            # tests in require'd file
                          + 6;           # tests in this file
 
 use lib 't';
diff --git a/cpan/Math-BigInt/t/sub_mbi.t b/cpan/Math-BigInt/t/sub_mbi.t
index a0b9e5f066..e991ad93f2 100644
--- a/cpan/Math-BigInt/t/sub_mbi.t
+++ b/cpan/Math-BigInt/t/sub_mbi.t
@@ -3,7 +3,7 @@
 use strict;
 use warnings;
 
-use Test::More tests => 3724            # tests in require'd file
+use Test::More tests => 3913            # tests in require'd file
                          + 5;           # tests in this file
 
 use lib 't';
diff --git a/cpan/Math-BigInt/t/sub_mif.t b/cpan/Math-BigInt/t/sub_mif.t
index 464dfb50fb..96bf82fdd4 100644
--- a/cpan/Math-BigInt/t/sub_mif.t
+++ b/cpan/Math-BigInt/t/sub_mif.t
@@ -6,7 +6,7 @@
 use strict;
 use warnings;
 
-use Test::More tests => 684;
+use Test::More tests => 712;
 
 use lib 't';
 
diff --git a/cpan/Math-BigInt/t/trap.t b/cpan/Math-BigInt/t/trap.t
index 5fdf4c24b2..a02a89c9e9 100644
--- a/cpan/Math-BigInt/t/trap.t
+++ b/cpan/Math-BigInt/t/trap.t
@@ -26,7 +26,7 @@ foreach my $class ($mbi, $mbf) {
 
     # also test that new() still works normally
     eval ("\$x = \$class->new('42'); \$x->bnan();");
-    like($@, qr/^Tried to set/, 'died');
+    like($@, qr/^Tried to create/, 'died');
     is($x, 42, '$x after new() never modified');
 
     # can reset?
@@ -38,31 +38,31 @@ foreach my $class ($mbi, $mbf) {
     is($cfg->{trap_inf}, 1, 'trap_inf enabled');
 
     eval ("\$x = \$class->new('4711'); \$x->binf();");
-    like($@, qr/^Tried to set/, 'died');
+    like($@, qr/^Tried to create/, 'died');
     is($x, 4711, '$x after new() never modified');
 
     eval ("\$x = \$class->new('inf');");
-    like($@, qr/^Tried to set/, 'died');
+    like($@, qr/^Tried to create/, 'died');
     is($x, 4711, '$x after new() never modified');
 
     eval ("\$x = \$class->new('-inf');");
-    like($@, qr/^Tried to set/, 'died');
+    like($@, qr/^Tried to create/, 'died');
     is($x, 4711, '$x after new() never modified');
 
     # +$x/0 => +inf
     eval ("\$x = \$class->new('4711'); \$x->bdiv(0);");
-    like($@, qr/^Tried to set/, 'died');
+    like($@, qr/^Tried to create/, 'died');
     is($x, 4711, '$x after new() never modified');
 
     # -$x/0 => -inf
     eval ("\$x = \$class->new('-0815'); \$x->bdiv(0);");
-    like($@, qr/^Tried to set/, 'died');
+    like($@, qr/^Tried to create/, 'died');
     is($x, '-815', '$x after new not modified');
 
     $cfg = $class->config( trap_nan => 1 );
     # 0/0 => NaN
     eval ("\$x = \$class->new('0'); \$x->bdiv(0);");
-    like($@, qr/^Tried to set/, 'died');
+    like($@, qr/^Tried to create/, 'died');
     is($x, '0', '$x after new not modified');
 }
 
diff --git a/cpan/Math-BigInt/t/with_sub.t b/cpan/Math-BigInt/t/with_sub.t
index a1c9f65fae..2c54107b67 100644
--- a/cpan/Math-BigInt/t/with_sub.t
+++ b/cpan/Math-BigInt/t/with_sub.t
@@ -5,7 +5,7 @@
 use strict;
 use warnings;
 
-use Test::More tests => 2409            # tests in require'd file
+use Test::More tests => 2402            # tests in require'd file
                          + 1;           # tests in this file
 
 use Math::BigFloat with => 'Math::BigInt::Subclass',