octoleo/phpseclib
1
0
Fork 0
mirror of https://github.com/phpseclib/phpseclib.git synced 2024-11-09 15:20:58 +00:00
Code Issues Packages Projects Releases Wiki Activity

Replace new Math_BigInteger with new static.

Browse Source
This commit is contained in:
Andreas Fischer 2014-06-02 19:33:55 +02:00
parent 740422c65f
commit a011596578
1 changed files with 105 additions and 105 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

210
phpseclib/Math/BigInteger.php
View File

@ -384,7 +384,7 @@ class BigInteger
if (MATH_BIGINTEGER_MODE != MATH_BIGINTEGER_MODE_INTERNAL) {
$this->is_negative = false;
}
$temp = $this->add(new Math_BigInteger('-1'));
$temp = $this->add(new static('-1'));
$this->value = $temp->value;
}
break;
@ -411,18 +411,18 @@ class BigInteger
break;
case MATH_BIGINTEGER_MODE_BCMATH:
$x = ( strlen($x) & 1 ) ? '0' . $x : $x;
$temp = new Math_BigInteger(pack('H*', $x), 256);
$temp = new static(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);
$temp = new static(pack('H*', $x), 256);
$this->value = $temp->value;
}
if ($is_negative) {
$temp = $this->add(new Math_BigInteger('-1'));
$temp = $this->add(new static('-1'));
$this->value = $temp->value;
}
break;
@ -443,9 +443,9 @@ class BigInteger
$this->value = $x === '-' ? '0' : (string) $x;
break;
default:
$temp = new Math_BigInteger();
$temp = new static();
$multiplier = new Math_BigInteger();
$multiplier = new static();
$multiplier->value = array(MATH_BIGINTEGER_MAX10);
if ($x[0] == '-') {
@ -456,7 +456,7 @@ class BigInteger
$x = str_pad($x, strlen($x) + ((MATH_BIGINTEGER_MAX10_LEN - 1) * strlen($x)) % MATH_BIGINTEGER_MAX10_LEN, 0, STR_PAD_LEFT);
while (strlen($x)) {
$temp = $temp->multiply($multiplier);
$temp = $temp->add(new Math_BigInteger($this->_int2bytes(substr($x, 0, MATH_BIGINTEGER_MAX10_LEN)), 256));
$temp = $temp->add(new static($this->_int2bytes(substr($x, 0, MATH_BIGINTEGER_MAX10_LEN)), 256));
$x = substr($x, MATH_BIGINTEGER_MAX10_LEN);
}
@ -484,7 +484,7 @@ class BigInteger
$str = '-' . $str;
}
$temp = new Math_BigInteger($str, 8 * $base); // ie. either -16 or +16
$temp = new static($str, 8 * $base); // ie. either -16 or +16
$this->value = $temp->value;
$this->is_negative = $temp->is_negative;
@ -517,12 +517,12 @@ class BigInteger
function toBytes($twos_compliment = false)
{
if ($twos_compliment) {
$comparison = $this->compare(new Math_BigInteger());
$comparison = $this->compare(new static());
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();
$temp = $comparison < 0 ? $this->add(new static(1)) : $this->copy();
$bytes = $temp->toBytes();
if (empty($bytes)) { // eg. if the number we're trying to convert is -1
@ -646,7 +646,7 @@ class BigInteger
}
$result = $this->precision > 0 ? substr($bits, -$this->precision) : ltrim($bits, '0');
if ($twos_compliment && $this->compare(new Math_BigInteger()) > 0 && $this->precision <= 0) {
if ($twos_compliment && $this->compare(new static()) > 0 && $this->precision <= 0) {
return '0' . $result;
}
@ -689,7 +689,7 @@ class BigInteger
$temp = $this->copy();
$temp->is_negative = false;
$divisor = new Math_BigInteger();
$divisor = new static();
$divisor->value = array(MATH_BIGINTEGER_MAX10);
$result = '';
while (count($temp->value)) {
@ -722,7 +722,7 @@ class BigInteger
*/
function copy()
{
$temp = new Math_BigInteger();
$temp = new static();
$temp->value = $this->value;
$temp->is_negative = $this->is_negative;
$temp->generator = $this->generator;
@ -794,7 +794,7 @@ class BigInteger
*/
function __wakeup()
{
$temp = new Math_BigInteger($this->hex, -16);
$temp = new static($this->hex, -16);
$this->value = $temp->value;
$this->is_negative = $temp->is_negative;
if ($this->precision > 0) {
@ -827,12 +827,12 @@ class BigInteger
{
switch ( MATH_BIGINTEGER_MODE ) {
case MATH_BIGINTEGER_MODE_GMP:
$temp = new Math_BigInteger();
$temp = new static();
$temp->value = gmp_add($this->value, $y->value);
return $this->_normalize($temp);
case MATH_BIGINTEGER_MODE_BCMATH:
$temp = new Math_BigInteger();
$temp = new static();
$temp->value = bcadd($this->value, $y->value, 0);
return $this->_normalize($temp);
@ -840,7 +840,7 @@ class BigInteger
$temp = $this->_add($this->value, $this->is_negative, $y->value, $y->is_negative);
$result = new Math_BigInteger();
$result = new static();
$result->value = $temp[MATH_BIGINTEGER_VALUE];
$result->is_negative = $temp[MATH_BIGINTEGER_SIGN];
@ -956,12 +956,12 @@ class BigInteger
{
switch ( MATH_BIGINTEGER_MODE ) {
case MATH_BIGINTEGER_MODE_GMP:
$temp = new Math_BigInteger();
$temp = new static();
$temp->value = gmp_sub($this->value, $y->value);
return $this->_normalize($temp);
case MATH_BIGINTEGER_MODE_BCMATH:
$temp = new Math_BigInteger();
$temp = new static();
$temp->value = bcsub($this->value, $y->value, 0);
return $this->_normalize($temp);
@ -969,7 +969,7 @@ class BigInteger
$temp = $this->_subtract($this->value, $this->is_negative, $y->value, $y->is_negative);
$result = new Math_BigInteger();
$result = new static();
$result->value = $temp[MATH_BIGINTEGER_VALUE];
$result->is_negative = $temp[MATH_BIGINTEGER_SIGN];
@ -1089,12 +1089,12 @@ class BigInteger
{
switch ( MATH_BIGINTEGER_MODE ) {
case MATH_BIGINTEGER_MODE_GMP:
$temp = new Math_BigInteger();
$temp = new static();
$temp->value = gmp_mul($this->value, $x->value);
return $this->_normalize($temp);
case MATH_BIGINTEGER_MODE_BCMATH:
$temp = new Math_BigInteger();
$temp = new static();
$temp->value = bcmul($this->value, $x->value, 0);
return $this->_normalize($temp);
@ -1102,7 +1102,7 @@ class BigInteger
$temp = $this->_multiply($this->value, $this->is_negative, $x->value, $x->is_negative);
$product = new Math_BigInteger();
$product = new static();
$product->value = $temp[MATH_BIGINTEGER_VALUE];
$product->is_negative = $temp[MATH_BIGINTEGER_SIGN];
@ -1374,8 +1374,8 @@ class BigInteger
{
switch ( MATH_BIGINTEGER_MODE ) {
case MATH_BIGINTEGER_MODE_GMP:
$quotient = new Math_BigInteger();
$remainder = new Math_BigInteger();
$quotient = new static();
$remainder = new static();
list($quotient->value, $remainder->value) = gmp_div_qr($this->value, $y->value);
@ -1385,8 +1385,8 @@ class BigInteger
return array($this->_normalize($quotient), $this->_normalize($remainder));
case MATH_BIGINTEGER_MODE_BCMATH:
$quotient = new Math_BigInteger();
$remainder = new Math_BigInteger();
$quotient = new static();
$remainder = new static();
$quotient->value = bcdiv($this->value, $y->value, 0);
$remainder->value = bcmod($this->value, $y->value);
@ -1400,8 +1400,8 @@ class BigInteger
if (count($y->value) == 1) {
list($q, $r) = $this->_divide_digit($this->value, $y->value[0]);
$quotient = new Math_BigInteger();
$remainder = new Math_BigInteger();
$quotient = new static();
$remainder = new static();
$quotient->value = $q;
$remainder->value = array($r);
$quotient->is_negative = $this->is_negative != $y->is_negative;
@ -1410,7 +1410,7 @@ class BigInteger
static $zero;
if ( !isset($zero) ) {
$zero = new Math_BigInteger();
$zero = new static();
}
$x = $this->copy();
@ -1424,10 +1424,10 @@ class BigInteger
$diff = $x->compare($y);
if ( !$diff ) {
$temp = new Math_BigInteger();
$temp = new static();
$temp->value = array(1);
$temp->is_negative = $x_sign != $y_sign;
return array($this->_normalize($temp), $this->_normalize(new Math_BigInteger()));
return array($this->_normalize($temp), $this->_normalize(new static()));
}
if ( $diff < 0 ) {
@ -1435,7 +1435,7 @@ class BigInteger
if ( $x_sign ) {
$x = $y->subtract($x);
}
return array($this->_normalize(new Math_BigInteger()), $this->_normalize($x));
return array($this->_normalize(new static()), $this->_normalize($x));
}
// normalize $x and $y as described in HAC 14.23 / 14.24
@ -1450,15 +1450,15 @@ class BigInteger
$x_max = count($x->value) - 1;
$y_max = count($y->value) - 1;
$quotient = new Math_BigInteger();
$quotient = new static();
$quotient_value = &$quotient->value;
$quotient_value = $this->_array_repeat(0, $x_max - $y_max + 1);
static $temp, $lhs, $rhs;
if (!isset($temp)) {
$temp = new Math_BigInteger();
$lhs = new Math_BigInteger();
$rhs = new Math_BigInteger();
$temp = new static();
$lhs = new static();
$rhs = new static();
}
$temp_value = &$temp->value;
$rhs_value = &$rhs->value;
@ -1609,7 +1609,7 @@ class BigInteger
{
$n = $this->bitmask !== false && $this->bitmask->compare($n) < 0 ? $this->bitmask : $n->abs();
if ($e->compare(new Math_BigInteger()) < 0) {
if ($e->compare(new static()) < 0) {
$e = $e->abs();
$temp = $this->modInverse($n);
@ -1621,13 +1621,13 @@ class BigInteger
}
if ( MATH_BIGINTEGER_MODE == MATH_BIGINTEGER_MODE_GMP ) {
$temp = new Math_BigInteger();
$temp = new static();
$temp->value = gmp_powm($this->value, $e->value, $n->value);
return $this->_normalize($temp);
}
if ($this->compare(new Math_BigInteger()) < 0 || $this->compare($n) > 0) {
if ($this->compare(new static()) < 0 || $this->compare($n) > 0) {
list(, $temp) = $this->divide($n);
return $temp->modPow($e, $n);
}
@ -1663,19 +1663,19 @@ class BigInteger
$plaintext = str_pad($this->toBytes(), strlen($n->toBytes(true)) - 1, "\0", STR_PAD_LEFT);
if (openssl_public_encrypt($plaintext, $result, $RSAPublicKey, OPENSSL_NO_PADDING)) {
return new Math_BigInteger($result, 256);
return new static($result, 256);
}
}
if ( MATH_BIGINTEGER_MODE == MATH_BIGINTEGER_MODE_BCMATH ) {
$temp = new Math_BigInteger();
$temp = new static();
$temp->value = bcpowmod($this->value, $e->value, $n->value, 0);
return $this->_normalize($temp);
}
if ( empty($e->value) ) {
$temp = new Math_BigInteger();
$temp = new static();
$temp->value = array(1);
return $this->_normalize($temp);
}
@ -1686,7 +1686,7 @@ class BigInteger
}
if ( $e->value == array(2) ) {
$temp = new Math_BigInteger();
$temp = new static();
$temp->value = $this->_square($this->value);
list(, $temp) = $temp->divide($n);
return $this->_normalize($temp);
@ -1718,11 +1718,11 @@ class BigInteger
$mod1 = $n->copy();
$mod1->_rshift($j);
$mod2 = new Math_BigInteger();
$mod2 = new static();
$mod2->value = array(1);
$mod2->_lshift($j);
$part1 = ( $mod1->value != array(1) ) ? $this->_slidingWindow($e, $mod1, MATH_BIGINTEGER_MONTGOMERY) : new Math_BigInteger();
$part1 = ( $mod1->value != array(1) ) ? $this->_slidingWindow($e, $mod1, MATH_BIGINTEGER_MONTGOMERY) : new static();
$part2 = $this->_slidingWindow($e, $mod2, MATH_BIGINTEGER_POWEROF2);
$y1 = $mod2->modInverse($mod1);
@ -1826,7 +1826,7 @@ class BigInteger
}
}
$temp = new Math_BigInteger();
$temp = new static();
$temp->value = $this->_reduce($result, $n_value, $mode);
return $temp;
@ -1852,15 +1852,15 @@ class BigInteger
case MATH_BIGINTEGER_BARRETT:
return $this->_barrett($x, $n);
case MATH_BIGINTEGER_POWEROF2:
$lhs = new Math_BigInteger();
$lhs = new static();
$lhs->value = $x;
$rhs = new Math_BigInteger();
$rhs = new static();
$rhs->value = $n;
return $x->_mod2($n);
case MATH_BIGINTEGER_CLASSIC:
$lhs = new Math_BigInteger();
$lhs = new static();
$lhs->value = $x;
$rhs = new Math_BigInteger();
$rhs = new static();
$rhs->value = $n;
list(, $temp) = $lhs->divide($rhs);
return $temp->value;
@ -1940,7 +1940,7 @@ class BigInteger
*/
function _mod2($n)
{
$temp = new Math_BigInteger();
$temp = new static();
$temp->value = array(1);
return $this->bitwise_and($n->subtract($temp));
}
@ -1980,8 +1980,8 @@ class BigInteger
// if ($this->_compare($n, $this->_square($m)) >= 0) {
if (count($n) > 2 * $m_length) {
$lhs = new Math_BigInteger();
$rhs = new Math_BigInteger();
$lhs = new static();
$rhs = new static();
$lhs->value = $n;
$rhs->value = $m;
list(, $temp) = $lhs->divide($rhs);
@ -1999,11 +1999,11 @@ class BigInteger
$key = count($cache[MATH_BIGINTEGER_VARIABLE]);
$cache[MATH_BIGINTEGER_VARIABLE][] = $m;
$lhs = new Math_BigInteger();
$lhs = new static();
$lhs_value = &$lhs->value;
$lhs_value = $this->_array_repeat(0, $m_length + ($m_length >> 1));
$lhs_value[] = 1;
$rhs = new Math_BigInteger();
$rhs = new static();
$rhs->value = $m;
list($u, $m1) = $lhs->divide($rhs);
@ -2076,8 +2076,8 @@ class BigInteger
$n_length = count($n);
if (count($x) > 2 * $n_length) {
$lhs = new Math_BigInteger();
$rhs = new Math_BigInteger();
$lhs = new static();
$rhs = new static();
$lhs->value = $x;
$rhs->value = $n;
list(, $temp) = $lhs->divide($rhs);
@ -2087,11 +2087,11 @@ class BigInteger
if ( ($key = array_search($n, $cache[MATH_BIGINTEGER_VARIABLE])) === false ) {
$key = count($cache[MATH_BIGINTEGER_VARIABLE]);
$cache[MATH_BIGINTEGER_VARIABLE][] = $n;
$lhs = new Math_BigInteger();
$lhs = new static();
$lhs_value = &$lhs->value;
$lhs_value = $this->_array_repeat(0, 2 * $n_length);
$lhs_value[] = 1;
$rhs = new Math_BigInteger();
$rhs = new static();
$rhs->value = $n;
list($temp, ) = $lhs->divide($rhs); // m.length
$cache[MATH_BIGINTEGER_DATA][] = $temp->value;
@ -2320,9 +2320,9 @@ class BigInteger
*/
function _prepMontgomery($x, $n)
{
$lhs = new Math_BigInteger();
$lhs = new static();
$lhs->value = array_merge($this->_array_repeat(0, count($n)), $x);
$rhs = new Math_BigInteger();
$rhs = new static();
$rhs->value = $n;
list(, $temp) = $lhs->divide($rhs);
@ -2397,7 +2397,7 @@ class BigInteger
{
switch ( MATH_BIGINTEGER_MODE ) {
case MATH_BIGINTEGER_MODE_GMP:
$temp = new Math_BigInteger();
$temp = new static();
$temp->value = gmp_invert($this->value, $n->value);
return ( $temp->value === false ) ? false : $this->_normalize($temp);
@ -2405,8 +2405,8 @@ class BigInteger
static $zero, $one;
if (!isset($zero)) {
$zero = new Math_BigInteger();
$one = new Math_BigInteger(1);
$zero = new static();
$one = new static(1);
}
// $x mod -$n == $x mod $n.
@ -2464,9 +2464,9 @@ class BigInteger
extract(gmp_gcdext($this->value, $n->value));
return array(
'gcd' => $this->_normalize(new Math_BigInteger($g)),
'x' => $this->_normalize(new Math_BigInteger($s)),
'y' => $this->_normalize(new Math_BigInteger($t))
'gcd' => $this->_normalize(new static($g)),
'x' => $this->_normalize(new static($s)),
'y' => $this->_normalize(new static($t))
);
case MATH_BIGINTEGER_MODE_BCMATH:
// it might be faster to use the binary xGCD algorithim here, as well, but (1) that algorithim works
@ -2498,15 +2498,15 @@ class BigInteger
}
return array(
'gcd' => $this->_normalize(new Math_BigInteger($u)),
'x' => $this->_normalize(new Math_BigInteger($a)),
'y' => $this->_normalize(new Math_BigInteger($b))
'gcd' => $this->_normalize(new static($u)),
'x' => $this->_normalize(new static($a)),
'y' => $this->_normalize(new static($b))
);
}
$y = $n->copy();
$x = $this->copy();
$g = new Math_BigInteger();
$g = new static();
$g->value = array(1);
while ( !(($x->value[0] & 1)|| ($y->value[0] & 1)) ) {
@ -2518,10 +2518,10 @@ class BigInteger
$u = $x->copy();
$v = $y->copy();
$a = new Math_BigInteger();
$b = new Math_BigInteger();
$c = new Math_BigInteger();
$d = new Math_BigInteger();
$a = new static();
$b = new static();
$c = new static();
$d = new static();
$a->value = $d->value = $g->value = array(1);
$b->value = $c->value = array();
@ -2600,7 +2600,7 @@ class BigInteger
*/
function abs()
{
$temp = new Math_BigInteger();
$temp = new static();
switch ( MATH_BIGINTEGER_MODE ) {
case MATH_BIGINTEGER_MODE_GMP:
@ -2715,9 +2715,9 @@ class BigInteger
{
$this->precision = $bits;
if ( MATH_BIGINTEGER_MODE != MATH_BIGINTEGER_MODE_BCMATH ) {
$this->bitmask = new Math_BigInteger(chr((1 << ($bits & 0x7)) - 1) . str_repeat(chr(0xFF), $bits >> 3), 256);
$this->bitmask = new static(chr((1 << ($bits & 0x7)) - 1) . str_repeat(chr(0xFF), $bits >> 3), 256);
} else {
$this->bitmask = new Math_BigInteger(bcpow('2', $bits, 0));
$this->bitmask = new static(bcpow('2', $bits, 0));
}
$temp = $this->_normalize($this);
@ -2736,7 +2736,7 @@ class BigInteger
{
switch ( MATH_BIGINTEGER_MODE ) {
case MATH_BIGINTEGER_MODE_GMP:
$temp = new Math_BigInteger();
$temp = new static();
$temp->value = gmp_and($this->value, $x->value);
return $this->_normalize($temp);
@ -2749,7 +2749,7 @@ class BigInteger
$left = str_pad($left, $length, chr(0), STR_PAD_LEFT);
$right = str_pad($right, $length, chr(0), STR_PAD_LEFT);
return $this->_normalize(new Math_BigInteger($left & $right, 256));
return $this->_normalize(new static($left & $right, 256));
}
$result = $this->copy();
@ -2777,7 +2777,7 @@ class BigInteger
{
switch ( MATH_BIGINTEGER_MODE ) {
case MATH_BIGINTEGER_MODE_GMP:
$temp = new Math_BigInteger();
$temp = new static();
$temp->value = gmp_or($this->value, $x->value);
return $this->_normalize($temp);
@ -2790,7 +2790,7 @@ class BigInteger
$left = str_pad($left, $length, chr(0), STR_PAD_LEFT);
$right = str_pad($right, $length, chr(0), STR_PAD_LEFT);
return $this->_normalize(new Math_BigInteger($left | $right, 256));
return $this->_normalize(new static($left | $right, 256));
}
$length = max(count($this->value), count($x->value));
@ -2817,7 +2817,7 @@ class BigInteger
{
switch ( MATH_BIGINTEGER_MODE ) {
case MATH_BIGINTEGER_MODE_GMP:
$temp = new Math_BigInteger();
$temp = new static();
$temp->value = gmp_xor($this->value, $x->value);
return $this->_normalize($temp);
@ -2830,7 +2830,7 @@ class BigInteger
$left = str_pad($left, $length, chr(0), STR_PAD_LEFT);
$right = str_pad($right, $length, chr(0), STR_PAD_LEFT);
return $this->_normalize(new Math_BigInteger($left ^ $right, 256));
return $this->_normalize(new static($left ^ $right, 256));
}
$length = max(count($this->value), count($x->value));
@ -2869,7 +2869,7 @@ class BigInteger
$current_bits = strlen($pre_msb) + 8 * strlen($temp) - 8;
$new_bits = $this->precision - $current_bits;
if ($new_bits <= 0) {
return $this->_normalize(new Math_BigInteger($temp, 256));
return $this->_normalize(new static($temp, 256));
}
// generate as many leading 1's as we need to.
@ -2878,7 +2878,7 @@ class BigInteger
$temp = str_pad($temp, ceil($this->bits / 8), chr(0), STR_PAD_LEFT);
return $this->_normalize(new Math_BigInteger($leading_ones | $temp, 256));
return $this->_normalize(new static($leading_ones | $temp, 256));
}
/**
@ -2893,7 +2893,7 @@ class BigInteger
*/
function bitwise_rightShift($shift)
{
$temp = new Math_BigInteger();
$temp = new static();
switch ( MATH_BIGINTEGER_MODE ) {
case MATH_BIGINTEGER_MODE_GMP:
@ -2931,7 +2931,7 @@ class BigInteger
*/
function bitwise_leftShift($shift)
{
$temp = new Math_BigInteger();
$temp = new static();
switch ( MATH_BIGINTEGER_MODE ) {
case MATH_BIGINTEGER_MODE_GMP:
@ -2973,7 +2973,7 @@ class BigInteger
if ($this->precision > 0) {
$precision = $this->precision;
if ( MATH_BIGINTEGER_MODE == MATH_BIGINTEGER_MODE_BCMATH ) {
$mask = $this->bitmask->subtract(new Math_BigInteger(1));
$mask = $this->bitmask->subtract(new static(1));
$mask = $mask->toBytes();
} else {
$mask = $this->bitmask->toBytes();
@ -2995,7 +2995,7 @@ class BigInteger
}
$left = $this->bitwise_leftShift($shift);
$left = $left->bitwise_and(new Math_BigInteger($mask, 256));
$left = $left->bitwise_and(new static($mask, 256));
$right = $this->bitwise_rightShift($precision - $shift);
$result = MATH_BIGINTEGER_MODE != MATH_BIGINTEGER_MODE_BCMATH ? $left->bitwise_or($right) : $left->add($right);
return $this->_normalize($result);
@ -3042,7 +3042,7 @@ class BigInteger
}
}
return new Math_BigInteger($random, 256);
return new static($random, 256);
}
/**
@ -3056,11 +3056,11 @@ class BigInteger
function random($min = false, $max = false)
{
if ($min === false) {
$min = new Math_BigInteger(0);
$min = new static(0);
}
if ($max === false) {
$max = new Math_BigInteger(0x7FFFFFFF);
$max = new static(0x7FFFFFFF);
}
$compare = $max->compare($min);
@ -3076,7 +3076,7 @@ class BigInteger
static $one;
if (!isset($one)) {
$one = new Math_BigInteger(1);
$one = new static(1);
}
$max = $max->subtract($min->subtract($one));
@ -3097,7 +3097,7 @@ class BigInteger
http://crypto.stackexchange.com/questions/5708/creating-a-small-number-from-a-cryptographically-secure-random-string
*/
$random_max = new Math_BigInteger(chr(1) . str_repeat("\0", $size), 256);
$random_max = new static(chr(1) . str_repeat("\0", $size), 256);
$random = $this->_random_number_helper($size);
list($max_multiple) = $random_max->divide($max);
@ -3133,11 +3133,11 @@ class BigInteger
function randomPrime($min = false, $max = false, $timeout = false)
{
if ($min === false) {
$min = new Math_BigInteger(0);
$min = new static(0);
}
if ($max === false) {
$max = new Math_BigInteger(0x7FFFFFFF);
$max = new static(0x7FFFFFFF);
}
$compare = $max->compare($min);
@ -3153,8 +3153,8 @@ class BigInteger
static $one, $two;
if (!isset($one)) {
$one = new Math_BigInteger(1);
$two = new Math_BigInteger(2);
$one = new static(1);
$two = new static(2);
}
$start = time();
@ -3163,7 +3163,7 @@ class BigInteger
// gmp_nextprime() requires PHP 5 >= 5.2.0 per <http://php.net/gmp-nextprime>.
if ( MATH_BIGINTEGER_MODE == MATH_BIGINTEGER_MODE_GMP && function_exists('gmp_nextprime') ) {
$p = new Math_BigInteger();
$p = new static();
$p->value = gmp_nextprime($x->value);
if ($p->compare($max) <= 0) {
@ -3319,13 +3319,13 @@ class BigInteger
if ( MATH_BIGINTEGER_MODE != MATH_BIGINTEGER_MODE_INTERNAL ) {
for ($i = 0; $i < count($primes); ++$i) {
$primes[$i] = new Math_BigInteger($primes[$i]);
$primes[$i] = new static($primes[$i]);
}
}
$zero = new Math_BigInteger();
$one = new Math_BigInteger(1);
$two = new Math_BigInteger(2);
$zero = new static();
$one = new static(1);
$two = new static(2);
}
if ($this->equals($one)) {