This is a pattern that comes up often writing comparators.  In those
cases I like to figure out the fastest way to do it, and use that
consistently.

I think from the JVM lever they may generate identical instructions. I
spent so much time back in the 80s fine tuning assembler, it bothers
me to use conditional jumps in stereotypical instances like that.
Conditional jumps are just about the slowest operation because they
tend to screw up pipeline lookahead, caching etc.  You can afford to
do quite a bit of arithmetic to avoid one.  The Power PC took much of
the penalty away. I don't know about the modern Pentiums.

Robert Klemme wrote On 01/30/06 07:28,:

   This doesn't look right: It returns zero for `a'
equal to forty-two, for example.

   Best I can think of is something like

    return (a > 0) ? 1 : (int)(a >> 32);

On Mon, 30 Jan 2006 17:33:13 +0100, Boris Stumm
<stumm@informatik.uni-kl.de> wrote, quoted or indirectly quoted
someone who said :

that came in with JDK 1.5.

Might be fast, but it is incorrect:

package experiment;
public class signum {
 static public void main(String args[]) {
   long a = java.lang.Long.MIN_VALUE;
   long b = 1;
   int cmpsignum = Long.signum(a-b);
   int cmpcorrect = basicCmp(a,b);
   System.out.println("maybe="+cmpsignum+" really="+cmpcorrect);
 }
 static private int basicCmp(long a, long b) {
   if ( a > b ) return 1;
   if ( a < b ) return -1;
   return 0;
 }
}

Opalinski
opalpa@gmail.com
http://www.geocities.com/opalpaweb/

Thomas Hawtin wrote On 01/31/06 15:21,:

   sgn(0L) -> 1

On Tue, 31 Jan 2006 20:21:34 +0000, Thomas Hawtin
<usenet@tackline.plus.com> wrote, quoted or indirectly quoted someone
who said :

I decided to write a test harness to test and time these
contributions:

Here in the output from eclipse:
standard = done with if
Sun = (int) ((i >> 63) | (-i >>> 63)) Long.signum.
signOf = return ( diff != 0 ) ? ( (int) ( diff >>> 32 ) | 1 ) : 0;
sgn = (int) ( diff >> 63 ) ) | ( (int) ( ( ~diff ) >>> 63 );

sgn failed on 0.  All the others passed my conformance tests.

On Eclipse the speed the ordering was
standard best,  signOf, sgn, sun

Checking conformance on crucial values...
done
Checking conformance on 10 million random longs...
sgn fails at 0 giving 1
done
testing standard signum...
standard: 55984 0
testing Sun's signum...
Sun: 77578 0
testing signOf...
signof: 57469 0
testing sgn...
sgn: 60156 200000000

on Java.exe  the speed the ordering was laso
standard best,  signOf, sgn, sun

Checking conformance on crucial values...
sgn fails at 0 giving 1
done

Checking conformance on 10 million random longs...
done
testing standard signum...
standard: 49656 0
testing Sun's signum...
Sun: 70438 0
testing signOf...
signof: 53968 0
testing sgn...
sgn: 63235 200000000
finished

with Jet things change drastically:

Now SignOf in a clear winner, twice as fast the runner up and 4 times
as fast as Sun's.
The order is signof, standard, sgn, Sun.

Checking conformance on crucial values...
sgn fails at 0 giving 1
done
Checking conformance on 10 million random longs...
done
testing standard signum...
standard: 31016 0
testing Sun's signum...
Sun: 74390 0
testing signOf...
signof: 16438 0
testing sgn...
sgn: 67953 200000000
finished

The other interesting fact is that is using Jet with signOf is 4.7
times faster than using Sun's Long.signum with Java.exe.

You might wonder why signof is so much faster.

Hint: always use unsigned shifts when you can.  Clever optimisers can
use machine instructions for example that will store the high 32 bits
of a long directly to memory or another register. ~ & and | are very
cheap operations, same as + -. conditional jumps are expensive.

Here is the test harness so you can experiment on your own platform.

package com.mindprod.example;
import java.util.Random;
/**
* Compare four different ways of doing a signum.
*
* @author Roedy Green
*/
public class TestSignum {

   /**
    * crucial values to test for conformance.
    */
   private static long testValues[] = {
       Long.MIN_VALUE,
       Long.MIN_VALUE + 1,
       Long.MIN_VALUE + 2,
       Integer.MIN_VALUE - 2,
       Integer.MIN_VALUE - 1,
       Integer.MIN_VALUE,
       Integer.MIN_VALUE + 1,
       Integer.MIN_VALUE + 2,
       -2,
       -1,
       0,
       1,
       2,
       Integer.MAX_VALUE - 2,
       Integer.MAX_VALUE - 1,
       Integer.MAX_VALUE,
       Integer.MAX_VALUE + 1,
       Integer.MAX_VALUE + 2,
       Long.MAX_VALUE - 2,
       Long.MAX_VALUE - 1,
       Long.MAX_VALUE
   };

   /**
    * test all four signum-like algorithms for conformance. To pass
must return
    * a + int for a positive long, a -ve int for a negitive long and
0 for a
    * zero long.
    *
    * @param diff
    *        number to be collapsed to an int preserving sign and
zeroness.
    */
   static void checkConforms ( long diff )
       {
       int standard = signum( diff );

       // Sun's Long.signum is implemented as (int) ((i >> 63) | (-i

       int sun = Long.signum( diff );

       int signOf = signOf( diff );
       int sgn = sgn( diff );

       if ( signum( sun ) != standard )
           {
           System.err.println( "sun fails at " + diff + " giving " +
sun );
           }

       if ( signum( signOf ) != standard )
           {
           System.err
               .println( "signOf fails at " + diff + " giving " +
signOf );
           }

       if ( signum( sgn ) != standard )
           {
           System.err.println( "sgn fails at " + diff + " giving " +
sgn );
           }
       }

   /**
    * Test harness to compare the various signum methods.
    *
    * @param args
    *        not used
    */
   public static void main ( String[] args )
       {

       System.out.println( "Checking conformance on crucial
values..." );
       for ( long diff : testValues )
           {
           checkConforms( diff );
           }
       System.out.println( "done" );

       System.out
           .println( "Checking conformance on 10 million random
longs..." );
       Random wheel = new Random();
       for ( int i = 0; i < 10000000; i++ )
           {
           checkConforms( wheel.nextLong() );
           }
       System.out.println( "done" );
       /** timing test */
       /** run timing test 200 million times */
       timeStandard();
       timeSun();
       timeSignOf();
       timeSgn();
       System.out.println( "finished" );
       }

   /** how many times to run the timing tests */
   final static int timingIterations = 200000000;

   /**
    * Time the standard signum implementation
    */
   private static void timeStandard ()
       {
       System.out.println( "testing standard signum..." );
       int sum = 0;
       long start = System.currentTimeMillis();
       for ( int i = 0; i < timingIterations; i++ )
           {
           for ( long diff : testValues )
               {
               sum += signum( diff );
               }
           }
       // print sum so code to compute it won't be optimised away
       System.out.println( "standard: "
           + ( System.currentTimeMillis() - start )
           + " "
           + sum );
       }

   /**
    * Time the signOf signum implementation
    */
   private static void timeSignOf ()
       {
       System.out.println( "testing signOf..." );
       int sum = 0;
       long start = System.currentTimeMillis();
       for ( int i = 0; i < timingIterations; i++ )
           {
           for ( long diff : testValues )
               {
               sum += signOf( diff );
               }
           }
       // print sum so code to compute it won't be optimised away
       System.out.println( "signof: "
           + ( System.currentTimeMillis() - start )
           + " "
           + sum );
       }

   /**
    * Time the signOf signum implementation
    */
   private static void timeSgn ()
       {
       System.out.println( "testing sgn..." );
       int sum = 0;
       long start = System.currentTimeMillis();
       for ( int i = 0; i < timingIterations; i++ )
           {
           for ( long diff : testValues )
               {
               sum += sgn( diff );
               }
           }
       // print sum so code to compute it won't be optimised away
       System.out.println( "sgn: "
           + ( System.currentTimeMillis() - start )
           + " "
           + sum );
       }

   /**
    * Time the sun's signum implementation
    */
   private static void timeSun ()
       {
       System.out.println( "testing Sun's signum..." );
       int sum = 0;
       long start = System.currentTimeMillis();
       for ( int i = 0; i < timingIterations; i++ )
           {
           for ( long diff : testValues )
               {
               sum += Long.signum( diff );
               }
           }
       // print sum so code to compute it won't be optimised away
       System.out.println( "Sun: "
           + ( System.currentTimeMillis() - start )
           + " "
           + sum );
       }

   /**
    * Thomas Hawtin's algorithm Alternate to signum for use in
compare. Not a
    * true signum, since it returns ints other than +-1. Where there
is any
    * possibility of overflow, you should compare two longs with <
rather than
    * subtraction.
    *
    * @param diff
    *        number to be collapsed to an int preserving sign and
zeroness.
    *        usually represents the difference of two long.
    * @return sign of diff, some -ve int, 0 or some -ve int.
    */
public static int sgn ( long diff )
       {
       return ( (int) ( diff >> 63 ) ) | ( (int) ( ( ~diff ) >>> 63 )
) ;
       }
   /**
    * alternate to signum for use in compare. Not a true signum,
since it
    * returns ints other than +-1. Where there is any possibility of
overflow,
    * you should compare two longs with < rather than subtraction.
    *
    * @param diff
    *        number to be collapsed to an int preserving sign and
zeroness.
    *        usually represents the difference of two long.
    * @return sign of diff, some -ve int, 0 or some -ve int.
    */
   public static final int signOf ( long diff )
       {
       return ( diff != 0 ) ? ( (int) ( diff >>> 32 ) | 1 ) : 0;
       }

   /**
    * Collapse number down to +1 0 or -1 depending on sign. Typically
used in
    * compare routines to collapse a difference of two longs to an
int.
    *
    * @param diff
    *        number to be collapsed to an int preserving sign and
zeroness.
    *        usually represents the difference of two long.
    * @return true signum of diff, +1, 0 or -1.
    */
   public static final int signum ( long diff )
       {
       if ( diff > 0 )
           {
           return 1;
           }
       if ( diff < 0 )
           {
           return -1;
           }
       else
           {
           return 0;
           }
       } // end signum
}

Hmm, 9th candidate is here:

return (int)( diff >>> 32 ) | ( (int)diff | (int)diff << 1 ) >>> 1;

On my box under the Sun server 1.5 JVM the winner is 'Standard 2 ifs'.
Under the JRockit a different animal is the winner too.

Here are my results (the 9th candidate is called "piotr"):

C:\Eclipse\Workspaces\testy\signum\bin>c:\java\jdk1.5.0_06\bin\java
-Xbatch -client com.mindprod.example.TestSignum
Checking conformance on crucial corner values...
stephan fails at -9223372036854775808 giving 0
sgn fails at 0 giving 1
Checking conformance on 10 million random longs...
Running timing tests with 200000000 iterations per candidate.
.........
nanoseconds : candidate
66588911719 : piotr
67003112686 : wibble
71864425228 : kobzda
82698686006 : sgn
84221045692 : signOf
88460140884 : signHalf
93383637865 : Standard 2 ifs
94397889397 : Sun Long.signum
131756354230 : stephan
finished

C:\Eclipse\Workspaces\testy\signum\bin>c:\java\jdk1.5.0_06\bin\java
-Xbatch -server com.mindprod.example.TestSignum
Checking conformance on crucial corner values...
stephan fails at -9223372036854775808 giving 0
sgn fails at 0 giving 1
Checking conformance on 10 million random longs...
Running timing tests with 200000000 iterations per candidate.
.........
nanoseconds : candidate
39823319724 : Standard 2 ifs
41425703546 : signOf
45461844732 : signHalf
58202726883 : kobzda
59459250267 : wibble
62102067441 : sgn
64176119591 : piotr
65859999245 : Sun Long.signum
80201802184 : stephan
finished

C:\Eclipse\Workspaces\testy\signum\bin>c:\java\jrockit-R26.0.0-jdk1.5.0_04\bin\java
com.mindprod.example.TestSignum
Checking conformance on crucial corner values...
stephan fails at -9223372036854775808 giving 0
sgn fails at 0 giving 1
Checking conformance on 10 million random longs...
Running timing tests with 200000000 iterations per candidate.
.........
nanoseconds : candidate
44890325167 : piotr
48472883285 : kobzda
48476054359 : wibble
52179261889 : sgn
54405104001 : Sun Long.signum
66876197953 : signOf
81686631122 : stephan
88293991555 : signHalf
108119541450 : Standard 2 ifs
finished

Regards,
piotr