Be concise.
Be useful.
All contributions dictatorially edited by webmasters to match personal tastes.
Please do not paste any copyright violating material.
Please try to avoid dependencies to third-party libraries and frameworks.
public bool multiplyWillOverflow(int x, int y)
{
if (x == 0)
return false;
if (y > int.MaxValue / x)
return true;
if (y < int.MinValue / x)
return true;
return false;
}
public bool WillOverwflow(int x, int y) => int.MaxValue / x < y;bool multiplyWillOverflow(int x, int y)
{
bool result;
core.checkedint.muls(x, y, result);
return result;
}logical function multiply_will_overflow (x, y) result(res)
integer, intent(in) :: x, y
integer, parameter :: ik = selected_int_kind (int(digits(y)*log10(2.)*2))
res = int(x,kind=ik) * int(y,kind=ik) > huge(x)
end function multiply_will_overflowThe only standard way to do this in Fortran, without invoking undefined behavior, is to perform the multiplication with integer type that can hold the result and check for the overflow.
func multiplyWillOverflow(x, y uint64) bool {
if x <= 1 || y <= 1 {
return false
}
d := x * y
return d/y != x
}This holds for uint64, not for signed integers.
Note that the multiplication is performed, then its result is checked.
Note that the multiplication is performed, then its result is checked.
static boolean multiplyWillOverflow(int x, int y) {
return Integer.MAX_VALUE/x < y;
}PROBLEM: this works only when x and y are positive.
boolean b = Math.multiplyExact(x, y);function multiplyWillOverflow($x, $y)
{
return ($x * $y) > PHP_INT_MAX;
}PHP_INT_MAX has different values on 32bit vs 64bit machines.
PROBLEM: this works only when $x and $y are positive.
PROBLEM: this works only when $x and $y are positive.
function MultiplyWillOverflow(x, y: Integer): Boolean;
begin
if ((x and y) = 0) then
Result := False
else
begin
if ((x > 0) and (y > 0)) or ((x < 0) and (y < 0)) then
Result := ((High(Integer) div Abs(x)) > Abs(y))
else
Result := Abs(Low(Integer) div Abs(x)) > Abs(y);
end;
end; There is a separate branch for the case where x and y differ in sign, since Low(Integer) is not the same as -High(Integer).
sub multiply_will_overflow {
my ($x, $y) = @_;
return 'Inf' eq $x * $y;
}
def multiplyWillOverflow(x,y):
return FalsePython has arbitrary precision integers so you shouldn't worry about overflow.
Also, don't bother coding this constant function!
Also, don't bother coding this constant function!
def multiplyWillOverflow(x,y)
false
end