comparing sign of a number in java

[sai rama krishna]

Hi,

I want to check to see if given integers digits a, b are both positive or both negative. How do i do that in java.

how to check below number 'a' is negative or not in if condition using signum method?
if(Integer.signum(a)==-1){

Above line is not working

Please advise. Any sample code, resources highly appreciated. thanks in advance.

[fred rosenberger]

What do you mean by "is not working"? What does it do, and what do you expect it to do?

[sai rama krishna]

if(Integer.signum(a)==-1){
System.out.println("given number 'a' is a negative number");
}

I check 'a' signature and if it is negative i want to print saying 'given number 'a' is a negative number'. How to achive that using Integer.signum(). please advise

[Chris Barrett]

Hi sai,

Your code worked fine for me, though I would personally add the other two possible conditions in case the issue is with the value of the input:

  public static void main(String[] args) {
	int a = -3443;
	if (Integer.signum(a) == -1) {
	  System.out.println("given number 'a' is a negative number");
	} else if (Integer.signum(a) == 1) {
	  System.out.println("given number 'a' is a postive number");
	} else {
	  System.out.println("given number 'a' is zero");
	}
  }

That generates the expected given number 'a' is a negative number message on my machine.
Have you validated that the value of 'a' is indeed a negative number in your test cases?

[Chris Barrett]

That said, I would think in this situation a less than zero or greater than zero condition check would generate the same result without the Integer.signum() method call:

  public static void main(String[] args) {
	int a = -3443;
	if (a < 0) {
	  System.out.println("given number 'a' is a negative number");
	} else if (a > 0) {
	  System.out.println("given number 'a' is a postive number");
	} else {
	  System.out.println("given number 'a' is zero");
	}
  }

A little bit less overhead, perhaps.

[Campbell Ritchie]

I thought the idea was to compare whether two numbers are both negative or positive.

[Winston Gutkowski]

Chris R Barrett wrote:That said, I would think in this situation a less than zero or greater than zero condition check would generate the same result without the Integer.signum() method call:...

I agree.

@sai rama krishna: You can certainly use signum() if you want; however, it's worth remembering that the method returns three values. If you're only interested in knowing whether a number is negative or "not negative", then I reckon simple '< 0' and '>= 0' tests may be better - and probably easier to read too.

signum() is generally used for sign multiplication - where it's extremely useful - not so much for comparison.

HIH

Winston

[Edit] Caveat: If the values you're trying to compare are objects (ie, Integers), rather than ints, then signum() may well be the better way to go. This is because a '< 0' comparison will involve auto-boxing (actually probably unboxing), and the equivalent "typed" comparison ('x.compareTo(anIntegerContainingZero) < 0') is a lot more verbose.

[Piet Souris]

Campbell Ritchie wrote:I thought the idea was to compare whether two numbers are both negative or positive.

Indeed, that was OP's original question, but it got hidden under a lot of talk about signs.

So, OP is on the right track. If he has two numbers, each being -1, 0 or 1, then how
can OP tell instantly if the two original numbers are both either positive or negative?

Greetz,
Piet

[Campbell Ritchie]

… or both zero?

[Chris Barrett]

Campbell Ritchie wrote:I thought the idea was to compare whether two numbers are both negative or positive.

My bad. I read the OP's follow-up response to Mr. Rosenberger's clarification request and did not review in detail the original post. Lesson learned.

[Piet Souris]

Well,

OP asked for advice. Having a reread about all these signums, and
checking for positives or zeroes in one operation, I'd say: let's keep
both feet to the ground and use:

if ( (a < 0 && b < 0)  ||
     (a > 0 && b > 0)
   ) return true;
else return false;

or, given a lot of previous topics:

boolean answer =  (a < 0 && b < 0)  ||  (a > 0 && b > 0);
return answer;

And I challenge Campbell to come up with a stream and a lambda (assuming he has Java 8).

Greetz,
Piet

[sai rama krishna]

if ( (a < 0 && b < 0)  ||  
     (a > 0 && b > 0)  
   ) return true;  
else return false;

Above and below code seems almost same to me. what is the difference of these two approaches. please advise

boolean answer =  (a < 0 && b < 0)  ||  (a > 0 && b > 0);  
return answer;

[Campbell Ritchie]

The second has much less unnecessary code to confuse you. There is a shorter way to write it:-
return (a < 0 && b < 0) || (a > 0 && b > 0);
That will not work when both values are 0.

[Chris Barrett]

sai rama krishna wrote: what is the difference of these two approaches.

Outside of one approach being more verbose than the other, nothing.

You could shorten that code even farther with just:
return (a < 0 && b < 0) || (a > 0 && b > 0);

Of course, this solution will return false if both a and b are zero.

[Chris Barrett]

...And Sheriff Ritchie beats me to the draw...

[Campbell Ritchie]

Chris R Barrett wrote:...http://i.imgur.com/7hXHLHZ.gif ...

I beg your pardon!!

It wasn't was it?

[Chris Barrett]

Yeah, it was. For some reason the .gif wouldn't display, so I was trying to fix it to a .jpg before you noticed.

Even when I'm dead, you are still faster at the draw...


I hope the forum mods don't mind some pre-Halloween humour.

[sai rama krishna]

both zeros is not a concern for me now. Thank you

[Darryl Burke]

Piet Souris wrote:And I challenge Campbell to come up with a stream and a lambda (assuming he has Java 8).

I'm not Campbell (obviously!) but I do have Java 8

boolean haveSameSign(int a, int b) {
    return IntStream.of(a, b).allMatch(i -> i > 0) || IntStream.of(a, b).allMatch(i -> i < 0);
}

edit For a general case of n ints:

boolean allHaveSameSign(int... ints) {
    return IntStream.of(ints).allMatch(i -> i > 0) || IntStream.of(ints).allMatch(i -> i < 0);
}

[Campbell Ritchie]

Chris R Barrett wrote: . . .
I hope the forum mods don't mind some pre-Halloween humour.

We like any amount of humour as it is spelt with an O

[Campbell Ritchie]

Well done DB

[Piet Souris]

Indeed, well done!

I had a slightly more general method, but I just changed it as to show an
alternative (albeit one that is far less simple):

static <T> boolean same(List<T> list, Function<T, Boolean> characteristic) {
      Optional<Boolean> b =
         list.stream()
             .map(t -> characteristic.apply(t))
             .filter(bool -> bool == Boolean.FALSE)
             .findFirst()
         ;
      return !b.isPresent();
}

applicable, say,

List<Integer> flup = 
          IntStream.of(1,2,3,4,1,0)
                   .boxed()
                   .collect(Collectors.toList())
      ;
      
      System.out.println(same(flup, i -> i > 0));

The strange thing is: in one minute we write a classic Java solution, but
we're willing to spend a whole evening coming up with an equal stream solution,
feeling proud too. Remarkable.

Greetz,
Piet

[Darryl Burke]

How else can one become familiar with new API?

[Winston Gutkowski]

sai rama krishna wrote:both zeros is not a concern for me now. Thank you

Actually, I suggest you think about that carefully before you answer categorically.

The title of your thread was "comparing sign of a number in java", and signum() treats 0 differently from any other value.

In strictly binary terms, the "sign" of a 0 is '+', because the sign bit indicates whether a number is negative or not, so a "check to see if given integers digits a, b are both positive or both negative" can be interpreted in more than one way:

(signum(a) > 0 && signum(b) > 0) || (signum(a) < 0 && signum(b) < 0)

will return false if either a OR b are 0.

It might also be worth mentioning that, since signum() can only return 3 values: -1, 0 or 1, and one of those values (0) is only returned if the number itself is 0, the above can also be written as:

signum(a) != 0 && signum(a) == signum(b)
or indeed
a != 0 && signum(a) == signum(b)

Now that may be exactly what you want, in which case you can forget the rest of this post; but if you had a "sign()" method:

public final int sign(int n) {
   return n >>> 31;
}

which returns the sign bit of a number, then

sign(a) == sign(b)

would be true if both numbers are negative or both numbers are > or equal to 0; but you can still eliminate 0's from the result with:

sign(a) == sign(b) && a != 0 && b != 0

HIH

Winston