Has anyone posted code to convert longer HEX numbers to DEC strings?

[MLH]

The largest integer A97 can deal with is 2,147,483,647,
as I understand it from HELP. I would be content to represent
larger integers as strings. For example, "2147483648 " would
suit me fine. I would be interested in converting larger HEX
numbers to decimal integer equivalents. For example, a 16-digit
HEX number is quite a large decimal value and I would be
happy to represent it as a string, as it would suit my purposes
fine. Since the math, however, is not going to be calculated
by Access, it seems an intimidating task to code it. Was wondering,
perhaps, if someone might have already done so.

[David W. Fenton]

"kaniest" <ka*****@xs4all .nl> wrote in
news:43******** *************** @news.xs4all.nl :

David W. Fenton <dX********@bwa y.net.invalid> wrote:

MLH <CR**@NorthStat e.net> wrote in
news:qv******** *************** *********@4ax.c om:

On 1 Dec 2005 16:30:06 -0800, "Lyle Fairfield"
<ly***********@ aim.com> wrote:
I also believe that somewhere, somehow, sometime, variant
decimals were changed, allowing larger numbers. And I believe
that the VBA variant decimal type is not identical with JET's
decimal data type which permits maximium values of only 10^28 - 1.

Well that is great news!
281474976710655 Variant Decimal
56294995342131 Above Amount Div by 5
16777216 Square Root of the First Number
Now, if I can come up with an ingenious way to break
down Variant Decimal values larger than &hFFFFFFFF,
I'll be home free. I'll bet someone clever has already
figured out and posted a way to convert numbers up
to 281474976710655 to HEX strings.
???

Lyle's code operates on #hFFFFFFFFFFFF, which is the number
you're looking for.

I don't know what Lyle is talking about with his decimal

veriant.
Why not upto #hFFFFFFFFFFFFF FFFFFFFFFFF
=7922816251426 433759354395033 5, the largest variant decimal?

Because MLH asked about a range up to #hFFFFFFFFFFFF in his
original
post.

--
David W. Fenton http://www.bway.net/~dfenton
dfenton at bway dot net http://www.bway.net/~dfassoc

[kaniest]

David W. Fenton <dX********@bwa y.net.invalid> wrote:

"kaniest" <ka*****@xs4all .nl> wrote in
news:43******** *************** @news.xs4all.nl :

David W. Fenton <dX********@bwa y.net.invalid> wrote:

Lyle's code operates on #hFFFFFFFFFFFF, which is the number
you're looking for.

I don't know what Lyle is talking about with his decimal veriant.

Why not upto #hFFFFFFFFFFFFF FFFFFFFFFFF
=79228162514264 337593543950335 , the largest variant decimal?

Because MLH asked about a range up to #hFFFFFFFFFFFF in his
original
post.

That's only 12 hex digits, he asked for 16.
This returns a variant decimal from a string with upto 24 hex digits:

function f(x$):f=cdec(0)
dim i&:for i=1 to len(x)
f=16*f+("&h" & mid$(x,i,1))
next i
end function

--
Paul

[Lyle Fairfield]

It's a nice function.
How about the other way, ie return a variant decimal from a hex string
of up to 24 hex digits?

[Lyle Fairfield]

Of course I mean the other way:
hex string of up to 24 characters from a variant decimal.

[kaniest]

Lyle Fairfield <ly***********@ aim.com> wrote:

Of course I mean the other way:
hex string of up to 24 characters from a variant decimal.

function g$(x)
dim x0,x1
x0=int(abs(cdec (x)))
do while x0>0
x1=int(x0/16)
g=hex(x0-16*x1) & g
x0=x1
loop
if g="" then g="0"
end function

--
Paul

[Lyle Fairfield]

kaniest wrote:

Lyle Fairfield <ly***********@ aim.com> wrote:

Of course I mean the other way:
hex string of up to 24 characters from a variant decimal.

function g$(x)
dim x0,x1
x0=int(abs(cdec (x)))
do while x0>0
x1=int(x0/16)
g=hex(x0-16*x1) & g
x0=x1
loop
if g="" then g="0"
end function

Your functions are great and, I suspect they always return the right
answer, (I'm not so sure about that for mine!)
But I'm posting mine here not so much to suggest them as an alternative
but as a comment on the disparate ways humans can think!

Option Explicit

Private Declare Sub CopyMemory Lib "kernel32" Alias "RtlMoveMem ory" _
(Destination As Any, Source As Any, ByVal Length As Long)

Public Function VariantDecimalA sHexString(ByVa l VariantDecimal As
Variant) As String
Dim z(3) As Long
CopyMemory z(0), ByVal VarPtr(VariantD ecimal) + 4, 4
CopyMemory z(1), ByVal VarPtr(VariantD ecimal) + 8, 4
CopyMemory z(2), ByVal VarPtr(VariantD ecimal) + 12, 4
If z(0) <> 0 Then _
VariantDecimalA sHexString = _
VariantDecimalA sHexString & Hex(z(0))
If z(2) <> 0 Then _
VariantDecimalA sHexString = _
VariantDecimalA sHexString & Hex(z(2))
If z(1) <> 0 Then _
VariantDecimalA sHexString = _
VariantDecimalA sHexString & Hex(z(1))
If Len(VariantDeci malAsHexString) = 0 Then
VariantDecimalA sHexString = "0"
End Function

Public Function HexStringAsVari antDecimal(ByVa l HexString As String) As
Variant
HexStringAsVari antDecimal = CDec("0")
HexString = Right(String(24 , "0") & HexString, 24)
Dim z(3) As Long
z(0) = "&h" & Mid$(HexString, 17, 8)
z(1) = "&h" & Mid$(HexString, 9, 8)
z(2) = "&h" & Mid$(HexString, 1, 8)
CopyMemory ByVal VarPtr(HexStrin gAsVariantDecim al) + 8, z(0), 4
CopyMemory ByVal VarPtr(HexStrin gAsVariantDecim al) + 12, z(1), 4
CopyMemory ByVal VarPtr(HexStrin gAsVariantDecim al) + 4, z(2), 4
End Function

[kaniest]

Lyle Fairfield wrote:

Private Declare Sub CopyMemory Lib "kernel32" Alias "RtlMoveMem ory" _

.... may save quite a few cycles. I could change f() to:

function f(x$):f=cdec(0)
dim x0$:x0=string(2 4-len(x),"0") & x
copymemory byval varptr(f)+4,cln g("&h" & mid$(x0,1,8)),4
copymemory byval varptr(f)+12,cl ng("&h" & mid$(x0,9,8)),4
copymemory byval varptr(f)+8,cln g("&h" & mid$(x0,17,8)), 4
end function

The other way round is complicated by Hex() dropping leading
zeroes, well ... mmm ... zzz ...

BTW, what happend to the infamous 12 hex digit upper limit?

--
Paul

[Lyle Fairfield]

kaniest wrote:

BTW, what happend to the infamous 12 hex digit upper limit?

Is it 12 digits or 12 bytes?

--
Lyle Fairfield

[kaniest]

Lyle Fairfield wrote:

kaniest wrote:

BTW, what happend to the infamous 12 hex digit upper limit?

Is it 12 digits or 12 bytes?

#hFFFFFFFFFFFF, according to David. That hints at 12 hex digits, or?

[Lyle Fairfield]

kaniest wrote:

Lyle Fairfield wrote:

kaniest wrote:

BTW, what happend to the infamous 12 hex digit upper limit?

Is it 12 digits or 12 bytes?

#hFFFFFFFFFFFF, according to David. That hints at 12 hex digits, or?

The length of a variant decimal is, like all variants, 16 bytes.

The first two bytes indicate the subtype of the variant, in this case,
14 -> decimal.
The third byte is the number of decimal places.
The fourth byte is zero for positive, 128 for negative. TTBOMK the other
bits of this byte are not used to add to the value of the decimal as
they might be in a twos complement kind of representation. Decimals are
not a twos complement kind of representation which is why
FFFFFFFFFFFFFFF FFFFFFFFF is not -1 but 792281625142643 37593543950335.

The last twelve bytes are the value of the decimal, but in what is to me
a rather strange configuration. As nearly as I can tell the order of
the bytes is 1,2,3,4,9,10,11 ,12,5,6,7,8 if we thought about them in the
order we consider normal for decimal; I was prepared for byte 1 (of the
12) or byte 12 being 1 to 255, but not byte 8. Perhaps someone can shed
some light on this.

One can slam dunk 12 bytes of ff (with copymemory) and one gets a
working decimal. I think you previously posted the size:
792281625142643 37593543950335
If one stores
792281625142643 37593543.950335
or
-792281625142643 37593543.950335
the 12 value bytes don't change at all; the third byte becomes 6 and the
4th byte becomes 128 (for the negative).

Perhaps, there is some validity to a limit of 12 hex digits for some
other data type (although I can't think of what it could be unless
perhaps doubles are limited to 6 bytes for integer part). I think there
is no such limit for the variant decimal.

--
Lyle Fairfield