mirror of
https://github.com/friendica/friendica
synced 2025-02-13 06:24:04 +01:00
3545 lines
119 KiB
PHP
3545 lines
119 KiB
PHP
|
<?php
|
|||
|
/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
|
|||
|
|
|||
|
/**
|
|||
|
* Pure-PHP arbitrary precision integer arithmetic library.
|
|||
|
*
|
|||
|
* Supports base-2, base-10, base-16, and base-256 numbers. Uses the GMP or BCMath extensions, if available,
|
|||
|
* and an internal implementation, otherwise.
|
|||
|
*
|
|||
|
* PHP versions 4 and 5
|
|||
|
*
|
|||
|
* {@internal (all DocBlock comments regarding implementation - such as the one that follows - refer to the
|
|||
|
* {@link MATH_BIGINTEGER_MODE_INTERNAL MATH_BIGINTEGER_MODE_INTERNAL} mode)
|
|||
|
*
|
|||
|
* Math_BigInteger uses base-2**26 to perform operations such as multiplication and division and
|
|||
|
* base-2**52 (ie. two base 2**26 digits) to perform addition and subtraction. Because the largest possible
|
|||
|
* value when multiplying two base-2**26 numbers together is a base-2**52 number, double precision floating
|
|||
|
* point numbers - numbers that should be supported on most hardware and whose significand is 53 bits - are
|
|||
|
* used. As a consequence, bitwise operators such as >> and << cannot be used, nor can the modulo operator %,
|
|||
|
* which only supports integers. Although this fact will slow this library down, the fact that such a high
|
|||
|
* base is being used should more than compensate.
|
|||
|
*
|
|||
|
* When PHP version 6 is officially released, we'll be able to use 64-bit integers. This should, once again,
|
|||
|
* allow bitwise operators, and will increase the maximum possible base to 2**31 (or 2**62 for addition /
|
|||
|
* subtraction).
|
|||
|
*
|
|||
|
* Numbers are stored in {@link http://en.wikipedia.org/wiki/Endianness little endian} format. ie.
|
|||
|
* (new Math_BigInteger(pow(2, 26)))->value = array(0, 1)
|
|||
|
*
|
|||
|
* Useful resources are as follows:
|
|||
|
*
|
|||
|
* - {@link http://www.cacr.math.uwaterloo.ca/hac/about/chap14.pdf Handbook of Applied Cryptography (HAC)}
|
|||
|
* - {@link http://math.libtomcrypt.com/files/tommath.pdf Multi-Precision Math (MPM)}
|
|||
|
* - Java's BigInteger classes. See /j2se/src/share/classes/java/math in jdk-1_5_0-src-jrl.zip
|
|||
|
*
|
|||
|
* Here's an example of how to use this library:
|
|||
|
* <code>
|
|||
|
* <?php
|
|||
|
* include('Math/BigInteger.php');
|
|||
|
*
|
|||
|
* $a = new Math_BigInteger(2);
|
|||
|
* $b = new Math_BigInteger(3);
|
|||
|
*
|
|||
|
* $c = $a->add($b);
|
|||
|
*
|
|||
|
* echo $c->toString(); // outputs 5
|
|||
|
* ?>
|
|||
|
* </code>
|
|||
|
*
|
|||
|
* LICENSE: This library is free software; you can redistribute it and/or
|
|||
|
* modify it under the terms of the GNU Lesser General Public
|
|||
|
* License as published by the Free Software Foundation; either
|
|||
|
* version 2.1 of the License, or (at your option) any later version.
|
|||
|
*
|
|||
|
* This library is distributed in the hope that it will be useful,
|
|||
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|||
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|||
|
* Lesser General Public License for more details.
|
|||
|
*
|
|||
|
* You should have received a copy of the GNU Lesser General Public
|
|||
|
* License along with this library; if not, write to the Free Software
|
|||
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
|
|||
|
* MA 02111-1307 USA
|
|||
|
*
|
|||
|
* @category Math
|
|||
|
* @package Math_BigInteger
|
|||
|
* @author Jim Wigginton <terrafrost@php.net>
|
|||
|
* @copyright MMVI Jim Wigginton
|
|||
|
* @license http://www.gnu.org/licenses/lgpl.txt
|
|||
|
* @version $Id: BigInteger.php,v 1.33 2010/03/22 22:32:03 terrafrost Exp $
|
|||
|
* @link http://pear.php.net/package/Math_BigInteger
|
|||
|
*/
|
|||
|
|
|||
|
/**#@+
|
|||
|
* Reduction constants
|
|||
|
*
|
|||
|
* @access private
|
|||
|
* @see Math_BigInteger::_reduce()
|
|||
|
*/
|
|||
|
/**
|
|||
|
* @see Math_BigInteger::_montgomery()
|
|||
|
* @see Math_BigInteger::_prepMontgomery()
|
|||
|
*/
|
|||
|
define('MATH_BIGINTEGER_MONTGOMERY', 0);
|
|||
|
/**
|
|||
|
* @see Math_BigInteger::_barrett()
|
|||
|
*/
|
|||
|
define('MATH_BIGINTEGER_BARRETT', 1);
|
|||
|
/**
|
|||
|
* @see Math_BigInteger::_mod2()
|
|||
|
*/
|
|||
|
define('MATH_BIGINTEGER_POWEROF2', 2);
|
|||
|
/**
|
|||
|
* @see Math_BigInteger::_remainder()
|
|||
|
*/
|
|||
|
define('MATH_BIGINTEGER_CLASSIC', 3);
|
|||
|
/**
|
|||
|
* @see Math_BigInteger::__clone()
|
|||
|
*/
|
|||
|
define('MATH_BIGINTEGER_NONE', 4);
|
|||
|
/**#@-*/
|
|||
|
|
|||
|
/**#@+
|
|||
|
* Array constants
|
|||
|
*
|
|||
|
* Rather than create a thousands and thousands of new Math_BigInteger objects in repeated function calls to add() and
|
|||
|
* multiply() or whatever, we'll just work directly on arrays, taking them in as parameters and returning them.
|
|||
|
*
|
|||
|
* @access private
|
|||
|
*/
|
|||
|
/**
|
|||
|
* $result[MATH_BIGINTEGER_VALUE] contains the value.
|
|||
|
*/
|
|||
|
define('MATH_BIGINTEGER_VALUE', 0);
|
|||
|
/**
|
|||
|
* $result[MATH_BIGINTEGER_SIGN] contains the sign.
|
|||
|
*/
|
|||
|
define('MATH_BIGINTEGER_SIGN', 1);
|
|||
|
/**#@-*/
|
|||
|
|
|||
|
/**#@+
|
|||
|
* @access private
|
|||
|
* @see Math_BigInteger::_montgomery()
|
|||
|
* @see Math_BigInteger::_barrett()
|
|||
|
*/
|
|||
|
/**
|
|||
|
* Cache constants
|
|||
|
*
|
|||
|
* $cache[MATH_BIGINTEGER_VARIABLE] tells us whether or not the cached data is still valid.
|
|||
|
*/
|
|||
|
define('MATH_BIGINTEGER_VARIABLE', 0);
|
|||
|
/**
|
|||
|
* $cache[MATH_BIGINTEGER_DATA] contains the cached data.
|
|||
|
*/
|
|||
|
define('MATH_BIGINTEGER_DATA', 1);
|
|||
|
/**#@-*/
|
|||
|
|
|||
|
/**#@+
|
|||
|
* Mode constants.
|
|||
|
*
|
|||
|
* @access private
|
|||
|
* @see Math_BigInteger::Math_BigInteger()
|
|||
|
*/
|
|||
|
/**
|
|||
|
* To use the pure-PHP implementation
|
|||
|
*/
|
|||
|
define('MATH_BIGINTEGER_MODE_INTERNAL', 1);
|
|||
|
/**
|
|||
|
* To use the BCMath library
|
|||
|
*
|
|||
|
* (if enabled; otherwise, the internal implementation will be used)
|
|||
|
*/
|
|||
|
define('MATH_BIGINTEGER_MODE_BCMATH', 2);
|
|||
|
/**
|
|||
|
* To use the GMP library
|
|||
|
*
|
|||
|
* (if present; otherwise, either the BCMath or the internal implementation will be used)
|
|||
|
*/
|
|||
|
define('MATH_BIGINTEGER_MODE_GMP', 3);
|
|||
|
/**#@-*/
|
|||
|
|
|||
|
/**
|
|||
|
* The largest digit that may be used in addition / subtraction
|
|||
|
*
|
|||
|
* (we do pow(2, 52) instead of using 4503599627370496, directly, because some PHP installations
|
|||
|
* will truncate 4503599627370496)
|
|||
|
*
|
|||
|
* @access private
|
|||
|
*/
|
|||
|
define('MATH_BIGINTEGER_MAX_DIGIT52', pow(2, 52));
|
|||
|
|
|||
|
/**
|
|||
|
* Karatsuba Cutoff
|
|||
|
*
|
|||
|
* At what point do we switch between Karatsuba multiplication and schoolbook long multiplication?
|
|||
|
*
|
|||
|
* @access private
|
|||
|
*/
|
|||
|
define('MATH_BIGINTEGER_KARATSUBA_CUTOFF', 25);
|
|||
|
|
|||
|
/**
|
|||
|
* Pure-PHP arbitrary precision integer arithmetic library. Supports base-2, base-10, base-16, and base-256
|
|||
|
* numbers.
|
|||
|
*
|
|||
|
* @author Jim Wigginton <terrafrost@php.net>
|
|||
|
* @version 1.0.0RC4
|
|||
|
* @access public
|
|||
|
* @package Math_BigInteger
|
|||
|
*/
|
|||
|
class Math_BigInteger {
|
|||
|
/**
|
|||
|
* Holds the BigInteger's value.
|
|||
|
*
|
|||
|
* @var Array
|
|||
|
* @access private
|
|||
|
*/
|
|||
|
var $value;
|
|||
|
|
|||
|
/**
|
|||
|
* Holds the BigInteger's magnitude.
|
|||
|
*
|
|||
|
* @var Boolean
|
|||
|
* @access private
|
|||
|
*/
|
|||
|
var $is_negative = false;
|
|||
|
|
|||
|
/**
|
|||
|
* Random number generator function
|
|||
|
*
|
|||
|
* @see setRandomGenerator()
|
|||
|
* @access private
|
|||
|
*/
|
|||
|
var $generator = 'mt_rand';
|
|||
|
|
|||
|
/**
|
|||
|
* Precision
|
|||
|
*
|
|||
|
* @see setPrecision()
|
|||
|
* @access private
|
|||
|
*/
|
|||
|
var $precision = -1;
|
|||
|
|
|||
|
/**
|
|||
|
* Precision Bitmask
|
|||
|
*
|
|||
|
* @see setPrecision()
|
|||
|
* @access private
|
|||
|
*/
|
|||
|
var $bitmask = false;
|
|||
|
|
|||
|
/**
|
|||
|
* Mode independant value used for serialization.
|
|||
|
*
|
|||
|
* If the bcmath or gmp extensions are installed $this->value will be a non-serializable resource, hence the need for
|
|||
|
* a variable that'll be serializable regardless of whether or not extensions are being used. Unlike $this->value,
|
|||
|
* however, $this->hex is only calculated when $this->__sleep() is called.
|
|||
|
*
|
|||
|
* @see __sleep()
|
|||
|
* @see __wakeup()
|
|||
|
* @var String
|
|||
|
* @access private
|
|||
|
*/
|
|||
|
var $hex;
|
|||
|
|
|||
|
/**
|
|||
|
* Converts base-2, base-10, base-16, and binary strings (eg. base-256) to BigIntegers.
|
|||
|
*
|
|||
|
* If the second parameter - $base - is negative, then it will be assumed that the number's are encoded using
|
|||
|
* two's compliment. The sole exception to this is -10, which is treated the same as 10 is.
|
|||
|
*
|
|||
|
* Here's an example:
|
|||
|
* <code>
|
|||
|
* <?php
|
|||
|
* include('Math/BigInteger.php');
|
|||
|
*
|
|||
|
* $a = new Math_BigInteger('0x32', 16); // 50 in base-16
|
|||
|
*
|
|||
|
* echo $a->toString(); // outputs 50
|
|||
|
* ?>
|
|||
|
* </code>
|
|||
|
*
|
|||
|
* @param optional $x base-10 number or base-$base number if $base set.
|
|||
|
* @param optional integer $base
|
|||
|
* @return Math_BigInteger
|
|||
|
* @access public
|
|||
|
*/
|
|||
|
function Math_BigInteger($x = 0, $base = 10)
|
|||
|
{
|
|||
|
if ( !defined('MATH_BIGINTEGER_MODE') ) {
|
|||
|
switch (true) {
|
|||
|
case extension_loaded('gmp'):
|
|||
|
define('MATH_BIGINTEGER_MODE', MATH_BIGINTEGER_MODE_GMP);
|
|||
|
break;
|
|||
|
case extension_loaded('bcmath'):
|
|||
|
define('MATH_BIGINTEGER_MODE', MATH_BIGINTEGER_MODE_BCMATH);
|
|||
|
break;
|
|||
|
default:
|
|||
|
define('MATH_BIGINTEGER_MODE', MATH_BIGINTEGER_MODE_INTERNAL);
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
switch ( MATH_BIGINTEGER_MODE ) {
|
|||
|
case MATH_BIGINTEGER_MODE_GMP:
|
|||
|
if (is_resource($x) && get_resource_type($x) == 'GMP integer') {
|
|||
|
$this->value = $x;
|
|||
|
return;
|
|||
|
}
|
|||
|
$this->value = gmp_init(0);
|
|||
|
break;
|
|||
|
case MATH_BIGINTEGER_MODE_BCMATH:
|
|||
|
$this->value = '0';
|
|||
|
break;
|
|||
|
default:
|
|||
|
$this->value = array();
|
|||
|
}
|
|||
|
|
|||
|
if (empty($x)) {
|
|||
|
return;
|
|||
|
}
|
|||
|
|
|||
|
switch ($base) {
|
|||
|
case -256:
|
|||
|
if (ord($x[0]) & 0x80) {
|
|||
|
$x = ~$x;
|
|||
|
$this->is_negative = true;
|
|||
|
}
|
|||
|
case 256:
|
|||
|
switch ( MATH_BIGINTEGER_MODE ) {
|
|||
|
case MATH_BIGINTEGER_MODE_GMP:
|
|||
|
$sign = $this->is_negative ? '-' : '';
|
|||
|
$this->value = gmp_init($sign . '0x' . bin2hex($x));
|
|||
|
break;
|
|||
|
case MATH_BIGINTEGER_MODE_BCMATH:
|
|||
|
// round $len to the nearest 4 (thanks, DavidMJ!)
|
|||
|
$len = (strlen($x) + 3) & 0xFFFFFFFC;
|
|||
|
|
|||
|
$x = str_pad($x, $len, chr(0), STR_PAD_LEFT);
|
|||
|
|
|||
|
for ($i = 0; $i < $len; $i+= 4) {
|
|||
|
$this->value = bcmul($this->value, '4294967296', 0); // 4294967296 == 2**32
|
|||
|
$this->value = bcadd($this->value, 0x1000000 * ord($x[$i]) + ((ord($x[$i + 1]) << 16) | (ord($x[$i + 2]) << 8) | ord($x[$i + 3])), 0);
|
|||
|
}
|
|||
|
|
|||
|
if ($this->is_negative) {
|
|||
|
$this->value = '-' . $this->value;
|
|||
|
}
|
|||
|
|
|||
|
break;
|
|||
|
// converts a base-2**8 (big endian / msb) number to base-2**26 (little endian / lsb)
|
|||
|
default:
|
|||
|
while (strlen($x)) {
|
|||
|
$this->value[] = $this->_bytes2int($this->_base256_rshift($x, 26));
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
if ($this->is_negative) {
|
|||
|
if (MATH_BIGINTEGER_MODE != MATH_BIGINTEGER_MODE_INTERNAL) {
|
|||
|
$this->is_negative = false;
|
|||
|
}
|
|||
|
$temp = $this->add(new Math_BigInteger('-1'));
|
|||
|
$this->value = $temp->value;
|
|||
|
}
|
|||
|
break;
|
|||
|
case 16:
|
|||
|
case -16:
|
|||
|
if ($base > 0 && $x[0] == '-') {
|
|||
|
$this->is_negative = true;
|
|||
|
$x = substr($x, 1);
|
|||
|
}
|
|||
|
|
|||
|
$x = preg_replace('#^(?:0x)?([A-Fa-f0-9]*).*#', '$1', $x);
|
|||
|
|
|||
|
$is_negative = false;
|
|||
|
if ($base < 0 && hexdec($x[0]) >= 8) {
|
|||
|
$this->is_negative = $is_negative = true;
|
|||
|
$x = bin2hex(~pack('H*', $x));
|
|||
|
}
|
|||
|
|
|||
|
switch ( MATH_BIGINTEGER_MODE ) {
|
|||
|
case MATH_BIGINTEGER_MODE_GMP:
|
|||
|
$temp = $this->is_negative ? '-0x' . $x : '0x' . $x;
|
|||
|
$this->value = gmp_init($temp);
|
|||
|
$this->is_negative = false;
|
|||
|
break;
|
|||
|
case MATH_BIGINTEGER_MODE_BCMATH:
|
|||
|
$x = ( strlen($x) & 1 ) ? '0' . $x : $x;
|
|||
|
$temp = new Math_BigInteger(pack('H*', $x), 256);
|
|||
|
$this->value = $this->is_negative ? '-' . $temp->value : $temp->value;
|
|||
|
$this->is_negative = false;
|
|||
|
break;
|
|||
|
default:
|
|||
|
$x = ( strlen($x) & 1 ) ? '0' . $x : $x;
|
|||
|
$temp = new Math_BigInteger(pack('H*', $x), 256);
|
|||
|
$this->value = $temp->value;
|
|||
|
}
|
|||
|
|
|||
|
if ($is_negative) {
|
|||
|
$temp = $this->add(new Math_BigInteger('-1'));
|
|||
|
$this->value = $temp->value;
|
|||
|
}
|
|||
|
break;
|
|||
|
case 10:
|
|||
|
case -10:
|
|||
|
$x = preg_replace('#^(-?[0-9]*).*#', '$1', $x);
|
|||
|
|
|||
|
switch ( MATH_BIGINTEGER_MODE ) {
|
|||
|
case MATH_BIGINTEGER_MODE_GMP:
|
|||
|
$this->value = gmp_init($x);
|
|||
|
break;
|
|||
|
case MATH_BIGINTEGER_MODE_BCMATH:
|
|||
|
// explicitly casting $x to a string is necessary, here, since doing $x[0] on -1 yields different
|
|||
|
// results then doing it on '-1' does (modInverse does $x[0])
|
|||
|
$this->value = (string) $x;
|
|||
|
break;
|
|||
|
default:
|
|||
|
$temp = new Math_BigInteger();
|
|||
|
|
|||
|
// array(10000000) is 10**7 in base-2**26. 10**7 is the closest to 2**26 we can get without passing it.
|
|||
|
$multiplier = new Math_BigInteger();
|
|||
|
$multiplier->value = array(10000000);
|
|||
|
|
|||
|
if ($x[0] == '-') {
|
|||
|
$this->is_negative = true;
|
|||
|
$x = substr($x, 1);
|
|||
|
}
|
|||
|
|
|||
|
$x = str_pad($x, strlen($x) + (6 * strlen($x)) % 7, 0, STR_PAD_LEFT);
|
|||
|
|
|||
|
while (strlen($x)) {
|
|||
|
$temp = $temp->multiply($multiplier);
|
|||
|
$temp = $temp->add(new Math_BigInteger($this->_int2bytes(substr($x, 0, 7)), 256));
|
|||
|
$x = substr($x, 7);
|
|||
|
}
|
|||
|
|
|||
|
$this->value = $temp->value;
|
|||
|
}
|
|||
|
break;
|
|||
|
case 2: // base-2 support originally implemented by Lluis Pamies - thanks!
|
|||
|
case -2:
|
|||
|
if ($base > 0 && $x[0] == '-') {
|
|||
|
$this->is_negative = true;
|
|||
|
$x = substr($x, 1);
|
|||
|
}
|
|||
|
|
|||
|
$x = preg_replace('#^([01]*).*#', '$1', $x);
|
|||
|
$x = str_pad($x, strlen($x) + (3 * strlen($x)) % 4, 0, STR_PAD_LEFT);
|
|||
|
|
|||
|
$str = '0x';
|
|||
|
while (strlen($x)) {
|
|||
|
$part = substr($x, 0, 4);
|
|||
|
$str.= dechex(bindec($part));
|
|||
|
$x = substr($x, 4);
|
|||
|
}
|
|||
|
|
|||
|
if ($this->is_negative) {
|
|||
|
$str = '-' . $str;
|
|||
|
}
|
|||
|
|
|||
|
$temp = new Math_BigInteger($str, 8 * $base); // ie. either -16 or +16
|
|||
|
$this->value = $temp->value;
|
|||
|
$this->is_negative = $temp->is_negative;
|
|||
|
|
|||
|
break;
|
|||
|
default:
|
|||
|
// base not supported, so we'll let $this == 0
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* Converts a BigInteger to a byte string (eg. base-256).
|
|||
|
*
|
|||
|
* Negative numbers are saved as positive numbers, unless $twos_compliment is set to true, at which point, they're
|
|||
|
* saved as two's compliment.
|
|||
|
*
|
|||
|
* Here's an example:
|
|||
|
* <code>
|
|||
|
* <?php
|
|||
|
* include('Math/BigInteger.php');
|
|||
|
*
|
|||
|
* $a = new Math_BigInteger('65');
|
|||
|
*
|
|||
|
* echo $a->toBytes(); // outputs chr(65)
|
|||
|
* ?>
|
|||
|
* </code>
|
|||
|
*
|
|||
|
* @param Boolean $twos_compliment
|
|||
|
* @return String
|
|||
|
* @access public
|
|||
|
* @internal Converts a base-2**26 number to base-2**8
|
|||
|
*/
|
|||
|
function toBytes($twos_compliment = false)
|
|||
|
{
|
|||
|
if ($twos_compliment) {
|
|||
|
$comparison = $this->compare(new Math_BigInteger());
|
|||
|
if ($comparison == 0) {
|
|||
|
return $this->precision > 0 ? str_repeat(chr(0), ($this->precision + 1) >> 3) : '';
|
|||
|
}
|
|||
|
|
|||
|
$temp = $comparison < 0 ? $this->add(new Math_BigInteger(1)) : $this->copy();
|
|||
|
$bytes = $temp->toBytes();
|
|||
|
|
|||
|
if (empty($bytes)) { // eg. if the number we're trying to convert is -1
|
|||
|
$bytes = chr(0);
|
|||
|
}
|
|||
|
|
|||
|
if (ord($bytes[0]) & 0x80) {
|
|||
|
$bytes = chr(0) . $bytes;
|
|||
|
}
|
|||
|
|
|||
|
return $comparison < 0 ? ~$bytes : $bytes;
|
|||
|
}
|
|||
|
|
|||
|
switch ( MATH_BIGINTEGER_MODE ) {
|
|||
|
case MATH_BIGINTEGER_MODE_GMP:
|
|||
|
if (gmp_cmp($this->value, gmp_init(0)) == 0) {
|
|||
|
return $this->precision > 0 ? str_repeat(chr(0), ($this->precision + 1) >> 3) : '';
|
|||
|
}
|
|||
|
|
|||
|
$temp = gmp_strval(gmp_abs($this->value), 16);
|
|||
|
$temp = ( strlen($temp) & 1 ) ? '0' . $temp : $temp;
|
|||
|
$temp = pack('H*', $temp);
|
|||
|
|
|||
|
return $this->precision > 0 ?
|
|||
|
substr(str_pad($temp, $this->precision >> 3, chr(0), STR_PAD_LEFT), -($this->precision >> 3)) :
|
|||
|
ltrim($temp, chr(0));
|
|||
|
case MATH_BIGINTEGER_MODE_BCMATH:
|
|||
|
if ($this->value === '0') {
|
|||
|
return $this->precision > 0 ? str_repeat(chr(0), ($this->precision + 1) >> 3) : '';
|
|||
|
}
|
|||
|
|
|||
|
$value = '';
|
|||
|
$current = $this->value;
|
|||
|
|
|||
|
if ($current[0] == '-') {
|
|||
|
$current = substr($current, 1);
|
|||
|
}
|
|||
|
|
|||
|
while (bccomp($current, '0', 0) > 0) {
|
|||
|
$temp = bcmod($current, '16777216');
|
|||
|
$value = chr($temp >> 16) . chr($temp >> 8) . chr($temp) . $value;
|
|||
|
$current = bcdiv($current, '16777216', 0);
|
|||
|
}
|
|||
|
|
|||
|
return $this->precision > 0 ?
|
|||
|
substr(str_pad($value, $this->precision >> 3, chr(0), STR_PAD_LEFT), -($this->precision >> 3)) :
|
|||
|
ltrim($value, chr(0));
|
|||
|
}
|
|||
|
|
|||
|
if (!count($this->value)) {
|
|||
|
return $this->precision > 0 ? str_repeat(chr(0), ($this->precision + 1) >> 3) : '';
|
|||
|
}
|
|||
|
$result = $this->_int2bytes($this->value[count($this->value) - 1]);
|
|||
|
|
|||
|
$temp = $this->copy();
|
|||
|
|
|||
|
for ($i = count($temp->value) - 2; $i >= 0; --$i) {
|
|||
|
$temp->_base256_lshift($result, 26);
|
|||
|
$result = $result | str_pad($temp->_int2bytes($temp->value[$i]), strlen($result), chr(0), STR_PAD_LEFT);
|
|||
|
}
|
|||
|
|
|||
|
return $this->precision > 0 ?
|
|||
|
str_pad(substr($result, -(($this->precision + 7) >> 3)), ($this->precision + 7) >> 3, chr(0), STR_PAD_LEFT) :
|
|||
|
$result;
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* Converts a BigInteger to a hex string (eg. base-16)).
|
|||
|
*
|
|||
|
* Negative numbers are saved as positive numbers, unless $twos_compliment is set to true, at which point, they're
|
|||
|
* saved as two's compliment.
|
|||
|
*
|
|||
|
* Here's an example:
|
|||
|
* <code>
|
|||
|
* <?php
|
|||
|
* include('Math/BigInteger.php');
|
|||
|
*
|
|||
|
* $a = new Math_BigInteger('65');
|
|||
|
*
|
|||
|
* echo $a->toHex(); // outputs '41'
|
|||
|
* ?>
|
|||
|
* </code>
|
|||
|
*
|
|||
|
* @param Boolean $twos_compliment
|
|||
|
* @return String
|
|||
|
* @access public
|
|||
|
* @internal Converts a base-2**26 number to base-2**8
|
|||
|
*/
|
|||
|
function toHex($twos_compliment = false)
|
|||
|
{
|
|||
|
return bin2hex($this->toBytes($twos_compliment));
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* Converts a BigInteger to a bit string (eg. base-2).
|
|||
|
*
|
|||
|
* Negative numbers are saved as positive numbers, unless $twos_compliment is set to true, at which point, they're
|
|||
|
* saved as two's compliment.
|
|||
|
*
|
|||
|
* Here's an example:
|
|||
|
* <code>
|
|||
|
* <?php
|
|||
|
* include('Math/BigInteger.php');
|
|||
|
*
|
|||
|
* $a = new Math_BigInteger('65');
|
|||
|
*
|
|||
|
* echo $a->toBits(); // outputs '1000001'
|
|||
|
* ?>
|
|||
|
* </code>
|
|||
|
*
|
|||
|
* @param Boolean $twos_compliment
|
|||
|
* @return String
|
|||
|
* @access public
|
|||
|
* @internal Converts a base-2**26 number to base-2**2
|
|||
|
*/
|
|||
|
function toBits($twos_compliment = false)
|
|||
|
{
|
|||
|
$hex = $this->toHex($twos_compliment);
|
|||
|
$bits = '';
|
|||
|
for ($i = 0; $i < strlen($hex); $i+=8) {
|
|||
|
$bits.= str_pad(decbin(hexdec(substr($hex, $i, 8))), 32, '0', STR_PAD_LEFT);
|
|||
|
}
|
|||
|
return $this->precision > 0 ? substr($bits, -$this->precision) : ltrim($bits, '0');
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* Converts a BigInteger to a base-10 number.
|
|||
|
*
|
|||
|
* Here's an example:
|
|||
|
* <code>
|
|||
|
* <?php
|
|||
|
* include('Math/BigInteger.php');
|
|||
|
*
|
|||
|
* $a = new Math_BigInteger('50');
|
|||
|
*
|
|||
|
* echo $a->toString(); // outputs 50
|
|||
|
* ?>
|
|||
|
* </code>
|
|||
|
*
|
|||
|
* @return String
|
|||
|
* @access public
|
|||
|
* @internal Converts a base-2**26 number to base-10**7 (which is pretty much base-10)
|
|||
|
*/
|
|||
|
function toString()
|
|||
|
{
|
|||
|
switch ( MATH_BIGINTEGER_MODE ) {
|
|||
|
case MATH_BIGINTEGER_MODE_GMP:
|
|||
|
return gmp_strval($this->value);
|
|||
|
case MATH_BIGINTEGER_MODE_BCMATH:
|
|||
|
if ($this->value === '0') {
|
|||
|
return '0';
|
|||
|
}
|
|||
|
|
|||
|
return ltrim($this->value, '0');
|
|||
|
}
|
|||
|
|
|||
|
if (!count($this->value)) {
|
|||
|
return '0';
|
|||
|
}
|
|||
|
|
|||
|
$temp = $this->copy();
|
|||
|
$temp->is_negative = false;
|
|||
|
|
|||
|
$divisor = new Math_BigInteger();
|
|||
|
$divisor->value = array(10000000); // eg. 10**7
|
|||
|
$result = '';
|
|||
|
while (count($temp->value)) {
|
|||
|
list($temp, $mod) = $temp->divide($divisor);
|
|||
|
$result = str_pad(isset($mod->value[0]) ? $mod->value[0] : '', 7, '0', STR_PAD_LEFT) . $result;
|
|||
|
}
|
|||
|
$result = ltrim($result, '0');
|
|||
|
if (empty($result)) {
|
|||
|
$result = '0';
|
|||
|
}
|
|||
|
|
|||
|
if ($this->is_negative) {
|
|||
|
$result = '-' . $result;
|
|||
|
}
|
|||
|
|
|||
|
return $result;
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* Copy an object
|
|||
|
*
|
|||
|
* PHP5 passes objects by reference while PHP4 passes by value. As such, we need a function to guarantee
|
|||
|
* that all objects are passed by value, when appropriate. More information can be found here:
|
|||
|
*
|
|||
|
* {@link http://php.net/language.oop5.basic#51624}
|
|||
|
*
|
|||
|
* @access public
|
|||
|
* @see __clone()
|
|||
|
* @return Math_BigInteger
|
|||
|
*/
|
|||
|
function copy()
|
|||
|
{
|
|||
|
$temp = new Math_BigInteger();
|
|||
|
$temp->value = $this->value;
|
|||
|
$temp->is_negative = $this->is_negative;
|
|||
|
$temp->generator = $this->generator;
|
|||
|
$temp->precision = $this->precision;
|
|||
|
$temp->bitmask = $this->bitmask;
|
|||
|
return $temp;
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* __toString() magic method
|
|||
|
*
|
|||
|
* Will be called, automatically, if you're supporting just PHP5. If you're supporting PHP4, you'll need to call
|
|||
|
* toString().
|
|||
|
*
|
|||
|
* @access public
|
|||
|
* @internal Implemented per a suggestion by Techie-Michael - thanks!
|
|||
|
*/
|
|||
|
function __toString()
|
|||
|
{
|
|||
|
return $this->toString();
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* __clone() magic method
|
|||
|
*
|
|||
|
* Although you can call Math_BigInteger::__toString() directly in PHP5, you cannot call Math_BigInteger::__clone()
|
|||
|
* directly in PHP5. You can in PHP4 since it's not a magic method, but in PHP5, you have to call it by using the PHP5
|
|||
|
* only syntax of $y = clone $x. As such, if you're trying to write an application that works on both PHP4 and PHP5,
|
|||
|
* call Math_BigInteger::copy(), instead.
|
|||
|
*
|
|||
|
* @access public
|
|||
|
* @see copy()
|
|||
|
* @return Math_BigInteger
|
|||
|
*/
|
|||
|
function __clone()
|
|||
|
{
|
|||
|
return $this->copy();
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* __sleep() magic method
|
|||
|
*
|
|||
|
* Will be called, automatically, when serialize() is called on a Math_BigInteger object.
|
|||
|
*
|
|||
|
* @see __wakeup()
|
|||
|
* @access public
|
|||
|
*/
|
|||
|
function __sleep()
|
|||
|
{
|
|||
|
$this->hex = $this->toHex(true);
|
|||
|
$vars = array('hex');
|
|||
|
if ($this->generator != 'mt_rand') {
|
|||
|
$vars[] = 'generator';
|
|||
|
}
|
|||
|
if ($this->precision > 0) {
|
|||
|
$vars[] = 'precision';
|
|||
|
}
|
|||
|
return $vars;
|
|||
|
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* __wakeup() magic method
|
|||
|
*
|
|||
|
* Will be called, automatically, when unserialize() is called on a Math_BigInteger object.
|
|||
|
*
|
|||
|
* @see __sleep()
|
|||
|
* @access public
|
|||
|
*/
|
|||
|
function __wakeup()
|
|||
|
{
|
|||
|
$temp = new Math_BigInteger($this->hex, -16);
|
|||
|
$this->value = $temp->value;
|
|||
|
$this->is_negative = $temp->is_negative;
|
|||
|
$this->setRandomGenerator($this->generator);
|
|||
|
if ($this->precision > 0) {
|
|||
|
// recalculate $this->bitmask
|
|||
|
$this->setPrecision($this->precision);
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* Adds two BigIntegers.
|
|||
|
*
|
|||
|
* Here's an example:
|
|||
|
* <code>
|
|||
|
* <?php
|
|||
|
* include('Math/BigInteger.php');
|
|||
|
*
|
|||
|
* $a = new Math_BigInteger('10');
|
|||
|
* $b = new Math_BigInteger('20');
|
|||
|
*
|
|||
|
* $c = $a->add($b);
|
|||
|
*
|
|||
|
* echo $c->toString(); // outputs 30
|
|||
|
* ?>
|
|||
|
* </code>
|
|||
|
*
|
|||
|
* @param Math_BigInteger $y
|
|||
|
* @return Math_BigInteger
|
|||
|
* @access public
|
|||
|
* @internal Performs base-2**52 addition
|
|||
|
*/
|
|||
|
function add($y)
|
|||
|
{
|
|||
|
switch ( MATH_BIGINTEGER_MODE ) {
|
|||
|
case MATH_BIGINTEGER_MODE_GMP:
|
|||
|
$temp = new Math_BigInteger();
|
|||
|
$temp->value = gmp_add($this->value, $y->value);
|
|||
|
|
|||
|
return $this->_normalize($temp);
|
|||
|
case MATH_BIGINTEGER_MODE_BCMATH:
|
|||
|
$temp = new Math_BigInteger();
|
|||
|
$temp->value = bcadd($this->value, $y->value, 0);
|
|||
|
|
|||
|
return $this->_normalize($temp);
|
|||
|
}
|
|||
|
|
|||
|
$temp = $this->_add($this->value, $this->is_negative, $y->value, $y->is_negative);
|
|||
|
|
|||
|
$result = new Math_BigInteger();
|
|||
|
$result->value = $temp[MATH_BIGINTEGER_VALUE];
|
|||
|
$result->is_negative = $temp[MATH_BIGINTEGER_SIGN];
|
|||
|
|
|||
|
return $this->_normalize($result);
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* Performs addition.
|
|||
|
*
|
|||
|
* @param Array $x_value
|
|||
|
* @param Boolean $x_negative
|
|||
|
* @param Array $y_value
|
|||
|
* @param Boolean $y_negative
|
|||
|
* @return Array
|
|||
|
* @access private
|
|||
|
*/
|
|||
|
function _add($x_value, $x_negative, $y_value, $y_negative)
|
|||
|
{
|
|||
|
$x_size = count($x_value);
|
|||
|
$y_size = count($y_value);
|
|||
|
|
|||
|
if ($x_size == 0) {
|
|||
|
return array(
|
|||
|
MATH_BIGINTEGER_VALUE => $y_value,
|
|||
|
MATH_BIGINTEGER_SIGN => $y_negative
|
|||
|
);
|
|||
|
} else if ($y_size == 0) {
|
|||
|
return array(
|
|||
|
MATH_BIGINTEGER_VALUE => $x_value,
|
|||
|
MATH_BIGINTEGER_SIGN => $x_negative
|
|||
|
);
|
|||
|
}
|
|||
|
|
|||
|
// subtract, if appropriate
|
|||
|
if ( $x_negative != $y_negative ) {
|
|||
|
if ( $x_value == $y_value ) {
|
|||
|
return array(
|
|||
|
MATH_BIGINTEGER_VALUE => array(),
|
|||
|
MATH_BIGINTEGER_SIGN => false
|
|||
|
);
|
|||
|
}
|
|||
|
|
|||
|
$temp = $this->_subtract($x_value, false, $y_value, false);
|
|||
|
$temp[MATH_BIGINTEGER_SIGN] = $this->_compare($x_value, false, $y_value, false) > 0 ?
|
|||
|
$x_negative : $y_negative;
|
|||
|
|
|||
|
return $temp;
|
|||
|
}
|
|||
|
|
|||
|
if ($x_size < $y_size) {
|
|||
|
$size = $x_size;
|
|||
|
$value = $y_value;
|
|||
|
} else {
|
|||
|
$size = $y_size;
|
|||
|
$value = $x_value;
|
|||
|
}
|
|||
|
|
|||
|
$value[] = 0; // just in case the carry adds an extra digit
|
|||
|
|
|||
|
$carry = 0;
|
|||
|
for ($i = 0, $j = 1; $j < $size; $i+=2, $j+=2) {
|
|||
|
$sum = $x_value[$j] * 0x4000000 + $x_value[$i] + $y_value[$j] * 0x4000000 + $y_value[$i] + $carry;
|
|||
|
$carry = $sum >= MATH_BIGINTEGER_MAX_DIGIT52; // eg. floor($sum / 2**52); only possible values (in any base) are 0 and 1
|
|||
|
$sum = $carry ? $sum - MATH_BIGINTEGER_MAX_DIGIT52 : $sum;
|
|||
|
|
|||
|
$temp = (int) ($sum / 0x4000000);
|
|||
|
|
|||
|
$value[$i] = (int) ($sum - 0x4000000 * $temp); // eg. a faster alternative to fmod($sum, 0x4000000)
|
|||
|
$value[$j] = $temp;
|
|||
|
}
|
|||
|
|
|||
|
if ($j == $size) { // ie. if $y_size is odd
|
|||
|
$sum = $x_value[$i] + $y_value[$i] + $carry;
|
|||
|
$carry = $sum >= 0x4000000;
|
|||
|
$value[$i] = $carry ? $sum - 0x4000000 : $sum;
|
|||
|
++$i; // ie. let $i = $j since we've just done $value[$i]
|
|||
|
}
|
|||
|
|
|||
|
if ($carry) {
|
|||
|
for (; $value[$i] == 0x3FFFFFF; ++$i) {
|
|||
|
$value[$i] = 0;
|
|||
|
}
|
|||
|
++$value[$i];
|
|||
|
}
|
|||
|
|
|||
|
return array(
|
|||
|
MATH_BIGINTEGER_VALUE => $this->_trim($value),
|
|||
|
MATH_BIGINTEGER_SIGN => $x_negative
|
|||
|
);
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* Subtracts two BigIntegers.
|
|||
|
*
|
|||
|
* Here's an example:
|
|||
|
* <code>
|
|||
|
* <?php
|
|||
|
* include('Math/BigInteger.php');
|
|||
|
*
|
|||
|
* $a = new Math_BigInteger('10');
|
|||
|
* $b = new Math_BigInteger('20');
|
|||
|
*
|
|||
|
* $c = $a->subtract($b);
|
|||
|
*
|
|||
|
* echo $c->toString(); // outputs -10
|
|||
|
* ?>
|
|||
|
* </code>
|
|||
|
*
|
|||
|
* @param Math_BigInteger $y
|
|||
|
* @return Math_BigInteger
|
|||
|
* @access public
|
|||
|
* @internal Performs base-2**52 subtraction
|
|||
|
*/
|
|||
|
function subtract($y)
|
|||
|
{
|
|||
|
switch ( MATH_BIGINTEGER_MODE ) {
|
|||
|
case MATH_BIGINTEGER_MODE_GMP:
|
|||
|
$temp = new Math_BigInteger();
|
|||
|
$temp->value = gmp_sub($this->value, $y->value);
|
|||
|
|
|||
|
return $this->_normalize($temp);
|
|||
|
case MATH_BIGINTEGER_MODE_BCMATH:
|
|||
|
$temp = new Math_BigInteger();
|
|||
|
$temp->value = bcsub($this->value, $y->value, 0);
|
|||
|
|
|||
|
return $this->_normalize($temp);
|
|||
|
}
|
|||
|
|
|||
|
$temp = $this->_subtract($this->value, $this->is_negative, $y->value, $y->is_negative);
|
|||
|
|
|||
|
$result = new Math_BigInteger();
|
|||
|
$result->value = $temp[MATH_BIGINTEGER_VALUE];
|
|||
|
$result->is_negative = $temp[MATH_BIGINTEGER_SIGN];
|
|||
|
|
|||
|
return $this->_normalize($result);
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* Performs subtraction.
|
|||
|
*
|
|||
|
* @param Array $x_value
|
|||
|
* @param Boolean $x_negative
|
|||
|
* @param Array $y_value
|
|||
|
* @param Boolean $y_negative
|
|||
|
* @return Array
|
|||
|
* @access private
|
|||
|
*/
|
|||
|
function _subtract($x_value, $x_negative, $y_value, $y_negative)
|
|||
|
{
|
|||
|
$x_size = count($x_value);
|
|||
|
$y_size = count($y_value);
|
|||
|
|
|||
|
if ($x_size == 0) {
|
|||
|
return array(
|
|||
|
MATH_BIGINTEGER_VALUE => $y_value,
|
|||
|
MATH_BIGINTEGER_SIGN => !$y_negative
|
|||
|
);
|
|||
|
} else if ($y_size == 0) {
|
|||
|
return array(
|
|||
|
MATH_BIGINTEGER_VALUE => $x_value,
|
|||
|
MATH_BIGINTEGER_SIGN => $x_negative
|
|||
|
);
|
|||
|
}
|
|||
|
|
|||
|
// add, if appropriate (ie. -$x - +$y or +$x - -$y)
|
|||
|
if ( $x_negative != $y_negative ) {
|
|||
|
$temp = $this->_add($x_value, false, $y_value, false);
|
|||
|
$temp[MATH_BIGINTEGER_SIGN] = $x_negative;
|
|||
|
|
|||
|
return $temp;
|
|||
|
}
|
|||
|
|
|||
|
$diff = $this->_compare($x_value, $x_negative, $y_value, $y_negative);
|
|||
|
|
|||
|
if ( !$diff ) {
|
|||
|
return array(
|
|||
|
MATH_BIGINTEGER_VALUE => array(),
|
|||
|
MATH_BIGINTEGER_SIGN => false
|
|||
|
);
|
|||
|
}
|
|||
|
|
|||
|
// switch $x and $y around, if appropriate.
|
|||
|
if ( (!$x_negative && $diff < 0) || ($x_negative && $diff > 0) ) {
|
|||
|
$temp = $x_value;
|
|||
|
$x_value = $y_value;
|
|||
|
$y_value = $temp;
|
|||
|
|
|||
|
$x_negative = !$x_negative;
|
|||
|
|
|||
|
$x_size = count($x_value);
|
|||
|
$y_size = count($y_value);
|
|||
|
}
|
|||
|
|
|||
|
// at this point, $x_value should be at least as big as - if not bigger than - $y_value
|
|||
|
|
|||
|
$carry = 0;
|
|||
|
for ($i = 0, $j = 1; $j < $y_size; $i+=2, $j+=2) {
|
|||
|
$sum = $x_value[$j] * 0x4000000 + $x_value[$i] - $y_value[$j] * 0x4000000 - $y_value[$i] - $carry;
|
|||
|
$carry = $sum < 0; // eg. floor($sum / 2**52); only possible values (in any base) are 0 and 1
|
|||
|
$sum = $carry ? $sum + MATH_BIGINTEGER_MAX_DIGIT52 : $sum;
|
|||
|
|
|||
|
$temp = (int) ($sum / 0x4000000);
|
|||
|
|
|||
|
$x_value[$i] = (int) ($sum - 0x4000000 * $temp);
|
|||
|
$x_value[$j] = $temp;
|
|||
|
}
|
|||
|
|
|||
|
if ($j == $y_size) { // ie. if $y_size is odd
|
|||
|
$sum = $x_value[$i] - $y_value[$i] - $carry;
|
|||
|
$carry = $sum < 0;
|
|||
|
$x_value[$i] = $carry ? $sum + 0x4000000 : $sum;
|
|||
|
++$i;
|
|||
|
}
|
|||
|
|
|||
|
if ($carry) {
|
|||
|
for (; !$x_value[$i]; ++$i) {
|
|||
|
$x_value[$i] = 0x3FFFFFF;
|
|||
|
}
|
|||
|
--$x_value[$i];
|
|||
|
}
|
|||
|
|
|||
|
return array(
|
|||
|
MATH_BIGINTEGER_VALUE => $this->_trim($x_value),
|
|||
|
MATH_BIGINTEGER_SIGN => $x_negative
|
|||
|
);
|
|||
|
}
|
|||
|
|
|||
|
/**
|
|||
|
* Multiplies two BigIntegers
|
|||
|
*
|
|||
|
* Here's an example:
|
|||
|
* <code>
|
|||
|
* <?php
|
|||
|
* include('Math/BigInteger.php');
|
|||
|
*
|
|||
|
* $a = new Math_BigInteger('10');
|
|||
|
* $b = new Math_BigInteger('20');
|
|||
|
*
|
|||
|
* $c = $a->multiply($b);
|
|||
|
*
|
|||
|
* echo $c->toString(); // outputs 200
|
|||
|
* ?>
|
|||
|
* </code>
|
|||
|
*
|
|||
|
* @param Math_BigInteger $x
|
|||
|
* @return Math_BigInteger
|
|||
|
* @access public
|
|||
|
*/
|
|||
|
function multiply($x)
|
|||
|
{
|
|||
|
switch ( MATH_BIGINTEGER_MODE ) {
|
|||
|
case MATH_BIGINTEGER_MODE_GMP:
|
|||
|
$temp = new Math_BigInteger();
|
|||
|