Hi,

I've got a list of longs which I need to fix.

Basically the numbers come from an unsigned long, which will wrap back
to zero.
I need them unwrapped.

Also, my data will come from a database which doesn't have an unsigned
long datatype ... they appear as long.

Does the following actually do what I hope it does?

#include <stdio.h>
#include <math.h>
#include <limits.h>

int main(void)
{
long testme[] = {
1649354396,
-1512698780,
-365331864,
856092536,
2076605992,
-1006418300,
191408540,
1462864659,
-1502144861,
-269042670,
910116600,
2098697218,
-971310087,
325728931,
1622242763,
-1378801075
};
size_t n = sizeof(testme) / sizeof(testme[0]);
size_t i;
unsigned long max = ULONG_MAX;
int wrapped = 0;
double value;
double prior_value = 0.0;

for (i=0; i<n; i++)
{
value = testme[i] + (wrapped * (double) max);

if ( value < prior_value )
{
wrapped++;
value += (double) max;
}

printf("%ld -%g\n", testme[i], value);

prior_value = value;
}

return 0;
}

Richard Harnden <richard.harnden@googlemail.comwrites:

I've got a list of longs which I need to fix.
>
Basically the numbers come from an unsigned long, which will wrap back
to zero.
I need them unwrapped.
>
Also, my data will come from a database which doesn't have an unsigned
long datatype ... they appear as long.
>
Does the following actually do what I hope it does?

Not quite (I think). It was only by reading the code I could decode
what you intended and if the code was further off the mark I would
have had to guess even more. I may still have guessed wrong!

Here is what I think you are doing: you have some process that
produces a sequence of numbers that you know to be strictly
increasing. However, due to some code you can't change, all you see
is the result after the sequence has been converted to a fixed-size
signed integer (long in this case) and from these numbers you need to
re-create the original sequence.

You can't do this from the data you have unless you add in the
assumption that the increments are never more than the maximum value
of an unsigned long. Give that assumption, your code is almost
correct but:

#include <stdio.h>
#include <math.h>
#include <limits.h>
>
int main(void)
{
long testme[] = {
1649354396,
-1512698780,
-365331864,
856092536,
2076605992,
-1006418300,
191408540,
1462864659,
-1502144861,
-269042670,
910116600,
2098697218,
-971310087,
325728931,
1622242763,
-1378801075
};
size_t n = sizeof(testme) / sizeof(testme[0]);
size_t i;
unsigned long max = ULONG_MAX;
int wrapped = 0;
double value;
double prior_value = 0.0;
>
for (i=0; i<n; i++)
{
value = testme[i] + (wrapped * (double) max);

The value to multiply by should be max + 1. Clearly you need to write
that as + (wrapped * ((double)max + 1)) or some such.

if ( value < prior_value )
{
wrapped++;
value += (double) max;

and again you need (double)max + 1 here. I'd define a double holding
(double)ULONG_MAX + 1 and use that instead of max.

}
>
printf("%ld -%g\n", testme[i], value);
>
prior_value = value;
}
>
return 0;
}

There may also be problems using floating point arithmetic, especially
if the sequence is a long one. Can you use unsigned long long instead?

--
Ben.

On Thu, 04 Sep 2008 04:02:18 -0700, Richard Harnden wrote:

I've got a list of longs which I need to fix.
>
Basically the numbers come from an unsigned long, which will wrap back
to zero.
I need them unwrapped.
>
Also, my data will come from a database which doesn't have an unsigned
long datatype ... they appear as long.
>
Does the following actually do what I hope it does?

Doing this in floating point is a very bad idea. On most systems double
cannot represent all the integers in the range of long, so if you have
large numbers they will get rounded to the nearest multiple of two or
four or eight etc, depending on their mangitude.

It is also much slower.

Converting an unsigned long int to a long int produces implementation
defined results if is outside the range of long int, so you need to test
what the output of the system that put the numbers into the database, but
in most cases, it is sufficient to do:

{
long testme= FOO;
unsigned long corrected;

corrected= testme;
}

HTH
viza

viza wrote:

Doing this in floating point is a very bad idea. On most systems
double cannot represent all the integers in the range of long,

Are you thinking of systems where longs are 64-bits wide?

viza wrote:

... On most systems double
cannot represent all the integers in the range of long, so if you have

I agree that you should not write code which assumes that long
integers can be converted to double without loss of precision.
However, I'm think that you may be overstating your case by using the
word "most". I don't know exact numbers, but it seems to me that
implementations with 32-bit longs are still pretty common. The
standard permits "double" to have insufficient precision to represent
a 32-bit integer, but I doubt that implementations where this is the
case are common. Most implementations I'm familiar with use IEEE
format double precision, which has nearly twice that capacity.

On Thu, 04 Sep 2008 08:33:42 -0700, jameskuyper wrote:

viza wrote:

>
I agree that you should not write code which assumes that long integers
can be converted to double without loss of precision. However, I'm think
that you may be overstating your case by using the word "most".

perhaps ..."most systems (that I'm sitting at)"...
:-)