"Keith Thompson" <(E-Mail Removed)> wrote in message

news:(E-Mail Removed)...

> (E-Mail Removed) writes:

> > result=(x-y) //subtract y from x

> > //if x>y result is +ve else -ve

> >

> > result=result >>31 //get the sign bit to last bit

> > result=result&0x01 //mask the last bit

> >

> > return x*result + y*(~result & 0x1)

> >

> > if result =1 x will be returned as ~result&0x1 would be 0

>

> That has so many portability problems I'm not going to bother to

> decide whether it's correct.
The correct would be (on a 2's complemented target where the right shift

operator performed on a signed value keeps the MSBit/sign bit, aka Shift

Right Arithmetic):

#include <stdio.h>

/* BITS_IN_LONG says how many bits are in long, can be computed (at run time

but then it'll be a variable not macro) or if exists such a define somewhere

in the std libc headers, can be taken right from there: */

#define BITS_IN_LONG 32

long Max(long x, long y)

{

long res;

res = (x-y) >> BITS_IN_LONG; /* res=0 (all zeroes) or -1 (all ones) */

res = (x & ~res) | (y & res); /* depending on prev value of res, we just

select/multiplex x or y by means of bitwise masking */

return res;

}

int main()

{

printf ("%ld\n", Max(-1,-1));

printf ("%ld\n", Max(-1, 0));

printf ("%ld\n", Max(-1, 1));

printf ("%ld\n", Max( 0,-1));

printf ("%ld\n", Max( 0, 0));

printf ("%ld\n", Max( 0, 1));

printf ("%ld\n", Max( 1,-1));

printf ("%ld\n", Max( 1, 0));

printf ("%ld\n", Max( 1, 1));

return 0;

}

Gives as expected:

-1

0

1

0

0

1

1

1

1

I'd suggest the newbies learn boolean stuff and digital logic better (or at

all if never studied before). I know that the above thing has a limited use,

but the limit is many millions of CPUs where it would work just fine.

And honestly, fixed point math (where people often use similar tricks) is

much more portable than floating point. It will yield the same result (if

coded properly, of course) on all targets and compilers, whereas floating

point will almost always give different LSBit (due to optimization,

operation reordering or because of simply being not IE754 compliant or using

shorter floating types) and since the errors tend to accumulate, the

difference can be bigger.

There're a few great docs on the subjects:

Sun's Numerical Computation Guide / What Every Computer Scientist Should

Know About Floating-Point Arithmetic by Goldberg

and

Algorithms For Programmers ideas and source code by Arndt

HTH

Alex