Singles

[Gaming_World]

Anyone know how to split a single into 3 byte longs?

basicly, I want to pass in 16FF6715F7F2 and get 16FF67 and 15F7F2 out.

Yes , I know longs are 4 bytes in VB, but the rotines I am using require 3 bytes. By the way, how many bytes long is the longest possible single?

[Aurilus]

OK.. I think this should do the trick for you It won't store them as 3-byte longs but will instead split it up into four-byte longs, which you can then change to 3-byte longs from there.

    Dim V1 As Long, V2 As Long
    SplitValue &H123456, V1, V2
    MsgBox Hex(&H123456) & vbNewLine & Hex(V1) & " " & Hex(V2)

Public Sub SplitValue(ByVal ValueIn As Single, ByRef BigValue As Long, ByRef SmallValue As Long)
    Dim ChunkSize As Long
    ' &H10 = split into 1-digit chunks
    ' &H100 = split into two digit chunks
    ' &H1000 = split into three digit chunks
    ' &H10000 = split into four digit chunks
    ' &H100000 = split into five-digit chunks
        ChunkSize = &H1000
    
    BigValue = ValueIn \ ChunkSize
    SmallValue = ValueIn - (BigValue * ChunkSize)
End Sub

Sorry 'bout the quality of the code, but at least it works

All you have to do is change the ChunkSize value to split up how many bytes you want it cut into.

- Aurilus

[Nucleus]

Create a byte array to hold the data size it to hold 4 bytes. then use copymemory to copy the data into the byte array.

So all you do is pass the pointer to the variable and a pointer to the 1st element of the byte array using varptr() and let copymemory api do all the work for you.

Then you can loop through the byte array to examine each byte.

[kedaman]

Single is a IEEE Standard 754 Floating Point precision datatype, it will contain unusable information as raw memory for you, have a look at:
http://research.microsoft.com/~holla...ieeefloat.html

16FF6715F7F2 is 25286201964530 decimal, would be stored 2.52862E+13 in a single; 25286200000000. You should rather use a Currency 64 bit integer or decimal datatype, the latter if you don't want to mess with the decimal point shift, the earlier if you want to save speed. Then you can copymemory the 3 hi bytes from currency to long.

[DerFarm]

Well, being totally out of my element here, I'm taking a crack at
this.

I was working on decoding packed data, which works with the
upper 4 bits and lower 4 bits of a character. Essentially, I found
that

(CH AND 240)/8 = Upper Nibble in Lower Nibble format
(CH and 15) = Lower Nibble in Lower Nibble format

It would seem that you could do something similar for the 4
bytes, using words instead of nibbles.


Be a damn sight faster than arraying a series of 0 and 1 constructs.

[kedaman]

Actually not worth a try unless you do it in assmbler on a cpu that can handle 64 bit integers. Copymemory will do fine, btw
do
CH \ 16
instead of
(CH AND 240)/8 to get the hi nibble, \ stands for integer division.

[DerFarm]

hmmmmmmm......Good idea. Actually, now that I think of it, your
copy memory would work perfectly. I'm getting too used to
thinking in VB.

Simply read the bit patterns from a part of one location to the
lower bits of another (zeroed) position. Then read the 2nd
position as a long.

Is this what you meant?

[kedaman]

well eh, you make it sound weird, actually it is this simple:
you start at the 6'th byte on currency and copy to 2nd on the long
Currency:
[00 00 16 FF 67 *15 F7 F2* ]
Long:
[00 *15 F7 F2*]

[Dim A]

Can't you just do something like:

lowerBytes= number mod (2^(8*3))
upperBytes= int(  number / (2^(8*3))  )

[kedaman]

modulus can't be emulated on 64 bit integer in vb, even if it would, copymemory would be faster, if you coded in assembly on a 64 bit cpu you would rather use bitwise and than modulus

and also, evulate all the numeric expressions, since vb's compiler isn't smart enough to do that itself

[Nucleus]

Originally posted by kedaman
well eh, you make it sound weird, actually it is this simple:
you start at the 6'th byte on currency and copy to 2nd on the long
Currency:
[00 00 16 FF 67 *15 F7 F2* ]
Long:
[00 *15 F7 F2*]

Are you sure currency stores it that way?

I found I had to move all 8 bytes to copy the value from one currency to the other?

This fails:

Private Declare Sub CopyMemory Lib "kernel32" Alias "RtlMoveMemory" (pDst As Any, pSrc As Any, ByVal ByteLen As Long)
 
Private Sub Command1_Click()
Dim c As Currency
Dim c2 As Currency
Dim l As Long
Dim i&
 
c = 25286201964530#
Debug.Print c
CopyMemory ByVal VarPtr(c2) + 2, ByVal VarPtr(c) + 2, 6
Debug.Print c2
End Sub

This works (obviously)

c = 25286201964530#
Debug.Print c
CopyMemory ByVal VarPtr(c2), ByVal VarPtr(c), 8
Debug.Print c2

[Nucleus]

You can do it with decimal though:

Private Declare Sub CopyMemory Lib "kernel32" Alias "RtlMoveMemory" (pDst As Any, pSrc As Any, ByVal ByteLen As Long)
 
Private Sub Command1_Click()
 Dim d As Variant
 Dim lHigh As Long
 Dim lLow As Long
 
 d = CDec(25286201964530#)
 
 CopyMemory ByVal VarPtr(lHigh), ByVal VarPtr(d) + 11, 3
 CopyMemory ByVal VarPtr(lLow), ByVal VarPtr(d) + 8, 3
 
 Debug.Print Hex(lLow), Hex(lHigh)
 
End Sub

[Kaverin]

Heh heh. Moving along to Sephiroth now .

[Nucleus]

Originally posted by Kaverin
Heh heh. Moving along to Sephiroth now .

That should be confusing most people by now

[kedaman]

Heya Nucleus, you're correct, Currency is an oddball, the bytes are reversed while the bits within each byte is in same order.

Dim c As Currency
Dim l As Long
c = 0.0011
Debug.Print c
CopyMemory ByVal VarPtr(c2), ByVal VarPtr(l) + 3, 1
Debug.Print l

I guess M$ has a really good reason to do so, the emulation of Currency operations isn't done at cpu level, so in VB you could pretty much go any way you want.

What you do now, is copy each byte separately
C:0 -> L:3
C:1 -> L:2
C:2 -> L:1

C=Currency L=Long :X = offset