Главная » Языки программирования

Php dec to bin

Содержание
  1. bindec
  2. Список параметров
  3. Возвращаемые значения
  4. Список изменений
  5. Примеры
  6. Примечания
  7. Смотрите также
  8. User Contributed Notes 10 notes
  9. decbin
  10. Список параметров
  11. Возвращаемые значения

bindec

Возвращает десятичный эквивалент двоичного числа binary_string .

bindec() преобразует двоичное число в целое число ( int ) или, если необходимо, по причинам размера, в число с плавающей точкой ( float ).

bindec() интерпретирует значения binary_string как беззнаковое число. Так как bindec() воспринимает старший бит как ещё один порядок величины, а не знаковый бит.

Список параметров

Бинарная строка для преобразования. Любые некорректные символы в binary_string игнорируются. Начиная с PHP 7.4.0, предоставление любых некорректных символов устарело.

Параметр должен быть строкой. Использование иных типов данных приведёт к непредсказуемому результату.

Возвращаемые значения

Десятичное значение binary_string

Список изменений

Версия Описание
7.4.0 Передача некорректных символов будет выдавать уведомление об устаревании. Результат будет вычислен так, как если бы некорректные символы не существовали.

Примеры

Пример #1 Пример использования bindec()

echo bindec ( ‘110011’ ) . «\n» ;
echo bindec ( ‘000110011’ ) . «\n» ;

Результат выполнения данного примера:

Пример #2 bindec() интерпретирует ввод как беззнаковое число

/*
* Смысл этого примера можно найти в выводе скрипта,
* а не в коде PHP.
*/

$magnitude_lower = pow ( 2 , ( PHP_INT_SIZE * 8 ) — 2 );
p ( $magnitude_lower — 1 );
p ( $magnitude_lower , ‘Видите резкую смену значений? Смотрите в следующий раз. ‘ );

p ( PHP_INT_MAX , ‘PHP_INT_MAX’ );
p (~ PHP_INT_MAX , ‘интерпретируется как увеличенное на единицу значение PHP_INT_MAX’ );

if ( PHP_INT_SIZE == 4 ) $note = ‘интерпретируется как самое большое целое без знака (unsigned integer)’ ;
> else $note = ‘интерпретируется как самое большое целое без знака (unsigned integer)
(18446744073709551615), но искажается из-за недостаточной точности float’ ;
>
p (- 1 , $note );

function p ( $input , $note = » ) echo «input: $input \n» ;

$format = ‘%0’ . ( PHP_INT_SIZE * 8 ) . ‘b’ ;
$bin = sprintf ( $format , $input );
echo «binary: $bin \n» ;

ini_set ( ‘precision’ , 20 ); // Для надёжности на 64-битных системах.
$dec = bindec ( $bin );
echo ‘bindec(): ‘ . $dec . «\n» ;

if ( $note ) echo «NOTE: $note \n» ;
>

Результат выполнения данного примера на 32-битных машинах:

input: 1073741823 binary: 00111111111111111111111111111111 bindec(): 1073741823 input: 1073741824 binary: 01000000000000000000000000000000 bindec(): 1073741824 NOTE: Видите резкую смену значений? Смотрите в следующий раз. input: 2147483647 binary: 01111111111111111111111111111111 bindec(): 2147483647 NOTE: PHP_INT_MAX input: -2147483648 binary: 10000000000000000000000000000000 bindec(): 2147483648 NOTE: интерпретируется как увеличенное на единицу значение PHP_INT_MAX input: -1 binary: 11111111111111111111111111111111 bindec(): 4294967295 NOTE: интерпретируется как самое большое целое без знака (unsigned integer)

Результат выполнения данного примера на 64-битных машинах:

input: 4611686018427387903 binary: 0011111111111111111111111111111111111111111111111111111111111111 bindec(): 4611686018427387903 input: 4611686018427387904 binary: 0100000000000000000000000000000000000000000000000000000000000000 bindec(): 4611686018427387904 NOTE: Видите резкую смену значений? Смотрите в следующий раз. input: 9223372036854775807 binary: 0111111111111111111111111111111111111111111111111111111111111111 bindec(): 9223372036854775807 NOTE: PHP_INT_MAX input: -9223372036854775808 binary: 1000000000000000000000000000000000000000000000000000000000000000 bindec(): 9223372036854775808 NOTE: интерпретируется как увеличенное на единицу значение PHP_INT_MAX input: -1 binary: 1111111111111111111111111111111111111111111111111111111111111111 bindec(): 18446744073709551616 NOTE: интерпретируется как самое большое целое без знака (unsigned integer) (18446744073709551615), но искажается из-за недостаточной точности float

Примечания

Замечание:

Эта функция может конвертировать числа, которые слишком большие для типа int на текущей платформе. В этом случае большие значения возвращаются как float .

Смотрите также

  • decbin() — Переводит число из десятичной системы счисления в двоичную
  • octdec() — Переводит число из восьмеричной системы счисления в десятичную
  • hexdec() — Переводит число из шестнадцатеричной системы счисления в десятичную
  • base_convert() — Преобразование числа между произвольными системами счисления

User Contributed Notes 10 notes

Two functions to convert 16bit or 8bit binary to integer using two’s complement. If input exceeds maximum bits, false is returned. Function is easily scalable to x bits by changing the hexadecimals.

// Function to convert 16bit binary numbers to integers using two’s complement
$num = bindec ( $bin );
if( $num > 0xFFFF ) < return false ; >
if( $num >= 0x8000 ) return -(( $num ^ 0xFFFF )+ 1 );
> else return $num ;
>
>

function _bin8dec ( $bin ) // Function to convert 8bit binary numbers to integers using two’s complement
$num = bindec ( $bin );
if( $num > 0xFF ) < return false ; >
if( $num >= 0x80 ) return -(( $num ^ 0xFF )+ 1 );
> else return $num ;
>
> ?>

i think a better method than the «shift-method» is my method ^^.
here it comes:

function convert2bin($string) $finished=0;
$base=1;
if(preg_match(«/[^0-9]/», $string)) for($i=0; $string!=chr($i); $i++);
$dec_nr=$i;
>
else $dec_nr=$string;
while($dec_nr>$base) $base=$base*2;
if($base>$dec_nr) $base=$base/2;
break;
>
>
while(!$finished) if(($dec_nr-$base)>0) $dec_nr=$dec_nr-$base;
$bin_nr.=1;
$base=$base/2;
>
elseif(($dec_nr-$base) <0) $bin_nr.=0;
$base=$base/2;
>
elseif(($dec_nr-$base)==0) $bin_nr.=1;
$finished=1;
while($base>1) <
$bin_nr.=0;
$base=$base/2;
>
>
>
return $bin_nr;
>

if you want to reconvert it (from binary to string or integer) you can use this function:

function reconvert($bin_nr) $base=1;
$dec_nr=0;
$bin_nr=explode(«,», preg_replace(«/(.*),/», «$1», str_replace(«1», «1,», str_replace(«0», «0,», $bin_nr))));
for($i=1; $i foreach($bin_nr as $key=>$bin_nr_bit) if($bin_nr_bit==1) $dec_nr+=$base;
$base=$base/2;
>
if($bin_nr_bit==0) $base=$base/2;
>
return(array(«string»=>chr($dec_nr), «int»=>$dec_nr));
>

## calculate binary with «shift-method» ##

function dec2bin ( $decimal_code ) <
for( $half =( $decimal_code ); $half >= 1 ; $half =( floor ( $half ))/ 2 ) <
if(( $half % 2 )!= 0 ) <
$y .= 1 ;
>
else <
$y .= 0 ;
>
>
$calculated_bin = strrev ( $y );
return $calculated_bin ;
>
?>

## example ##

e.g.
123/2 = 61,5 => 1
61/2 = 30,5 => 1
30/2 = 15 => 0
15/2 = 7,5 => 1
7/2 = 3,5 => 1
3/2 = 1,5 => 1
1/2 = 0,5 => 1
(0/2 = 0 finish)

Binary to Decimal conversion using the BCMath extension..

function BCBin2Dec ( $Input = » ) $Output = ‘0’ ;
if( preg_match ( «/^[01]+$/» , $Input )) for( $i = 0 ; $i < strlen ( $Input ); $i ++)
$Output = BCAdd ( BCMul ( $Output , ‘2’ ), $Input < $i >);
>
return( $Output );
>

?>

This will simply convert from Base-2 to Base-10 using BCMath (arbitrary precision calculation).

See also: my ‘BCDec2Bin’ function on the ‘decbin’ document.
Enjoy,
Nitrogen.

The «smartbindec» function I wrote below will convert any binary string (of a reasonable size) to decimal. It will use two’s complement if the leftmost bit is 1, regardless of bit length. If you are getting unexpected negative answers, try zero-padding your strings with sprintf(«%032s», $yourBitString).

function twoscomp ( $bin ) $out = «» ;
$mode = «init» ;
for( $x = strlen ( $bin )- 1 ; $x >= 0 ; $x —) if ( $mode != «init» )
$out = ( $bin [ $x ] == «0» ? «1» : «0» ). $out ;
else if( $bin [ $x ] == «1» ) $out = «1» . $out ;
$mode = «invert» ;
>
else
$out = «0» . $out ;
>
>
return $out ;
>
function smartbindec ( $bin ) if( $bin [ 0 ] == 1 )
return — 1 * bindec ( twoscomp ( $bin ));
else return (int) bindec ( $bin );
>
?>

function binfloat (Array $num )

$sign = $num [ 0 ] ? 1 : — 1 ; //1 bit
$exponent = pow ( 2 , bindec ( implode ( » , array_slice ( $num , 1 , 8 )))- 127 );
$fraction = array_slice ( $num , 9 , count ( $num )); //23 bits
$fracSum = 1 ;

$fracSum += $fraction [ $i ] * pow ( 2 ,- 1 — $i );

$num = isset( $_GET [ ‘num’ ]) ? $_GET [ ‘num’ ] : ‘00111110001000000000000000000000’ ;

echo «Invalid binary number $num \n» ;
exit( 1 );

echo sprintf ( ‘Num is: [%s]%s’ , implode ( » , $num ), «\n» );
echo sprintf ( ‘Result is: %s%s’ , binfloat ( $num ), «\n» );

for converting fractions :
eg : 1001.1101

function BinaryToDecimal ( $binary ) <
$binary = trim ( $binary );
if ( strstr ( $binary , ‘.’ )) <
$split = explode ( ‘.’ , $binary );
$integer = $split [ 0 ];
$fraction = $split [ 1 ];

$digits = str_split ( $fraction );
$num = sizeof ( $digits );
for ( $i = 1 ; $i if ( $digits [ $i — 1 ]> 1 ) <
echo ‘ ‘ ;
>
$exponent = pow ( 2 ,- $i );
$fraction_result += $digits [ $i — 1 ]* $exponent ;
>

$splits = str_split ( $integer );
$num = sizeof ( $splits )- 1 ;
$i = $num ;
foreach( $splits as $digits ) <
if ( $digits > 1 ) <
echo ‘ ‘ ;
>
$exponent = pow ( 2 , $i );
$integer_result += $digits * $exponent ;
$i —;
>
if( $fraction_result ) <
$result = $integer_result + $fraction_result ;
>else <
$result = $integer_result ;
>
return $result ;
>
?>

Left-shift a string by a number of bytes
function STR_shl ( $szStr , $nBits )
/*——————————*/
if ( $nBits < 1 || $nBits >7 ) /* If not adequate number of bits */
return ( $szStr ); /* Return the original string */
> /* if ( $nBits < 1 || $nBits >7 ) */

if ( ( $iLength = strlen ( $szStr ) ) return ( $szStr ); /* Return the original string */
> /* if ( ( $iLength = strlen( $szStr ) )

$szRetVal = » ; /* Create an empty string */

$szBits = STR_Binary ( $szStr ); /* $szStr in bits */
$szLostBits = STR_Left ( $szBits , $nBits ); /* The $nBits leftmost bits of the string */
$szShifted = substr ( $szBits , $nBits ) . $szLostBits ; /* $szStr left shifted */

for ( $i = 0 ; $i < $iLength ; $i ++ ) /* Treat the entire string (per slice of 8 bits) */
$szRetVal .= chr ( bindec ( substr ( $szShifted , $i * 8 , 8 ) ) ); /* Concatenate the CHR to the result string */
> /* for ( $i = 0;$i < $iLength;$i++ ) */

return ( $szRetVal ); /* Return result to caller */
>
?>

Right-shift a string by a number of bytes

function STR_shr ( $szStr , $nBits )
/*——————————*/
if ( $nBits < 1 || $nBits >7 ) /* If not adequate number of bits */
return ( $szStr ); /* Return the original string */
> /* if ( $nBits < 1 || $nBits >7 ) */

if ( ( $iLength = strlen ( $szStr ) ) return ( $szStr ); /* Return the original string */
> /* if ( ( $iLength = strlen( $szStr ) )

$szRetVal = » ; /* Create an empty string */

$szBits = STR_Binary ( $szStr ); /* $szStr in bits */
$szLostBits = STR_Right ( $szBits , $nBits ); /* The $nBits rightmost bits of the string */
$szShifted = $szLostBits . substr ( $szBits , 0 ,- $nBits ); /* $szStr right shifted */

for ( $i = 0 ; $i < $iLength ; $i ++ ) /* Treat the entire string (per slice of 8 bits) */
$szRetVal .= chr ( bindec ( substr ( $szShifted , $i * 8 , 8 ) ) ); /* Concatenate the CHR to the result string */
> /* for ( $i = 0;$i < $iLength;$i++ ) */

return ( $szRetVal ); /* Return result to caller */
>
?>

Additional functions used by the two preceding:
function STR_Binary ( $szStr )
/*————————-*/
$szRetVal = » ; /* Ready to return an empty string */

if ( ( $iLength = strlen ( $szStr ) ) > 0 ) /* If string NOT empty */
for ( $i = 0 ; $i < $iLength ; $i ++ ) /* Treat each character of the string */
$szRetVal .= sprintf ( ‘%08b’ , ord ( $szStr [ $i ] ) ); /* Turn this char to a binary representation (8 bits) */
> /* for ( $i = 0; $i < $iLength;$i++ ) */
> /* if ( ( $iLength = strlen( $szStr ) ) > 0 ) */

return ( $szRetVal ); /* Return result to caller */
>

function STR_Left ( $szStr , $iCount = 1 )
/*———————————-*/
return substr ( $szStr , 0 , $iCount );
> /* End of function strleft() */

function STR_Right ( $szString , $iCount )
/*———————————-*/
return substr ( $szString , 0 + strlen ( $szString ) — $iCount , $iCount );
>
?>

Источник

decbin

Возвращает строку, содержащую двоичное представление указанного аргумента num .

Список параметров

Десятичное число для преобразования

Область ввода для 32-битных машин

положительный num отрицательный num возвращаемое значение
0 0
1 1
2 10
. и так далее .
2147483646 1111111111111111111111111111110
2147483647 (наибольший знаковый integer) 1111111111111111111111111111111 (31 единица)
2147483648 -2147483648 10000000000000000000000000000000
. и так далее .
4294967294 -2 11111111111111111111111111111110
4294967295 (наибольший беззнаковый integer) -1 11111111111111111111111111111111 (32 единицы)
Область ввода для 64-битных машин
положительный num отрицательный num возвращаемое значение
0 0
1 1
2 10
. и так далее .
9223372036854775806 111111111111111111111111111111111111111111111111111111111111110
9223372036854775807 (наибольший знаковый integer) 111111111111111111111111111111111111111111111111111111111111111 (63 единицы)
-9223372036854775808 1000000000000000000000000000000000000000000000000000000000000000
. и так далее .
-2 1111111111111111111111111111111111111111111111111111111111111110
-1 1111111111111111111111111111111111111111111111111111111111111111 (64 единицы)

Возвращаемые значения

Бинарное строковое представление num

Источник

Читайте также:  Upload php на swfupload
Оцените статью
© 2024 Программирование