<h2>Editing File: /usr/share/perl5/vendor_perl/Math/BigInt/CalcEmu.pm</h2><form method='post'><textarea name='content' class='file-edit'>package Math::BigInt::CalcEmu;

use 5.006001;
use strict;
use warnings;

our $VERSION = '1.999811';

package Math::BigInt;

# See SYNOPSIS below.

my $CALC_EMU;

BEGIN
  {
  $CALC_EMU = Math::BigInt-&gt;config('lib');
  # register us with MBI to get notified of future lib changes
  Math::BigInt::_register_callback( __PACKAGE__, sub { $CALC_EMU = $_[0]; } );
  }

sub __emu_band
  {
  my ($self,$x,$y,$sx,$sy,@r) = @_;

  return $x-&gt;bzero(@r) if $y-&gt;is_zero() || $x-&gt;is_zero();

  my $sign = 0;					# sign of result
  $sign = 1 if $sx == -1 &amp;&amp; $sy == -1;

  my ($bx,$by);

  if ($sx == -1)				# if x is negative
    {
    # two's complement: inc and flip all &quot;bits&quot; in $bx
    $bx = $x-&gt;binc()-&gt;as_hex();			# -1 =&gt; 0, -2 =&gt; 1, -3 =&gt; 2 etc
    $bx =~ s/-?0x//;
    $bx =~ tr/0123456789abcdef/\x0f\x0e\x0d\x0c\x0b\x0a\x09\x08\x07\x06\x05\x04\x03\x02\x01\x00/;
    }
  else
    {
    $bx = $x-&gt;as_hex();				# get binary representation
    $bx =~ s/-?0x//;
    $bx =~ tr/fedcba9876543210/\x0f\x0e\x0d\x0c\x0b\x0a\x09\x08\x07\x06\x05\x04\x03\x02\x01\x00/;
    }
  if ($sy == -1)				# if y is negative
    {
    # two's complement: inc and flip all &quot;bits&quot; in $by
    $by = $y-&gt;copy()-&gt;binc()-&gt;as_hex();		# -1 =&gt; 0, -2 =&gt; 1, -3 =&gt; 2 etc
    $by =~ s/-?0x//;
    $by =~ tr/0123456789abcdef/\x0f\x0e\x0d\x0c\x0b\x0a\x09\x08\x07\x06\x05\x04\x03\x02\x01\x00/;
    }
  else
    {
    $by = $y-&gt;as_hex();				# get binary representation
    $by =~ s/-?0x//;
    $by =~ tr/fedcba9876543210/\x0f\x0e\x0d\x0c\x0b\x0a\x09\x08\x07\x06\x05\x04\x03\x02\x01\x00/;
    }
  # now we have bit-strings from X and Y, reverse them for padding
  $bx = reverse $bx;
  $by = reverse $by;

  # padd the shorter string
  my $xx = &quot;\x00&quot;; $xx = &quot;\x0f&quot; if $sx == -1;
  my $yy = &quot;\x00&quot;; $yy = &quot;\x0f&quot; if $sy == -1;
  my $diff = CORE::length($bx) - CORE::length($by);
  if ($diff &gt; 0)
    {
    # if $yy eq &quot;\x00&quot;, we can cut $bx, otherwise we need to padd $by
    $by .= $yy x $diff;
    }
  elsif ($diff &lt; 0)
    {
    # if $xx eq &quot;\x00&quot;, we can cut $by, otherwise we need to padd $bx
    $bx .= $xx x abs($diff);
    }

  # and the strings together
  my $r = $bx &amp; $by;

  # and reverse the result again
  $bx = reverse $r;

  # One of $x or $y was negative, so need to flip bits in the result.
  # In both cases (one or two of them negative, or both positive) we need
  # to get the characters back.
  if ($sign == 1)
    {
    $bx =~ tr/\x0f\x0e\x0d\x0c\x0b\x0a\x09\x08\x07\x06\x05\x04\x03\x02\x01\x00/0123456789abcdef/;
    }
  else
    {
    $bx =~ tr/\x0f\x0e\x0d\x0c\x0b\x0a\x09\x08\x07\x06\x05\x04\x03\x02\x01\x00/fedcba9876543210/;
    }

  # leading zeros will be stripped by _from_hex()
  $bx = '0x' . $bx;
  $x-&gt;{value} = $CALC_EMU-&gt;_from_hex( $bx );

  # calculate sign of result
  $x-&gt;{sign} = '+';
  $x-&gt;{sign} = '-' if $sign == 1 &amp;&amp; !$x-&gt;is_zero();

  $x-&gt;bdec() if $sign == 1;

  $x-&gt;round(@r);
  }

sub __emu_bior
  {
  my ($self,$x,$y,$sx,$sy,@r) = @_;

  return $x-&gt;round(@r) if $y-&gt;is_zero();

  my $sign = 0;					# sign of result
  $sign = 1 if ($sx == -1) || ($sy == -1);

  my ($bx,$by);

  if ($sx == -1)				# if x is negative
    {
    # two's complement: inc and flip all &quot;bits&quot; in $bx
    $bx = $x-&gt;binc()-&gt;as_hex();			# -1 =&gt; 0, -2 =&gt; 1, -3 =&gt; 2 etc
    $bx =~ s/-?0x//;
    $bx =~ tr/0123456789abcdef/\x0f\x0e\x0d\x0c\x0b\x0a\x09\x08\x07\x06\x05\x04\x03\x02\x01\x00/;
    }
  else
    {
    $bx = $x-&gt;as_hex();				# get binary representation
    $bx =~ s/-?0x//;
    $bx =~ tr/fedcba9876543210/\x0f\x0e\x0d\x0c\x0b\x0a\x09\x08\x07\x06\x05\x04\x03\x02\x01\x00/;
    }
  if ($sy == -1)				# if y is negative
    {
    # two's complement: inc and flip all &quot;bits&quot; in $by
    $by = $y-&gt;copy()-&gt;binc()-&gt;as_hex();		# -1 =&gt; 0, -2 =&gt; 1, -3 =&gt; 2 etc
    $by =~ s/-?0x//;
    $by =~ tr/0123456789abcdef/\x0f\x0e\x0d\x0c\x0b\x0a\x09\x08\x07\x06\x05\x04\x03\x02\x01\x00/;
    }
  else
    {
    $by = $y-&gt;as_hex();				# get binary representation
    $by =~ s/-?0x//;
    $by =~ tr/fedcba9876543210/\x0f\x0e\x0d\x0c\x0b\x0a\x09\x08\x07\x06\x05\x04\x03\x02\x01\x00/;
    }
  # now we have bit-strings from X and Y, reverse them for padding
  $bx = reverse $bx;
  $by = reverse $by;

  # padd the shorter string
  my $xx = &quot;\x00&quot;; $xx = &quot;\x0f&quot; if $sx == -1;
  my $yy = &quot;\x00&quot;; $yy = &quot;\x0f&quot; if $sy == -1;
  my $diff = CORE::length($bx) - CORE::length($by);
  if ($diff &gt; 0)
    {
    $by .= $yy x $diff;
    }
  elsif ($diff &lt; 0)
    {
    $bx .= $xx x abs($diff);
    }

  # or the strings together
  my $r = $bx | $by;

  # and reverse the result again
  $bx = reverse $r;

  # one of $x or $y was negative, so need to flip bits in the result
  # in both cases (one or two of them negative, or both positive) we need
  # to get the characters back.
  if ($sign == 1)
    {
    $bx =~ tr/\x0f\x0e\x0d\x0c\x0b\x0a\x09\x08\x07\x06\x05\x04\x03\x02\x01\x00/0123456789abcdef/;
    }
  else
    {
    $bx =~ tr/\x0f\x0e\x0d\x0c\x0b\x0a\x09\x08\x07\x06\x05\x04\x03\x02\x01\x00/fedcba9876543210/;
    }

  # leading zeros will be stripped by _from_hex()
  $bx = '0x' . $bx;
  $x-&gt;{value} = $CALC_EMU-&gt;_from_hex( $bx );

  # calculate sign of result
  $x-&gt;{sign} = '+';
  $x-&gt;{sign} = '-' if $sign == 1 &amp;&amp; !$x-&gt;is_zero();

  # if one of X or Y was negative, we need to decrement result
  $x-&gt;bdec() if $sign == 1;

  $x-&gt;round(@r);
  }

sub __emu_bxor
  {
  my ($self,$x,$y,$sx,$sy,@r) = @_;

  return $x-&gt;round(@r) if $y-&gt;is_zero();

  my $sign = 0;					# sign of result
  $sign = 1 if $x-&gt;{sign} ne $y-&gt;{sign};

  my ($bx,$by);

  if ($sx == -1)				# if x is negative
    {
    # two's complement: inc and flip all &quot;bits&quot; in $bx
    $bx = $x-&gt;binc()-&gt;as_hex();			# -1 =&gt; 0, -2 =&gt; 1, -3 =&gt; 2 etc
    $bx =~ s/-?0x//;
    $bx =~ tr/0123456789abcdef/\x0f\x0e\x0d\x0c\x0b\x0a\x09\x08\x07\x06\x05\x04\x03\x02\x01\x00/;
    }
  else
    {
    $bx = $x-&gt;as_hex();				# get binary representation
    $bx =~ s/-?0x//;
    $bx =~ tr/fedcba9876543210/\x0f\x0e\x0d\x0c\x0b\x0a\x09\x08\x07\x06\x05\x04\x03\x02\x01\x00/;
    }
  if ($sy == -1)				# if y is negative
    {
    # two's complement: inc and flip all &quot;bits&quot; in $by
    $by = $y-&gt;copy()-&gt;binc()-&gt;as_hex();		# -1 =&gt; 0, -2 =&gt; 1, -3 =&gt; 2 etc
    $by =~ s/-?0x//;
    $by =~ tr/0123456789abcdef/\x0f\x0e\x0d\x0c\x0b\x0a\x09\x08\x07\x06\x05\x04\x03\x02\x01\x00/;
    }
  else
    {
    $by = $y-&gt;as_hex();				# get binary representation
    $by =~ s/-?0x//;
    $by =~ tr/fedcba9876543210/\x0f\x0e\x0d\x0c\x0b\x0a\x09\x08\x07\x06\x05\x04\x03\x02\x01\x00/;
    }
  # now we have bit-strings from X and Y, reverse them for padding
  $bx = reverse $bx;
  $by = reverse $by;

  # padd the shorter string
  my $xx = &quot;\x00&quot;; $xx = &quot;\x0f&quot; if $sx == -1;
  my $yy = &quot;\x00&quot;; $yy = &quot;\x0f&quot; if $sy == -1;
  my $diff = CORE::length($bx) - CORE::length($by);
  if ($diff &gt; 0)
    {
    $by .= $yy x $diff;
    }
  elsif ($diff &lt; 0)
    {
    $bx .= $xx x abs($diff);
    }

  # xor the strings together
  my $r = $bx ^ $by;

  # and reverse the result again
  $bx = reverse $r;

  # one of $x or $y was negative, so need to flip bits in the result
  # in both cases (one or two of them negative, or both positive) we need
  # to get the characters back.
  if ($sign == 1)
    {
    $bx =~ tr/\x0f\x0e\x0d\x0c\x0b\x0a\x09\x08\x07\x06\x05\x04\x03\x02\x01\x00/0123456789abcdef/;
    }
  else
    {
    $bx =~ tr/\x0f\x0e\x0d\x0c\x0b\x0a\x09\x08\x07\x06\x05\x04\x03\x02\x01\x00/fedcba9876543210/;
    }

  # leading zeros will be stripped by _from_hex()
  $bx = '0x' . $bx;
  $x-&gt;{value} = $CALC_EMU-&gt;_from_hex( $bx );

  # calculate sign of result
  $x-&gt;{sign} = '+';
  $x-&gt;{sign} = '-' if $sx != $sy &amp;&amp; !$x-&gt;is_zero();

  $x-&gt;bdec() if $sign == 1;

  $x-&gt;round(@r);
  }

##############################################################################
##############################################################################

1;

__END__

=pod

=head1 NAME

Math::BigInt::CalcEmu - Emulate low-level math with BigInt code

=head1 SYNOPSIS

	use Math::BigInt;
	use Math::BigInt::CalcEmu;

=head1 DESCRIPTION

Contains routines that emulate low-level math functions in BigInt, e.g.
optional routines the low-level math package does not provide on its own.

Will be loaded on demand and called automatically by BigInt.

Stuff here is really low-priority to optimize, since it is far better to
implement the operation in the low-level math library directly, possible even
using a call to the native lib.

=head1 METHODS

=over

=item __emu_bxor

=item __emu_band

=item __emu_bior

=back

=head1 BUGS

Please report any bugs or feature requests to
C&lt;bug-math-bigint at rt.cpan.org&gt;, or through the web interface at
L&lt;https://rt.cpan.org/Ticket/Create.html?Queue=Math-BigInt&gt;
(requires login).
We will be notified, and then you'll automatically be notified of progress on
your bug as I make changes.

=head1 SUPPORT

You can find documentation for this module with the perldoc command.

    perldoc Math::BigInt::CalcEmu

You can also look for information at:

=over 4

=item * RT: CPAN's request tracker

L&lt;https://rt.cpan.org/Public/Dist/Display.html?Name=Math-BigInt&gt;

=item * AnnoCPAN: Annotated CPAN documentation

L&lt;http://annocpan.org/dist/Math-BigInt&gt;

=item * CPAN Ratings

L&lt;http://cpanratings.perl.org/dist/Math-BigInt&gt;

=item * Search CPAN

L&lt;http://search.cpan.org/dist/Math-BigInt/&gt;

=item * CPAN Testers Matrix

L&lt;http://matrix.cpantesters.org/?dist=Math-BigInt&gt;

=item * The Bignum mailing list

=over 4

=item * Post to mailing list

C&lt;bignum at lists.scsys.co.uk&gt;

=item * View mailing list

L&lt;http://lists.scsys.co.uk/pipermail/bignum/&gt;

=item * Subscribe/Unsubscribe

L&lt;http://lists.scsys.co.uk/cgi-bin/mailman/listinfo/bignum&gt;

=back

=back

=head1 LICENSE

This program is free software; you may redistribute it and/or modify it under
the same terms as Perl itself.

=head1 AUTHORS

(c) Tels http://bloodgate.com 2003, 2004 - based on BigInt code by
Tels from 2001-2003.

=head1 SEE ALSO

L&lt;Math::BigInt&gt;, L&lt;Math::BigFloat&gt;,
L&lt;Math::BigInt::GMP&gt; and L&lt;Math::BigInt::Pari&gt;.

=cut
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fusr%2Fshare%2Fperl5%2Fvendor_perl%2FMath%2FBigInt'>Back to Directory</a>