Ytukyg

How can i compare 8 bit with another 8 bit to have something like this:

first Nr     1 0 0 0 1 1 0 1

second Nr    1 0 1 0 1 0 0 0

Result       r r f r r f r f



r = right 

f = false

Thanks

An annotated solution:

$firstNrBin  = '1 0 0 0 1 1 0 1'

$secondNrBin = '1 0 1 0 1 0 0 0'



# Convert the binary number strings to [byte]s (unsigned 8-bit values).

$firstNr = [Convert]::ToByte($firstNrBin -replace ' ', 2)   # 141 == 0x8d

$secondNr = [Convert]::ToByte($secondNrBin -replace ' ', 2) # 168 == 0xa8



# Perform bitwise XOR logic and negate the result to get a bit field

# that reflects the bits where the input numbers match.

# Note the need use of -band 0xff to limit the result to 8 bits - see

# explanation below.

# -> 218 == 0xda = 11011010

$bitsInCommon = [byte] (-bnot ($firstNr -bxor $secondNr) -band 0xff)



# Convert the bit field back into a binary representation, 0-padded to 8 chars.

# -> '11011010'

$bitsInComminBin = [Convert]::ToString($bitsInCommon, 2).PadLeft(8, '0')



# Produce the desired output format with string manipulation

$result = ([char] $bitsInComminBin -replace '1', 'r' -replace '0', 'f') -join ' '



# Output the result

[ordered] @{

  'first Nr' = $firstNrBin

  'second Nr' = $secondNrBin

  'Result' = $result

}

The above yields:

Name                           Value

----                           -----

first Nr                       1 0 0 0 1 1 0 1

second Nr                      1 0 1 0 1 0 0 0

Result                         r r f r r f r f

Note that PowerShell's bitwise operators output [int] - System.Int32 as the smallest data type, i.e., signed numbers.

Therefore you have to mask out extra bits explicitly with the -band operator, because directly casting back to an unsigned type doesn't work.

In the case at hand:

$firstNr -bxor $secondNr # 141 -bxor 168

produces 37 as an [int] value, i.e, the following 32 bits:

00000000000000000000000000100101

Applying -bnot to this [int] yields the bitwise complement:

11111111111111111111111111011010

As an [int], this is a negative number, because the high bit is set: -38

You cannot cast this directly back to an unsigned type such as [byte] to only get the lowest 8 bits, but you can use -band with bit mask 0xff to zero out all bits beyond the first 8 ones - but note that the result is still an [int] at that point:

-bnot -38 -band 0xff

yields the following bits:

00000000000000000000000000100101

As an [int], this is 37, which you can safely cast back to [byte].

You can use bitwise comparison operators:

e.g.

[byte]$a = 9       #00001001

[byte]$b = 12      #00001100



-bnot ($a -bxor $b) #11111010



$a -band $b        #00001000

$a -bor $b         #00001101

For your scenario you're looking at -bxor functionality, only taking the negative (-bnot) of the result.

If you need to see the flags themselves, you can use methods such as these:

function Format-BooleanString {

    [CmdletBinding()]

    Param (

        [Parameter(Mandatory = $true, ValueFromPipeline = $true)]

        [byte]$ByteToDisplay 

    )

    Process {

        [string]$result = ''

        for ([int]$i = 7; $i -ge 0; $i--) {

            [int]$x = [Math]::Pow(2, $i)

            if ($ByteToDisplay -band $x) {

                $result += '1'

            } else {

                $result += '0'

            }

        }

        $result

    }

}

function Convert-BooleanStringToByte {

    [CmdletBinding()]

    Param (

        [Parameter(Mandatory = $true, ValueFromPipeline = $true)]

        [string]$ByteAsString

    )

    Process {

        if ($ByteAsString -notmatch '^[01]{8}$') {

            throw 'Input string must be 8 chars, consisting of only 0s and/or 1s'

        }

        [int]$result = 0

        for ([int]$i = 0; $i -lt 8; $i++) {

            if ($ByteAsString[$i] -eq '1') {

                $result += [Math]::Pow(2, 7-$i)

            }

        }

        [byte]$result            

    }



}



Format-BooleanString -ByteToDisplay 9

Convert-BooleanStringToByte -ByteAsString '00100010'