[RESOLVED] Bit conversion operations

[bergerkiller]

Hello everyone.

In my API class I encountered a lot of times I had to Get/Set low/high order <something> of <something>. For example, get the low order integer from a long. I made a few functions for this:

    Public Shared Function LHByteCombine(ByVal low As Byte, ByVal high As Byte) As Short
        Return low + high * 2 ^ 8
    End Function
    Public Shared Function LHShortCombine(ByVal low As Short, ByVal high As Short) As Integer
        Return low + high * 2 ^ 16
    End Function
    Public Shared Function LHIntegerCombine(ByVal low As Integer, ByVal high As Integer) As Long
        Return low + high * 2 ^ 32
    End Function
    Public Shared Function GetHighByte(ByVal value As Short) As Byte
        Return value >> 8
    End Function
    Public Shared Function GetHighShort(ByVal value As Integer) As Short
        Return value >> 16
    End Function
    Public Shared Function GetHighInteger(ByVal value As Long) As Integer
        Return value >> 32
    End Function
    Public Shared Function GetLowByte(ByVal value As Short) As Byte
        Return value - GetHighByte(value) * 2 ^ 8
    End Function
    Public Shared Function GetLowShort(ByVal value As Integer) As Short
        Return value - GetHighShort(value) * 2 ^ 16
    End Function
    Public Shared Function GetLowInteger(ByVal value As Long) As Integer
        Return value - GetHighInteger(value) * 2 ^ 32
    End Function

Before I start using these functions permanently, I come to ask if it contains any bugs, especially because of the Unsigned/Signed issue.

[kleinma]

You are not coding with option strict on. If you turned it on, you would see none of the methods compile because you are using narrowing conversions on the numeric values. With strict off, the runtime tries to perform the conversion for you, but this can lead to you assuming things are correct when in fact they could be wrong.

For example, try running this:

        Try
            Dim myShort As Short = CombineLH(Byte.MaxValue, Byte.MaxValue)
        Catch ex As Exception
            MessageBox.Show(ex.Message)
        End Try

[Shaggy Hiker]

I thought there was an issue with your GetHigh methods, but if you do the proper conversion, as Kleinma suggested, it will be ok.

[kleinma]

I thought there was an issue with your GetHigh methods, but if you do the proper conversion, as Kleinma suggested, it will be ok.

I thought maybe the GetHigh method would make everything really slow and make the app memory hungry

[bergerkiller]

Thanks for the replies.
Updated the first post so no narrowing conversions take place.

I had it like that before, but noticed that it was able to do the narrowing itself so left it out. (it called the GetLow byte version when two bytes were passed.)
But I can understand that narrowing numeric values can cause some issues and it would be annoying if you find it out after you made everything around it.

What about the UShort - Short, UInteger - Integer and ULong - Long conversions? I believe the signed versions have a bit set indicating negative/positive. Can that be of any problem when using these functions?

EDIT

Ow and does changing:

Return value >> 8

To:

Return CByte(value >> 8)

Improve the code or would the implicit conversion do the same thing anyways?

[Shaggy Hiker]

I thought maybe the GetHigh method would make everything really slow and make the app memory hungry

I can't believe I missed that.



Implicit narrowing conversions will happen with Option Strict OFF, but even though they can be done, they are also slow, so don't do them. The speed difference is negligible if you are only calling a few of these, but bit manipulation is something you tend to do lots of if you do it at all, so a bit of attention to this detail will probably pay off, perhaps even noticeably.

The signed versions don't really use a bit to indicate negative. You could look up Twos Complement for an in depth explanation of how negative numbers or stored, or Threes Company for a light commentary on the 70s. However, the net result (or the .NET result, anyways) of the Twos Complement way of storing numbers is that the high bit will be set for negative numbers. One interesting feature of .NET is that when you use the bit shift operator (>>), the most significant bit is propagated over. In C++, the >> operator shifts to the right and fills the high bits with 0. In .NET, the >> operator shifts to the right and fills the top bits with whatever was originally in the most significant bit. In your case, however, this will have no impact, because you are shifting over by a number of bytes, and throwing out the top bytes. If you were not shifting by multiples of 8, or were retaining the most significant bits, then you would have a problem. For example, if your GetHigh returned the same type as the argument rather than a type half the size of the argument, then you would certainly have an issue. You might actually consider doing this. After all, a 32 bit processor handles 32 bit values most efficiently. Therefore, shortening an Integer to a Short doesn't buy you much of anything. You could leave it as an integer, but if you did, you'd have to mask off the high bytes:

Public Function GetHigh(myInt As Integer) As Integer
 return ((myInt >>16) And &HFFFF)
End Function

[bergerkiller]

Aah so THAT is why those functions on the internet use [& &HFFFF].

But I prefer keeping the conversions, since I will be using the same functions in API's. For example, get the integer of a short and two bytes combined:

Dim flags As Integer = LHShortCombine(myshort, LHByteCombine(mybyte1, mybyte2))

BTW: I used a bitconverter-method before, but I read everywhere that it is significantly slower. Here the (probably narrowing conversion sensitive) functions I used previously:

    Public Shared Function GetBytes(ByVal ParamArray values() As Object) As Byte()
        Dim b As New List(Of Byte)
        For Each value As Object In values
            If TypeOf value Is Byte Then
                b.Add(value)
            Else
                b.AddRange(BitConverter.GetBytes(value))
            End If
        Next
        Return b.ToArray
    End Function
    Public Shared Function GetShort(ByVal l As Byte, ByVal h As Byte) As Short
        Return BitConverter.ToInt16(GetBytes(l, h), 0)
    End Function
    Public Shared Function GetInteger(ByVal ParamArray values() As Object) As Integer
        Return BitConverter.ToInt32(GetBytes(values), 0)
    End Function

I had to use a lot of 'CTyping' because most passed values were enumerated values of type <>.

Basically, I have to pass variables (LParam most of the time) that contain other values inside. I do not want to go with making structures for every single "Type" of LParam but want to "Combine" values of different types into the LParam. This can either be done with that "GetBytes -> Integer" method or by using multiple 'combine and convert' and splitting functions.

[minitech]

By the way, there's a very easy way to convert between things with, for example, this 8-byte type: (Assumes Imports System.Runtime.InteropServices)

<StructLayout(LayoutKind.Explicit)> _
Public Structure XLong
     <FieldOffset(0)> Public UnsignedLongValue As ULong
     <FieldOffset(0)> Public LongValue As Long
     <FieldOffset(0)> Public HighInt As Integer
     <FieldOffset(4)> Public LowInt As Integer
     <FieldOffset(0)> Public Short1 As Short
     <FieldOffset(2)> Public Short2 As Short
     <FieldOffset(4)> Public Short3 As Short
     <FieldOffset(6)> Public Short4 As Short
     <FieldOffset(0)> Public Byte1 As Byte
     <FieldOffset(1)> Public Byte2 As Byte
     <FieldOffset(2)> Public Byte3 As Byte
     <FieldOffset(3)> Public Byte4 As Byte
     <FieldOffset(4)> Public Byte5 As Byte
     <FieldOffset(5)> Public Byte6 As Byte
     <FieldOffset(6)> Public Byte7 As Byte
     <FieldOffset(7)> Public Byte8 As Byte
End Structure

This allows you to get and set any bytes, shorts, ints, or longs in an 8-byte value. It's also very efficient.

[bergerkiller]

Interesting...but there are no problems if I would, for example, send such a structure instead of a long? And what if you have to retrieve the values from the LParam if you know that the order is short-byte-byte? Not sure what happens if you would use such a structure in a ByRef.

EDIT

Plus I would preferably make all members hidden and use properties with an index variable instead:

<StructLayout(LayoutKind.Explicit)> _
    Public Structure XLong
        <FieldOffset(0)> Private ULong1 As ULong
        <FieldOffset(0)> Private Long1 As Long
        <FieldOffset(0)> Private Integer1 As Integer
        <FieldOffset(4)> Private Integer2 As Integer
        <FieldOffset(0)> Private Short1 As Short
        <FieldOffset(2)> Private Short2 As Short
        <FieldOffset(4)> Private Short3 As Short
        <FieldOffset(6)> Private Short4 As Short
        <FieldOffset(0)> Private Byte1 As Byte
        <FieldOffset(1)> Private Byte2 As Byte
        <FieldOffset(2)> Private Byte3 As Byte
        <FieldOffset(3)> Private Byte4 As Byte
        <FieldOffset(4)> Private Byte5 As Byte
        <FieldOffset(5)> Private Byte6 As Byte
        <FieldOffset(6)> Private Byte7 As Byte
        <FieldOffset(7)> Private Byte8 As Byte
        Public Property ByteMember(ByVal index As Integer) As Byte
            Get
                Select Case index
                    Case 0
                        Return Me.Byte1
                    Case 1
                        Return Me.Byte2
                    Case 2
                        Return Me.Byte3
                    Case 3
                        Return Me.Byte4
                    Case 4
                        Return Me.Byte5
                    Case 5
                        Return Me.Byte6
                    Case 6
                        Return Me.Byte7
                    Case 7
                        Return Me.Byte8
                    Case Else
                        Return Nothing
                End Select
            End Get
            Set(ByVal value As Byte)
                Select Case index
                    Case 0
                        Me.Byte1 = value
                    Case 1
                        Me.Byte2 = value
                    Case 2
                        Me.Byte3 = value
                    Case 3
                        Me.Byte4 = value
                    Case 4
                        Me.Byte5 = value
                    Case 5
                        Me.Byte6 = value
                    Case 6
                        Me.Byte7 = value
                    Case 7
                        Me.Byte8 = value
                End Select
            End Set
        End Property
        Public Property ShortMember(ByVal index As Integer) As Short
            Get
                Select Case index
                    Case 0
                        Return Me.Short1
                    Case 1
                        Return Me.Short2
                    Case 2
                        Return Me.Short3
                    Case 3
                        Return Me.Short4
                    Case Else
                        Return Nothing
                End Select
            End Get
            Set(ByVal value As Short)
                Select Case index
                    Case 0
                        Me.Short1 = value
                    Case 1
                        Me.Short2 = value
                    Case 2
                        Me.Short3 = value
                    Case 3
                        Me.Short4 = value
                End Select
            End Set
        End Property
        Public Property IntegerMember(ByVal index As Integer) As Integer
            Get
                Select Case index
                    Case 0
                        Return Me.Integer1
                    Case 1
                        Return Me.Integer2
                    Case Else
                        Return Nothing
                End Select
            End Get
            Set(ByVal value As Integer)
                Select Case index
                    Case 0
                        Me.Integer1 = value
                    Case 1
                        Me.Integer2 = value
                End Select
            End Set
        End Property
        Public Property LongMember() As Long
            Get
                Return Me.Long1
            End Get
            Set(ByVal value As Long)
                Me.Long1 = value
            End Set
        End Property
        Public Property ULongMember() As ULong
            Get
                Return Me.ULong1
            End Get
            Set(ByVal value As ULong)
                Me.ULong1 = value
            End Set
        End Property
    End Structure

[minitech]

No, here's how you use it:

' To retrieve something from LParam with order short-byte-byte
Dim v As XLong
v.LowInt = theLParam
Dim theHighShort As Short = v.Short3
Dim theBytes() As Byte = {v.Byte7, v.Byte8}
' Do stuff

And that in reverse to set things. When you want to transfer its Long value to a function, instead pass theVariable.LongValue.

[bergerkiller]

Hey never thought of that
Thanks, I guess I will be using this, or a somewhat modified version.
(like adding constructors to hold a certain value at start)

I always thought the <offset> thing only allowed a certain row of values, didn't know the values actually shared their bytes! Another thing learned.

EDIT

Final code:

<StructLayout(LayoutKind.Explicit)> _
    Public Structure WORD
        <FieldOffset(0)> Public Short1 As Short
        <FieldOffset(0)> Public UShort1 As UShort
        <FieldOffset(0)> Public Byte1 As Byte
        <FieldOffset(1)> Public Byte2 As Byte
    End Structure
    <StructLayout(LayoutKind.Explicit)> _
    Public Structure DWORD
        <FieldOffset(0)> Public Integer1 As Integer
        <FieldOffset(0)> Public UInteger1 As UInteger
        <FieldOffset(0)> Public Short1 As Short
        <FieldOffset(0)> Public UShort1 As UShort
        <FieldOffset(2)> Public Short2 As Short
        <FieldOffset(2)> Public UShort2 As UShort
        <FieldOffset(0)> Public Byte1 As Byte
        <FieldOffset(1)> Public Byte2 As Byte
        <FieldOffset(2)> Public Byte3 As Byte
        <FieldOffset(3)> Public Byte4 As Byte
    End Structure
    <StructLayout(LayoutKind.Explicit)> _
    Public Structure QWORD
        <FieldOffset(0)> Public Long1 As Long
        <FieldOffset(0)> Public ULong1 As ULong
        <FieldOffset(0)> Public Integer1 As Integer
        <FieldOffset(0)> Public UInteger1 As UInteger
        <FieldOffset(4)> Public Integer2 As Integer
        <FieldOffset(4)> Public UInteger2 As UInteger
        <FieldOffset(0)> Public Short1 As Short
        <FieldOffset(0)> Public UShort1 As UShort
        <FieldOffset(2)> Public Short2 As Short
        <FieldOffset(2)> Public UShort2 As UShort
        <FieldOffset(4)> Public Short3 As Short
        <FieldOffset(4)> Public UShort3 As UShort
        <FieldOffset(6)> Public Short4 As Short
        <FieldOffset(6)> Public UShort4 As UShort
        <FieldOffset(0)> Public Byte1 As Byte
        <FieldOffset(1)> Public Byte2 As Byte
        <FieldOffset(2)> Public Byte3 As Byte
        <FieldOffset(3)> Public Byte4 As Byte
        <FieldOffset(4)> Public Byte5 As Byte
        <FieldOffset(5)> Public Byte6 As Byte
        <FieldOffset(6)> Public Byte7 As Byte
        <FieldOffset(7)> Public Byte8 As Byte
    End Structure

Just wondering though...could you store Byte1...Byte8 as an array (of 8 elements) or would that interfere with the Marshalling too much?

E.g.

<StructLayout(LayoutKind.Explicit)> _
    Public Structure QWORDA
        <FieldOffset(0)> Public Longs() As Long
        <FieldOffset(0)> Public ULongs() As ULong
        <FieldOffset(0)> Public Integers() As Integer
        <FieldOffset(0)> Public UIntegers() As UInteger
        <FieldOffset(0)> Public Shorts() As Short
        <FieldOffset(0)> Public UShorts() As UShort
        <FieldOffset(0)> Public Bytes() As Byte
    End Structure

[Milk]

I've been using something similar to Minitech there, and just want to confirm it appears very efficient.

[minitech]

I don't know; I've never tried. Marshal.Copy seems to handle them pretty well though, and array elements should be stored sequentially in memory so that is a possibility.

No wait, it's not possible - the structure could never know the size of the array ahead of time. You would store a POINTER to the array which would really mess things up for you. On a 64-bit system, the LongValue would be a pointer to the array and on a 32-bit system half of it would be zeroes. Don't do that.

[bergerkiller]

Okay, I'll keep the large amounts of members then.
Might add some properties to them like "Bytes(Integer index, Integer count) As Byte()", but I'm not sure. Thanks for the help everyone, really didn't expect that this would have been a possibility.

And yep, it looks very slim. For example, the following function:

        Private Shared Function GetErrorString(ByVal ErrorCode As Long) As String
            With New QWORD(ErrorCode)
                GetErrorString = "Device " & .Integer2 & " - "
                Dim buff As New System.Text.StringBuilder(128)
                If mciGetErrorString(.Integer1, buff, buff.Capacity) Then
                    GetErrorString &= buff.ToString
                Else
                    GetErrorString &= "Error code: " & .Integer1
                End If
            End With
        End Function

[Milk]

In c# you can define a sequential sequence of a type within a structure using the fixed keyword but this is considered unsafe and so I assume not an option in VB.

[bergerkiller]

Ow I found it no problem having all those members in the end, it is actually pretty useful having all these members ready to access in one go.

For example, I added a CType conversion from "WORD to Short", "DWORD to Integer" and "QWORD to Long" and can now pass my structure into functions that require a Short/Integer/Long parameter. Plus some "FromXXXX" functions:

        Public Shared Function FromSBB(ByVal Short1 As Short, ByVal Byte1 As Byte, ByVal Byte2 As Byte) As DWORD
            FromSBB = New DWORD
            FromSBB.Short1 = Short1
            FromSBB.Byte3 = Byte1
            FromSBB.Byte4 = Byte2
        End Function

This must be the easiest order conversion I ever did.