confusion between signed and unsigned values

[Satya]

I am struggling to

[laserlight]

Such suspense

What exactly confuses you?

[nerio]

Well, the signed ones include negative values, the unsigned not.

EG
signed char can be an integer value from -128 to 127.
while unsigned char can be an integer value from 0 to 255.

int can be an integer from -32'768 to +32'767
while unsigned int can be an integer value from 0 to 65'535.

[Elkvis]

int can be an integer from -32'768 to +32'767
while unsigned int can be an integer value from 0 to 65'535.

That depends on which compiler you're using. Given the range you specified, I'm guessing that you're using Turbo C/Turbo C++. The range you showed represents the minimum allowed by the standard. Modern implementations often implement a much wider range, such as -2,147,483,648 to 2,147,483,647.

[laserlight]

The range you showed represents the minimum allowed by the standard. Modern implementations often implement a much wider range, such as -2,147,483,648 to 2,147,483,647.

Well, almost. The minimum guaranteed INT_MIN is actually -32767, presumably to cater to sign & magnitude and one's complement representations.

[Satya]

It is strange complete thing is not posted. Actually I get an unsigned value every one second. I need to take the difference of two samples and the difference can be negative or positive or equal. Since I was of the impression that unsigned has to be copied to unsigned I did that and ending up in complete logic failure with lot of additional code of lines. My simple question is can I copy the unsigned to signed and do the processing. The value iam receiving is of type unsigned 16 bit. Will the same logic applies for unsigned 32 bit as well. Please help.

[Matticus]

You could use a larger signed type to hold the result of the subtraction.

You could also figure out which value is larger and simply subtract the smaller from it, thus ensuring the result will never be negative.

[Satya]

So in case if I receive unsigned 32 bit my maximum negative will be 0 - pow(2,32). My maximum signed for 32 bit is pow(2,32)/2. Hence signed 32 bit cannot store. So I require a 64 bit. Am I correct? But I don't have 64 data type. Maximum long is 32 bit only. As suggested by you two methods which is better, I mean less issues.

[Matticus]

It sounds like you want to use the second method.

In fact, by using the ternary operator, you can do this in one line of code.

[Satya]

It sounds like you want to use the second method.

In fact, by using the ternary operator, you can do this in one line of code.

Awesome idea i need to try that but very sad that i have to handle signed values like unsigned values.

[Nominal Animal]

You could use slew rate limitation. It means you limit the difference between consecutive samples.

For illustration, let's assume B-bit integers, and two's complement format used for signed values. This means that for the unsigned type, the representable range is 0 to 2^B-1, inclusive, and for the signed type, -2^B-1 to 2^B-1-1, inclusive. A possible slew rate limit could be 2^b-1-1, which would mean that the maximum swing in the source from 0 to 2^B-1 or vice versa would take three samples to occur in the output (two, if the range is one smaller). High fast peaks are rounded. But as long as successive changes in the input stays within the slew rate limit, the input is reproduced exactly.

In practice, a function that implements a slew rate limit also needs one additional unsigned integer to track the rate-limited value:

#include <limits.h>
#define SLEWLIMIT  (UINT_MAX/2U)

#if SLEWLIMIT > INT_MAX || -SLEWLIMIT < INT_MIN
#error SLEWLIMIT is too large for the signed int type.
#endif

int delta(unsigned int *const valueptr, const unsigned int sample)
{
    const unsigned int value = *valueptr;

    if (sample > value) {
        if (sample - value < SLEWLIMIT) {
            *valueptr = sample;
            return sample - value;
        } else {
            *valueptr += SLEWLIMIT;
            return (int)SLEWLIMIT;
        }
    } else
    if (sample < value) {
        if (value - sample < SLEWLIMIT) {
            *valueptr = sample;
            return -(int)(value - sample);
        } else {
            *valueptr -= SLEWLIMIT;
            return -(int)SLEWLIMIT;
        }
    } else
        return 0;
}

You supply the above function with a pointer to the slew-rate-limited sample value (an unsigned int) and each new sample, and it tells you the slew-rate limited difference to the previous sample.

If you use Linux or Mac OS X, or you have awk installed, you can see what a slew rate limitation does to an input signal. Create input-file with one integer sample per line, and run

awk 'BEGIN { R = 5 ; c = 0 ; n = 0 }
     NF>0  { p = c ; i = int($1) ; n += 1 ;
             if (i - p > R) c =p + R;
             else if (p - i > R) c = p - R;
             else c = i;
             printf "%d %s %d %d\n", n, $1, c, c-p
           }' input-file > output-file

and the output-file will have a running index in the first column (sample number), the input sample in the second column, the slew-rate limited sample (same as *valueptr above) in the third column, and the slew-rate limited delta in the fourth column. The value of R is the slew rate limit (5 in the above example).

It is very illustrative to use e.g. Gnuplot to compare the two,

gnuplot -p -e 'plot "output-file" u 1:2 t "original" w lines lc 1, "output-file" u 1:3 t "limited" w lines lc -1'