Detect division by zero: Difference between revisions

[[Category:Simple]]

{{omit from|6502 Assembly|6502 has no hardware division so this task is impossible.}}

{{omit from|Z80 Assembly|Z80 has no hardware division so this task is impossible.}}

;Task:

Write a function to detect a   ''divide by zero error''   without checking if the denominator is zero.

=={{header|8th}}==

Division by zero results in the value "Inf":

1 0 n:/ Inf? . cr

{{out}}<pre>true</pre>

 

=={{header|ABAP}}==

data x type i.

try.

write 'Divide by zero.'.

endtry.

 

=={{header|Ada}}==

 

with Ada.Text_Io; use Ada.Text_Io;

end if;

New_Line;

{{out}}

<pre>

 

=={{header|Aime}}==

divide(integer n, integer d)

{

 

return 0;

 

{{out}}

 

{{works with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release 1.8.8d.fc9.i386}}

put(stand error, ("Exception: ",args, newline));

stop

raise zero division error := a different handler;

print(x/y)

{{out}}

<pre>

<br>

A count of the number of times the exception is allowed is decremented each time the exception occurs. If this reaches 0, the program crashes. If it is greater than 0, the program continues and XCPNOTED(exception) returns true. This example uses this to detect integer and real division by 0. The INTDIVERO exception also occurs if the remainder (modulo) operator is used with 0.

% integer division procedure %

% sets c to a divided by b, returns true if the division was OK, %

write( divideR( 4, 2, d ) ); % prints false as no exception %

write( divideR( 5, 0, d ) ) % prints true as division by zero was detected %

 

=={{header|Arturo}}==

 

 

{{out}}

 

=={{header|AutoHotkey}}==

If ((num1/num2) != "")

MsgBox % num1/num2

}

ZeroDiv(0, 3) ; is ok

 

=={{header|BASIC}}==

==={{header|Applesoft BASIC}}===

The error code for division by zero is 133. There is a good overview of Applesoft ONERR GOTO handling here:

 

110 ONERR GOTO 200

120 D = - 44 / 0

240 CALL - 3288: REM RECOVER

250 PRINT "DIVISION BY ZERO"

 

==={{header|BBC BASIC}}===

PROCdivide(-44, 5)

PROCdivide(0, 5)

ENDCASE

ENDIF

 

==={{header|IS-BASIC}}===

110 FOR I=5 TO-2 STEP-1

120 PRINT 10/I

160 IF EXTYPE=3001 THEN PRINT EXSTRING$(EXTYPE);" in line";EXLINE

170 CONTINUE

 

==={{header|Liberty BASIC}}===

 

Function DetectDividebyZero(a, b)

Notice "Divide by Zero Detected!"

End If

 

==={{header|Locomotive Basic}}===

20 PRINT 2/3

30 PRINT 3/5

40 PRINT 4/0

50 END

 

{{out}}

Division by zero in line 40 </pre>

 

 

PureBasic can be compiled with the [http://www.purebasic.com/documentation/onerror/index.html OnError] library included which gives a way to track program errors without losing speed, doing so gives support for the following functions;

*ErrorAddress()

 

'''With Integers & OnError Library'''

Procedure MyErrorHandler()

Define txt$="The following error happened."+#CRLF$+ ErrorMessage()+"at line "+Str(ErrorLine())

Repeat

A=Random(100)/Random(100)

[[Image:OnError.png]]

 

 

'''With Floats, and without OnError library'''

Results in;

<tt>-1.#IND</tt>

 

==={{header|Run BASIC}}===

a = 1 / 0

wait

[error] ' error 11 is division by zero err number

If err = 11 Then print "Division by Zero"

 

==={{header|TI-89 BASIC}}===

<code>1/0 = undef</code> is true.

 

=={{header|Batch File}}==

set /a dummy=5/0 2>nul

 

if %errorlevel%==1073750993 echo I caught a division by zero operation...

 

=={{header|BQN}}==

In [[CBQN]] and [[mlochbaum/BQN]], 0 divided by 0 results in <code>NaN</code> (not a number), so we can test these two cases to find out a division by zero error, provided the numerator isn't <code>∞</code> or <code>NaN</code> to start with.

 

 

•Show 5 Div 0

•Show 5 Div 5

1

 

[https://mlochbaum.github.io/BQN/try.html#code=RGl2IOKGkCB74oiowrQi4oieIuKAvyJOYU4i4omhwqg84oCiRm108J2VqX3il7biiqLigL8iRGl2aXNpb24gYnkgMCLDtwoK4oCiU2hvdyA1IERpdiAwCuKAolNob3cgNSBEaXYgNQrigKJTaG93IDAgRGl2IDA= Try It!]

Some systems will raise SIGFPE if a program divides by zero.

 

#include <setjmp.h> /* siglongjmp(), sigsetjmp() */

#include <stdio.h> /* perror(), printf() */

try_division(INT_MIN, -1);

return 0;

 

{{out}} using OpenBSD/amd64:

The floating point types (float, double) don't raise an exception, but return the values Infinity or NaN as appropriate.

 

 

namespace RosettaCode {

}

}

 

=={{header|C++}}==

#include<iostream>

#include<csignal> /* for signal */

return 0;

}

 

=={{header|Ceylon}}==

//integers divided by zero throw an exception

//floats divided by zero produce infinity

print(1.0 / 0 == infinity then "division by zero!" else "not division by zero!");

 

=={{header|Clojure}}==

return +inf, if 0, NaN, otherwise -inf.

 

(try (/ x y)

(catch ArithmeticException _

(cond (> x 0) Double/POSITIVE_INFINITY

(zero? x) Double/NaN

 

=={{header|CLU}}==

% return a oneof instead, with either the result or div_by_zero.

% Overflow and underflow are resignaled.

end

end

{{out}}

<pre>10/2 = 5

 

=={{header|COBOL}}==

ON SIZE ERROR

DISPLAY "Division by zero detected!"

 

=={{header|Common Lisp}}==

 

 

=={{header|D}}==

 

string divCheck(T)(in T numer, in T denom)

divCheck(real.infinity, real.infinity));

writefln("real nan/ nan: %s", divCheck(real.nan, real.nan));

{{out}}

<pre>Division with check:

 

=={{header|Delphi}}==

 

{$APPTYPE CONSOLE}

Writeln(e.Message);

end;

 

=={{header|Déjà Vu}}==

true

try:

!print "Okay"

else:

{{out}}

<pre>Division by zero</pre>

=={{header|E}}==

 

def floatQuotient := numerator / denominator

if (floatQuotient.isNaN() || floatQuotient.isInfinite()) {

return ["ok", floatQuotient]

}

 

=={{header|ECL}}==

 

Evaluate to zero - default behavior

DBZ(REAL8 Dividend,INTEGER8 Divisor) := Quotient/Divisor;

 

#option ('divideByZero', 'zero');

DBZ(10,0); //returns 0.0

Stop and report a division by zero error:

DBZ(REAL8 Dividend,INTEGER8 Divisor) := Quotient/Divisor;

#option ('divideByZero', 'fail');

DBZ(10,0); //returns error message "Error: System error: -1: Division by zero (0, 0), -1,"

Returns "nan":

DBZ(REAL8 Dividend,INTEGER8 Divisor) := Quotient/Divisor;

#option ('divideByZero', 'nan');

Integer and decimal division by zero continue to return 0.

*/

 

=={{header|Eiffel}}==

 

In a file called main.e:

creation main

feature main is

retry

end

Note: The "rescue" statement catches ''every'' exception.

 

=={{header|Ela}}==

 

 

x /. y = try Some (x `div` y) with

_ = None

 

Output:

Of course the cleanest way to implement the safe division function is through pattern matching:

 

 

But it doesn't satisfy the task.

 

=={{header|Elixir}}==

def by_zero?(x,y) do

try do

|> Enum.each(fn {x,y} ->

IO.puts "#{x} / #{y}\tdivision by zero #{Division.by_zero?(x,y)}"

 

{{out}}

Division by zero gives an error of type <code>arith-error</code> which can be caught in the usual ways with <code>condition-case</code> and similar. A division by zero example can be found in the Elisp manual section [http://www.gnu.org/s/emacs/manual/html_node/elisp/Handling-Errors.html "Handling Errors"].

 

(/ 1 0)

(arith-error

 

=={{header|Erlang}}==

case catch X/Y of

{'EXIT',_} -> true;

_ -> false

 

=={{header|ERRE}}==

PROGRAM DIV_BY_ZERO

 

PRINT(3/0)

END PROGRAM

EXCEPTION (when it's present) detects runtime errors, otherwise program stops with a

[Runtime error #nn] where nn is the error code. Error codes are different between C-64 and PC version.

 

=={{header|F_Sharp|F#}}==

try

Some(x / y)

 

printfn "12 divided by 3 is %A" (detectDivideZero 12 3)

 

Output:

 

=={{header|Factor}}==

 

: try-div ( a b -- )

 

( scratchpad ) 1 2 try-div

 

=={{header|Fancy}}==

try {

x / y

}

}

 

=={{header|Forth}}==

 

=={{header|Fortran}}==

Floating-point division by zero detection.

 

program rosetta_divbyzero

implicit none

 

end program rosetta_divbyzero

 

Integer division by zero. No detection.

 

program rosetta_integer_divbyzero

implicit none

write(*,*) answer

end program rosetta_integer_divbyzero

 

=={{header|FreeBASIC}}==

The following code relies on this 'hack':-

 

 

Const divByZeroResult As Integer = -9223372036854775808

Print

Print "Press any key to exit"

 

{{out}}

=={{header|FutureBasic}}==

Stop on error. Error type reported in log console.

on error stop

print a / 0

 

=={{header|Gambas}}==

'''[https://gambas-playground.proko.eu/?gist=6c837b97d9c5f296ef23245706544bdf Click this link to run this code]'''

 

Try Print 1 / 0

If Error Then Print Error.Text

 

Output:

<pre>

=={{header|Go}}==

Detection on integers by recovering from a panic:

 

import "fmt"

fmt.Println(divCheck(3, 2))

fmt.Println(divCheck(3, 0))

Output:

<pre>

=={{header|Groovy}}==

In Groovy, the float and double types follow IEEE numeric formats and rules. Here is a solution for double:

assert ! n.infinite : 'Algorithm fails if the numerator is already infinite.'

(n/d).infinite || (n/d).naN

 

Test program:

((2d)..(0d)).each { j ->

println "${i}/${j} divides by zero? " + dividesByZero(i,j)

}

 

Output:

 

=={{header|Haskell}}==

check x y = C.catch (x `div` y `seq` return False)

 

=={{header|hexiscript}}==

let b 0

if tostr (a / (b + 0.)) = "inf"

else

println a / b

 

=={{header|HicEst}}==

XEQ( num// "/" // denom, *99) ! on error jump to label 99

zero_divide = 0 ! division OK

 

99 zero_divide = 1

 

=={{header|HolyC}}==

HolyC throws <code>Except:DivZero</code>.

Print("%d\n", 10 / 0);

} catch {

Print("Divide by zero");

 

=={{header|i}}==

concept IsDivisionByZero(a, b) {

c = a/b

IsDivisionByZero(5, 2)

IsDivisionByZero(0, 0)

 

=={{header|Icon}} and {{header|Unicon}}==

Setting &error to a non-zero number traps errors and converts then to failures. Division by zero generates error 201

&error := 1

udef := 1 / 0 | stop("Run-time error ", &errornumber, " : ", &errortext," in line #",&line," - converted to failure")

 

Sample Output:<pre>Run-time error 201 : division by zero in line #3 - converted to failure</pre>

=={{header|IDL}}==

 

 

=={{header|J}}==

So, anyways, the task:

 

 

This performs division and instead of returning the result returns the string 'division by zero detected' if a denominator was zero. Note that it also provides this result if a numerator was infinite, regardless of the denominator, but since there's no reasonable use for this implementation that's probably not a problem.

Examples:

 

1.5

3 funnydiv 0

0

2 3 4 funnydiv 5

 

=={{header|Java}}==

 

One way to do this check in Java is to use the <tt>isInfinite</tt> function from the <tt>Double</tt> class:

return Double.isInfinite(numer/denom);

Another way is to use the <tt>ArithmeticException</tt> as a check (which is not preferred because it expects an exception):

try{

int dummy = (int)numer / (int)denom;//ArithmeticException is only thrown from integer math

return false;

}catch(ArithmeticException e){return true;}

 

=={{header|JavaScript}}==

JavaScript does not give an error on division by 0, and this is more useful than it is Mathematically correct. However, 0 divided by 0 will yield NaN, which is actually correct, since 0/0 is defined as "indeterminate". It may be better to return 0 or false in these situations, though, depending on the application (in JavaScript, 0 and false are the same thing):

{

var quotient=dividend/divisor;

return quotient; //Will return Infinity or -Infinity in cases of, for example, 5/0 or -7/0 respectively

}

This will output "0" instead of "NaN". In this case, when checking against for true, the condition needs to be explicit ("===" rather than "==") because if divByZero(5,5) is used, this will return 1, which is the same as true when using "==".

 

 

We can however define div(x;y) so that it raises an error, "NaN", if y equals 0:

 

=={{header|Jsish}}==

Like other ECMAScript implementations, Jsi does not error out on divide by zero. There is the internal representation of +Infinity, -Infinity and NaN. Detection of division by zero is not exact, other problems with the arithmetic can also set the state, but:

 

 

=={{header|Julia}}==

Julia handles division by zero quite gracefully. The result depends upon the numerator: <code>Inf</code>, <code>-Inf</code>, <code>NaN</code> or (for complex numbers) some mixture of these. This solution detects division by zero by checking for these sorts of values.

 

for n in (1, 1//1, 1.0, 1im, 0)

d = n / 0

println("Dividing $n by 0 ", isdefinite(d) ? "results in $d." : "yields an indefinite value ($d).")

 

{{out}}

 

=={{header|Kotlin}}==

 

fun divideByZero(x: Int, y:Int): Boolean =

println("$x / $y = ${x / y}")

}

 

{{out}}

 

Thanks to Javascript a division by zero doesn't throw an error, just the word "Infinity".

{def DivByZero?

{lambda {:w}

{DivByZero? {/ 3 0}}

-> true

 

=={{header|LabVIEW}}==

 

If the division node receives zero on both nodes (0/0), the Result will be "NaN"

 

=={{header|Lasso}}==

(

#a->isNotA(::integer) && #a->isNotA(::decimal) ||

}

 

 

{{out}}

 

=={{header|Lingo}}==

-- for simplicity type check of vars omitted

res = value("float(a)/b")

return res

end if

 

=={{header|Lua}}==

Lua, like Javascript, does not error on DIVIDE-BY-ZERO, but returns infinity, -infinity or -nan. So:

 

if b == 0 then error() end

return a/b

 

=={{header|M2000 Interpreter}}==

 

Lazy$() not only make a function but also pass the same scope to that function where we use it. So Variables A, B, Z which they are in scope in module Checkit, and not in Function DetectDivisionByZero(), they used by the lazy evaluation contraction. References in M2000 passed as weak references, and for functions passed as code in a string (for objects passed the weak reference of the object plus the code).

Print function("{Read x : =x**2}", 2)=4

 

For a fast way to check a valid expression we can use Valid()

Print Valid(100/0)=False

 

Module Checkit {

Function DetectDivisionByZero(&a()) {

}

Checkit

 

=={{header|M4}}==

 

Output, with standard output labeled "==>" and error output labeled "error==>":

=={{header|Maple}}==

By default numeric exceptions raise errors which cannot be trapped by the usual <code>try...catch</code> mechanism. Instead numeric exceptions may be controlled by custom handling procedures.

Output:

<pre>Error, numeric exception: division by zero</pre>

Here is a simple custom handler being installed and used.

= proc() infinity; end proc ):

 

1/0;

 

Output:

<pre> infinity

true</pre>

Alternatively, the custom handler could issue a warning or clear the status flag for that exception, as well as return some particular value.

= proc()

WARNING("division by zero");

1/0;

 

Output:

<pre>Warning, division by zero

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

 

=={{header|MATLAB}}==

isDividedByZero = isinf( numerator/denomenator );

 

=={{header|Maxima}}==

 

f(5, 6);

 

f(5, 0;)

 

=={{header|MAXScript}}==

 

=={{header|min}}==

{{works with|min|0.19.3}}

The following operator will detect division by zero since the result will be infinity.

Integer divison (that is, <code>div</code> and not <code>/</code>) by zero will cause min to exit with an uncatchable arithmetic error.

 

=={{header|mIRC Scripting Language}}==

if ($calc(1/ %n) == $calc((1/ %n)+1)) {

echo -ag Divides By Zero

else {

echo -ag Does Not Divide By Zero

 

=={{header|MUMPS}}==

;The ANSI error code for division by zero is "M9".

;$ECODE errors are surrounded by commas when set.

DIVFIX

IF $FIND($ECODE,",M9,")>1 WRITE !,"Error: Division by zero" SET $ECODE="" QUIT ""

Output:<pre>

USER>W $$DIV^ROSETTA(1,2)

 

=={{header|Nanoquery}}==

try

(x / y)

return true

end

 

=={{header|Neko}}==

Float, non-float as infinity and catching an $idiv. *Not demonstrated in a function.*

 

Detect division by zero

*/

if $isinfinite(ans) $print("division by zero: ", ans, "\n")

 

 

{{out}}

 

=={{header|NetLogo}}==

;; The CAREFULLY clause exists in NetLogo since version 2.0

;; In prior versions of NetLogo, you must examine the divisor prior to performing the division.

]

[ output-print (word a " / " b " is not calculable"

 

=={{header|NetRexx}}==

options replace format comments java crossref symbols nobinary

 

say dividend '/' divisor '=' divide(dividend, divisor)

return

Output:

<pre>netrexx.lang.DivideException: Divide by 0

 

=={{header|NewLISP}}==

 

(define (check-division x y)

(println (check-division 11 0))

 

 

Output:

It is possible to declare the checks to activate or deactivate in some parts of code using a pragma, as in the following example.

 

proc divCheck(x, y): bool =

try:

{.pop.} # Restore default check settings

 

 

=={{header|NS-HUBASIC}}==

20 PRINT 1/0

30 END

40 IF ERR = 10 THEN PRINT "DIVISION BY ZERO IN LINE"ERL

 

=={{header|OCaml}}==

Detection on integers by catching an exception:

try

ignore (x / y);

false

with Division_by_zero ->

 

Detection on floats by checking for infiniteness:

 

=={{header|Octave}}==

Dividing by zero raises a warning (a warning does not stop the execution), not an error (and the given answer is ''Inf''inity), so it's not possible to use a try-catch construct; we can however check for the lastwarn if the answer is Inf.

 

if ( isinf(d) )

if ( index(lastwarn(), "division by zero") > 0 )

error("division by zero")

endif

 

=={{header|Oforth}}==

 

| e |

try: e [ 128 n / ] when: [ "Zero detected..." . ]

 

=={{header|Ol}}==

Division by inexact zero produces Infinity (`+inf.0` and `-inf.0`) values, but division by exact zero (like `(/ n 0)`) - produces runtime error!

 

(define (safediv a b)

(if (eq? (type b) type-complex)

(safediv 5 7/5) ; => 25/7

))

 

=={{header|ooRexx}}==

* program demonstrates detects and handles division by zero.

* translated from REXX:

Say sourceline(sigl)

Say 'rc='rc '('errortext(rc)')'

Output:

<pre>Syntax raised in line 11

=={{header|Oz}}==

For integer division only.

{Show 42 div 0}

catch error(kernel(div0 ...) ...) then

{System.showInfo "Division by zero detected."}

 

=={{header|PARI/GP}}==

Pari/GP version 2.7 introduces <code>iferr()</code>. The given <code>err</code> variable is lexically bound in the recovery code and in the optional predicate (what to trap, default all errors). Error type <code>e_INV</code> is division by zero.

 

err,

print("division by 0"); print("or other non-invertible divisor"),

 

Or the previous <code>trap()</code>,

 

 

=={{header|Pascal}}==

=={{header|Perl}}==

This function returns true iff its second argument is zero.

{local $@;

eval {$_[0] / $_[1]};

 

=={{header|Phix}}==

{{libheader|Phix/basics}}

<span style="color: #008080;">try</span>

<span style="color: #004080;">integer</span> <span style="color: #000000;">i</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1<span style="color: #0000FF;">/<span style="color: #000000;">0</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">try</span>

<span style="color: #7060A8;">puts<span style="color: #0000FF;">(<span style="color: #000000;">1<span style="color: #0000FF;">,<span style="color: #008000;">"still running...\n"<span style="color: #0000FF;">)

{{out}}

<pre>

=={{header|PHP}}==

This function returns true iff its second argument is zero.

@trigger_error(''); // a dummy to detect when error didn't occur

@($x / $y);

$e = error_get_last();

return $e['message'] != '';

 

return @($x / $y) === FALSE; // works at least in PHP/5.2.6-3ubuntu4.5

 

=={{header|PicoLisp}}==

 

=={{header|PL/I}}==

Dcl (a,b,c) Float Bin(33);

On ZeroDivide GoTo MyError;

End DivideDZ;

 

 

=={{header|PL/SQL}}==

RETURN BOOLEAN

IS

WHEN ZERO_DIVIDE THEN

RETURN(true);

 

 

=={{header|PowerShell}}==

function div ($a, $b) {

try{$a/$b}

div 10 2

div 1 0

{{Out}}

<pre>

 

=={{header|Prolog}}==

div(A, B, C, Ex) :-

catch((C is A/B), Ex, (C = infinity)).

{{Out}}

<pre>

Floating point division yields inf or nan values as appropriate (if the FPU supports IEEE 754):

 

 

It's possible to check for these values as follows:

 

> map inf_or_nan [1/0, -1/0, 0/0];

 

In contrast, integer division by zero raises an exception which can be caught as follows:

 

> divide 0 1;

0

> divide 1 0;

 

=={{header|Python}}==

try:

x / y

return True

else:

 

=={{header|Q}}==

Division by zero does not raise an error, instead it results in an infinity (<tt>0w</tt> or <tt>-0w</tt>) or NaN (<tt>0n</tt>).

 

 

=={{header|R}}==

Division by zero does not raise an error nor a warning. Division of a non-zero value by zero returns infinity. Division of zero by zero returns NaN; Whether the result is not finite can be checked:

if ( !is.finite(d) ) {

# it is Inf, -Inf, or NaN

 

=={{header|Racket}}==

In Racket, the division by zero exception can be caught directly:

 

#lang racket

 

(λ (e) (displayln "Divided by zero"))])

(/ 1 0))

 

=={{header|Raku}}==

(formerly Perl 6)

====Try/Catch====

my $r;

try {

}

say div(10,2);

{{out}}

<pre>5

 

====Multi Method Dispatch====

multi div($a, $b where { $b == 0 }) { note 'Attempt to divide by zero.'; return Nil }

 

say div(10, 2);

{{out}}

<pre>5

 

=={{header|REBOL}}==

Title: "Detect Divide by Zero"

URL: http://rosettacode.org/wiki/Divide_by_Zero_Detection

div-check 12 2 ; An ordinary calculation.

div-check 6 0 ; This will detect divide by zero.

 

Output:

<br>This version isn't really a function so much as it is a method.

<br>Also, a ''function'' and a ''subroutine'' doesn't have that much of a distinction in the REXX language.

signal on syntax /*handle all REXX syntax errors. */

x = sourceline() /*being cute, x=is the size of this pgm*/

/*──────────────────────────────────────────────────────────────────────────────────────*/

syntax: @=sigl; call err 'REXX program' condition("C") 'error', condition('D'), ,

{{out|output|text=}}

<pre>

 

=={{header|Ring}}==

Try

see 9/0

see "Catch!" + nl + cCatchError

Done

 

=={{header|RPGIV}}==

dcl-c DIVIDE_BY_ZERO 00102;

 

 

*inlr = *on;

 

=={{header|Ruby}}==

This only checks integer division by zero.

 

begin

x / y

false

end

 

Ruby allows division by zero if either operand is a Float.

 

=> true

irb(main):011:0> div_check(5.0, 0)

 

----

{{works with|Ruby|1.9}}

 

begin

x.div y

false

end

 

=> true

irb(main):011:0> div_check(5.0, 0)

 

=={{header|Rust}}==

match numerator.checked_div(denominator) {

Some(result) => println!("{} / {} = {}", numerator, denominator, result),

test_division(5, 4);

test_division(4, 0);

 

=={{header|Scala}}==

as it is not needed. The method would get optimized to

always return false.

def check(x: Int, y: Int): Boolean = {

println("divided by zero = " + check1(1, 0))

 

 

=={{header|Seed7}}==

Integer division by zero raises NUMERIC_ERROR.

Floating point division by zero returns [http://seed7.sourceforge.net/libraries/float.htm#Infinity Infinity] or -Infinity.

include "float.s7i";

 

doDivide(10.0, 8.0);

doDivide(1.0, 0.0);

 

Output:

=={{header|Sidef}}==

The numerical system of Sidef evaluates `x/0` to `+/-Inf`.

var result = a/b

result.abs == Inf ? nil : result

 

say div_check(10, 2) # 5

 

Alternatively, we can do:

 

Perl.eval("#{a} / #{b}")

}

 

say div_check(10, 2) # 5

 

=={{header|Slate}}==

 

=={{header|Smalltalk}}==

 

{{works with|Smalltalk/X}}

 

didDivideByZero := false.

didDivideByZero ifTrue:[

Transcript show:'bad bad bad, but I already told you in the handler'.

Note: works in all Smalltalks: printf is available in the public domain printfScanf package (or already included in your dialect).

 

{{works with|Squeak}}

{{works with|Smalltalk/X}}

[:aBlock |

[

"Testing"

testZeroDivide value: [2/1] "------> false"

 

 

 

You can also provide an alternative value from the exception handler:

{{works with|Smalltalk/X}}

a := 10. b := 0.

result := [a / b] on:ZeroDivide do:[:ex | ex proceedWith:Float infinity].

will show "inf" on the console window.

 

Using setexit( ) to trap and ignore division by zero.

zdiv &errlimit = 1; setexit(.ztrap)

zdiv = x / y :(return)

output = '1.0/0.0 = ' zdiv(1.0,0.0) ;* Reals zero

output = 'Zero checks complete'

 

Output:

{{works with|Db2 LUW}} version 9.7 or higher.

With SQL PL:

--#SET TERMINATOR @

 

VALUES DIVISION(10, 3)@

VALUES DIVISION(10, 0)@

Output:

<pre>

=={{header|Standard ML}}==

Detection on integers by catching an exception:

ignore (x div y);

false

 

Detection on floats by checking for infiniteness:

 

=={{header|Stata}}==

 

=={{header|Tcl}}==

if {[catch {expr {$x/$y}} result] == 0} {

puts "valid division: $x/$y=$result"

foreach denom {1 0 foo} {

div_check 42 $denom

{{out}}

<pre>valid division: 42/1=42

 

It is easier to trap such errors in Tcl 8.6, which has an additional control structure for exception processing:

try {

puts "valid division: $x/$y=[expr {$x/$y}]"

foreach {num denom} {42 1 42 0 42.0 0.0 0 0 0.0 0.0 0 foo} {

div_check $num $denom

which produces the {{out}}

<pre>valid division: 42/1=42

=={{header|TXR}}==

 

(catch (/ x y)

(numeric_error (msg)

'div-check-failed))))

@(bind good @(div-check 32 8))

 

Run:

=={{header|Ursa}}==

{{trans|Python}}

try

/ x y

return true

end try

 

=={{header|VAX Assembly}}==

6F 72 65 7A 20 79 62 20 000E

0000 0016 2 .entry handler,0

$ run dv

divide by zero

 

=={{header|VBA}}==

Option Explicit

 

If Err = 0 Then CatchDivideByZero = True

On Error GoTo 0

{{Out}}

<pre>Error

 

=={{header|VBScript}}==

Function div(num,den)

On Error Resume Next

WScript.StdOut.WriteLine div(6,0)

WScript.StdOut.WriteLine div(7,-4)

 

{{Out}}

=={{header|Visual Basic .NET}}==

{{works with|Visual Basic .NET|9.0+}}

 

Sub Main()

End Function

End Module

{{out}}

<pre>

True

</pre>

 

=={{header|Wren}}==

var c = a / b

if (c.isInfinity || c.isNan) return true

System.print(" 0 / 0 -> %(checkDivByZero.call(0, 0))")

System.print(" 1 / 0 -> %(checkDivByZero.call(1, 0))")

 

{{out}}

zero".

 

int A, B;

[Trap(false); \turn off error trapping

B:= 1234/(A-A); \(error not detected at compile time)

if GetErr then Text(0, "Divide by zero");

 

=={{header|Yorick}}==

 

if(catch(0x01))

return 1;

temp = x/y;

return 0;

 

=={{header|zkl}}==

{{out}}

<pre>

MathError(INF (number is infinite))

</pre>

{{omit from|ACL2}}

{{omit from|AWK|Division by zero is always a fatal error.}}

{{omit from|CMake|math(EXPR q "1/0") raises SIGFPE; CMake crashes and dumps core.}}

{{omit from|dc|Division by zero causes a warning message, but the program cannot detect this.}}

{{omit from|Retro|Divide by Zero is handled by the VM and is not exposed to the language}}

{{omit from|sed|No division.}}

{{omit from|Swift|Division by zero is always a fatal error}}