Php int to bit

Содержание

bindec
Parameters
Return Values
Changelog
Examples
Notes
See Also
User Contributed Notes 10 notes
Конвертировать int в представление битов в php
3 ответа

bindec

Returns the decimal equivalent of the binary number represented by the binary_string argument.

bindec() converts a binary number to an int or, if needed for size reasons, float .

bindec() interprets all binary_string values as unsigned integers. This is because bindec() sees the most significant bit as another order of magnitude rather than as the sign bit.

Parameters

The binary string to convert. Any invalid characters in binary_string are silently ignored. As of PHP 7.4.0 supplying any invalid characters is deprecated.

The parameter must be a string. Using other data types will produce unexpected results.

Return Values

The decimal value of binary_string

Changelog

Version	Description
7.4.0	Passing invalid characters will now generate a deprecation notice. The result will still be computed as if the invalid characters did not exist.

Examples

Example #1 bindec() example

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

The above example will output:

Example #2 bindec() interprets input as unsigned integers

/*
* The lesson from this example is in the output
* rather than the PHP code itself.
*/

$magnitude_lower = pow ( 2 , ( PHP_INT_SIZE * 8 ) — 2 );
p ( $magnitude_lower — 1 );
p ( $magnitude_lower , ‘See the rollover? Watch it next time around. ‘ );

p ( PHP_INT_MAX , ‘PHP_INT_MAX’ );
p (~ PHP_INT_MAX , ‘interpreted to be one more than PHP_INT_MAX’ );

if ( PHP_INT_SIZE == 4 ) $note = ‘interpreted to be the largest unsigned integer’ ;
> else $note = ‘interpreted to be the largest unsigned integer
(18446744073709551615) but skewed by float precision’ ;
>
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 ); // For readability on 64 bit boxes.
$dec = bindec ( $bin );
echo ‘bindec(): ‘ . $dec . «\n» ;

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

Output of the above example on 32 bit machines:

input: 1073741823 binary: 00111111111111111111111111111111 bindec(): 1073741823 input: 1073741824 binary: 01000000000000000000000000000000 bindec(): 1073741824 NOTE: See the rollover? Watch it next time around. input: 2147483647 binary: 01111111111111111111111111111111 bindec(): 2147483647 NOTE: PHP_INT_MAX input: -2147483648 binary: 10000000000000000000000000000000 bindec(): 2147483648 NOTE: interpreted to be one more than PHP_INT_MAX input: -1 binary: 11111111111111111111111111111111 bindec(): 4294967295 NOTE: interpreted to be the largest unsigned integer

Output of the above example on 64 bit machines:

input: 4611686018427387903 binary: 0011111111111111111111111111111111111111111111111111111111111111 bindec(): 4611686018427387903 input: 4611686018427387904 binary: 0100000000000000000000000000000000000000000000000000000000000000 bindec(): 4611686018427387904 NOTE: See the rollover? Watch it next time around. input: 9223372036854775807 binary: 0111111111111111111111111111111111111111111111111111111111111111 bindec(): 9223372036854775807 NOTE: PHP_INT_MAX input: -9223372036854775808 binary: 1000000000000000000000000000000000000000000000000000000000000000 bindec(): 9223372036854775808 NOTE: interpreted to be one more than PHP_INT_MAX input: -1 binary: 1111111111111111111111111111111111111111111111111111111111111111 bindec(): 18446744073709551616 NOTE: interpreted to be the largest unsigned integer (18446744073709551615) but skewed by float precision

Notes

Note:

The function can convert numbers that are too large to fit into the platforms int type, larger values are returned as float in that case.

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).

Читайте также: Кнопка наверх вниз html

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 */

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 );
>
?>

Источник

Конвертировать int в представление битов в php

Как вы можете преобразовать целое число в его представление битов?

Например, представление числа 9 в битах: 10011

Например, чтобы преобразовать битовую последовательность в ее представление int, вы можете сделать это:

$bits_sq = array(1,0,0,1,1); function convert_bits_to_int($bits_sq) < $sum = 0; for($i=0; $i < count($bits_sq); $i++)< $sum = $sum + $bits_sq[$i] * pow(-2, $i); >print $sum; // equals to 9 >

Редактировать: НЕ ОШИБКА БИТОВ С ДВОЙНЫМИ, ЭТО НЕ ДУБЛИРУЕТ, ЧТОБЫ У ОТВЕТА НА ВЫШЕ НИТКУ

3 ответа

Вам нужно использовать decbin() для преобразования целого числа в двоичное.

Мой PHP ржавый, однако, если вы хотите сделать обратное этому примеру

$bits_sq = array(1,0,0,1,1); function convert_bits_to_int($bits_sq) < $sum = 0; for($i=0; $i < count($bits_sq); $i++)< $sum = $sum + $bits_sq[$i] * pow(-2, $i); >print $sum; // equals to 9 >

тогда я полагаю, вы хотите что-то вроде:

$bits_sq = convert_int_to_bits ($iValue); function convert_int_to_bits ($iValue) < $bits = array(); // initialize the array do < $bits[] = ($iValue & 1); $iValue >>= 1; // shift the bit off so that we go to the next one > while ($iValue); // continue as long as there are still some bits. // we have the bits in reverse order so lets reverse it. return array_reverse($bits); >