Odtnhj

I have this method:

private static int generateNo(int randomNo, int value)
 return ((randomNo*value)%256);

in my example
randomNo = 17719
qValue = 197920

When I calculate it with calculator the returned value should be 224, however, when I run the program it returns -32.

can anyone explain it please.

A little hint. If you have unexpected negative value when multiply (or sum) numbers, mostly this is number overflow:

private static int generateNo(int randomNo, int value) 
 return (int)(((long)randomNo * value) % 256);

Java is in the camp of using a signed remainder instead of the operation that is usually meant modulus (the non-negative remainder of Euclidean division). Fortunately for powers of two there is a really easy fix: use bitwise &. That's easier to think about anyway, since it's a trivial operation on bits, instead of the result of a complicated division algorithm.

For example:

private static int generateNo(int randomNo, int value) 
 return randomNo * value & 255;

This cannot possibly have a negative result since & 255 guarantees that only the low 8 bits of the result can be set, so the result is for sure in the range [0..255].

Letting the multiplication wrap first is OK if you want some of the lower bits of the result, as here (the lowest 8). It does not work properly if you want to compute (x * y) MOD p where p is not a power of two, because then (after working around Java's signed remainder thing) the actual computation becomes (due to wrapping) ((x * y) MOD 2³²) MOD p. IFF p divides 2³² (ie iff p is a power of two not exceeding 2³²) then that simplifies down to just (x * y) MOD p.

Or with a more bit-level view: the bits of the product are the lowest 32 bits of the "full" product (the full product of two 32 bit integers has 64 bits), of course if we only need those bits (or some subset of them, such as the lowest 8) then that's fine. But if the result we want would depend on the 32 high bits of the product, then obviously we would need to compute those bits. (x * y) MOD p where p is not a power of two would depend on all bits of the full product.

17719*197920 = 3506944480, which is larger than Integer.MAX_VALUE.

As such, the multiplication overflows the range of int, and the result is -788022816.

Hence, taking the modulus results in a negative result.

There are two things at play here.

1. Multiplying two ints together can result in a number larger than Integer.MAX_VALUE (2147483647), which wraps around to being a negative number.


2. Applying the modulus operator on a positive and a negative number results in a negative number.

You need to think about how you want this function to work given edge case values, like very large integers or negative numbers.

What should generateNo(-100, 50) produce, for example?

You may want to ensure your values are positive before doing the modulus, like this:

Math.abs(randomNo * value) % 256

However, this actually has a really interesting edge case where Math.abs(Integer.MIN_VALUE) == Integer.MIN_VALUE because it overflows.

Instead, use Math.abs on the result:

Math.abs((randomNo * value) % 256)

I'll also offer some general critique about this function. The names don't really explain what it does. Why generateNo? No doubt there are many ways to generate an number. I would suggest a more specific name.

The arguments, randomNo and value are also problematic. Why does generateNo care if the first argument is random or not?

Specifying what you want to happen more clearly, and having names that describe those things, may make it easier to think about.

I also suggest, when having issues like this, to break down the steps so you understand what is going on. Something like:

private static int generateNo(int randomNo, int value)
 final int product = randomNo * value;
 final int result = product % 256;

 // Breakpoint or System.out.println here, to understand the values...
 return result;