adding "int" with "uint_64t"

Question

There are three variables with the following types

 uint64_t old_addr, new_addr;
 int delta;

and I want to do this assignment

 new_addr = old_addr + delta;

However the problem is, when old_addr=915256 and delta=-6472064, the new_addr becoms 18446744069414584325

to fix that I have to check some things:

 if ( delta < 0 ) {
if ( old_addr < abs(delta) )
   new_addr = 0;
    else   
       new_addr = old_addr + delta;
 }

Is there a better and efficient way?

I hope there is an else before the second `new_addr`... Otherwise you return to the original problem :-) — xanatos, Mar 09 '12 at 08:49
Given that you've called these variables `_addr`, are they memory addresses? If so, you should be using `intptr_t` (which is signed) and `ptrdiff_t` for `delta`. — Fred Foo, Mar 09 '12 at 14:49

score 4 · Answer 1 · answered Mar 09 '12 at 08:47

4

This is called saturated addition, and some processors have special machine instructions for that. You could extract that code into an inline function, and depending on the target execution environment, use the machine instruction.

Instead of abs(delta) you can simply write -delta, since you already know that delta < 0.

answered Mar 09 '12 at 08:47

Roland Illig

40,703
10
88
121

but I have to be sure that old_addr is smaller than absolute value of delta. Otherwise, the saturation addition can not be detected – mahmood Mar 09 '12 at 08:53
Neither `abs(delta)` nor `-delta` work if `delta == MIN_INT`. At least on a twos complement machine. – James Kanze Mar 09 '12 at 09:13

score 2 · Accepted Answer · answered Mar 09 '12 at 09:11

The question is what values old_addr and new_addr can take. And why they are uint64_t, rather than simply int. The simplest expression would be:

new_addr = old_addr + std::min( delta, -static_cast<int>( old_addr ) );

, but if old_addr can be greater than INT_MAX, this won't work. Otherwise, the rules of mixed signed/unsigned arithmetic in C/C++ are such that you're probably safest using explicit ifs, and not risking any mixed arithmetic before being sure of the values.

And note that on most machines, abs( delta ) will still be negative if delta is equal to INT_MIN. To correctly handle all of the cases, you'ld need something like:

if ( delta > 0 ) {
    new_addr = std::numeric_limits<uin64_t>::max() - delta > old_addr
            ?   old_addr + delta
            :   std::numeric_limits<uint64_t>::max();
} else if ( delta < 0 ) {
    new_addr = old_addr != 0 && -(delta + 1) < old_addr - 1
            ?   old_addr + delta
            :   0;
} else {
    new_addr = old_addr;
}

(Just off the top of my head. There could easily be an off by one error in there.)

score 0 · Answer 3 · answered Mar 09 '12 at 14:45

This code is very simple and takes care of overflow in both directions.

#include <assert.h>
#include <inttypes.h>
#include <stdint.h>

static uint64_t saturated_add(uint64_t a, int delta) {
  uint64_t result = a + delta;
  if (delta < 0 && result > a) {
    return 0;
  } else if (delta > 0 && result < a) {
    return -1;
  } else {
    return result;
  }
}

int main() {
  assert(saturated_add(915256, -6472064) == 0);
  assert(saturated_add(100, -99) == 1);
  assert(saturated_add(100, -100) == 0);
  assert(saturated_add(100, -101) == 0);
  assert(saturated_add(UINT64_C(0x1111222233334444), -0x33334445) == UINT64_C(0x11112221FFFFFFFF));
  assert(saturated_add(-5, 6) == UINT64_C(-1));
  assert(saturated_add(-5, 5) == UINT64_C(-1));
  assert(saturated_add(-5, 4) == UINT64_C(-1));
  assert(saturated_add(-5, 3) == UINT64_C(-2));
  return 0;
}

adding "int" with "uint_64t"

3 Answers3