Huddled Masses

    # PowerShell does some strange casting of Int16, so we have to handle
    # it specially.
    [bool] $flagInt16 = $false

    # Only process if the number of bits to shift is valid
    if ($y -gt 0) {

        # Check the input variable type
        Switch ($x.gettype().fullname) {
            System.Byte {
                $maxbits = 8
                [byte] $highbit = 0x80
                [byte] $allbits = 0xFF
                [byte] $maskclear = 1
                [byte] $maskhigh = 1
                [byte] $maskrest = 1
            }
            System.Int16 {
                $maxbits = 16
                [int16] $highbit = -1 * 0x8000  # Int16 behaves differently
                [int16] $allbits = -1
                [int16] $maskclear = 1
                [int16] $maskhigh = 1
                [int16] $maskrest = 1
                [bool] $flagInt16 = $true
            }
            System.Int32 {
                $maxbits = 32
                [int32] $highbit = 0x80000000
                [int32] $allbits = -1
                [int32] $maskclear = 1
                [int32] $maskhigh = 1
                [int32] $maskrest = 1
            }
            System.Int64 {
                $maxbits = 64
                [int64] $highbit = 0x8000000000000000
                [int64] $allbits = -1
                [int64] $maskclear = 1
                [int64] $maskhigh = 1
                [int64] $maskrest = 1
            }
            # For any other variable type, alert the user and exit
            default {
                "Cannot process" + ($x.gettype().fullname) + " variables in a bitwise fashion."
                return
            }
        } # End of Switch

        # Only process if the shift distance is valid (less than variable length)
        if ($y -lt $maxbits) {

            # Check the shift direction, default to right, and if both are set,
            # give precedence to right
            if ($left.IsPresent -and (-not $right.IsPresent)) {

                # create a bitmask for just the bits we want to keep
                for ($count=1; $count -le $maxbits - $y -1; $count += 1) {
                    $maskhigh = $maskhigh * 2 # a mask with only the high bit set
                    $maskrest = $maskrest * 2 + 1 # a mask with all kept bits set
                }

                # Now do some mask magic to get the high bits and the rest of the bits
                # separated into variables
                $maskrest = $maskrest -bxor $maskhigh # clear the high bit from $maskrest
                $maskrest = $maskrest -band $x # then get just those bits from input
                $maskhigh = $maskhigh -band $x # and get the high kept bit from input

                # Now shift left by multiplying by 2
                for ($count=1; $count -le $y; $count += 1) {
                    $maskrest = $maskrest * 2
                }

                # Set the low-order bits of the return value
                $x = $maskrest

                # if the high input bit was set, then set it on output
                if ($maskhigh -ne 0) {
                    $x = $highbit -bor $x
                }
             }
             else { # Assume we want a right shift if Left wasn't selected
                # create a bitmask for the bits we will be losing
                # (this prevents underflow and conversion into a floating point
                # format)
                for ($count=1; $count -le $y -1; $count += 1) {
                    $maskclear = $maskclear * 2 + 1 # a mask of bits to clear
                }
                # Invert the mask so the bits to clear are zero
                $maskclear = $maskclear -bxor $allbits
                # Reduce the input to just the bits we want
                $maskclear = $maskclear -band $x
                # Now shift to the right by dividing by 2
                for ($count=1; $count -le $y; $count += 1) {
                    $maskclear = $maskclear / 2
                }
               
                # Set the return value
                $x = $maskclear                
             }
        }
        else {
            "Cannot shift a " + ($x.gettype().fullname) + " by $y bits."
        }
    } # End of check for shift length

    # Handle the special case by forcing the output to be cast back
    if ($flagInt16) {[Int16]$x = $x}

    # Output the result
    $x

} # End of Function