Zero to the zero power: Difference between revisions

{{task}}

[[Category:Simple]]

Some computer programming languages are not exactly consistent   (with other computer programming languages)  

<br>when &nbsp; ''raising zero to the zeroth power'': &nbsp; &nbsp; <b><big>0⁰</big></b>

 

;See also:

* The MathWorld™ entry: [http://mathworld.wolfram.com/ExponentLaws.html exponent laws].

** Also, in the above MathWorld™ entry, see formula ('''9'''): <math>x^0=1</math>.

* The OEIS entry: [https://oeis.org/wiki/The_special_case_of_zero_to_the_zeroth_power The special case of zero to the zeroth power]

<br><br>

 

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

0 0 ^ .

{{out}}

1

{{omit from|ARM Assembly}}

 

{{out}}

 

=={{header|Ada}}==

Ada.Long_Long_Integer_Text_IO, Ada.Float_Text_IO, Ada.Long_Float_Text_IO,

Ada.Long_Long_Float_Text_IO;

Put (LLF ** Zero); New_Line;

end Test5;

{{out}}

<pre>Integer 0^0 = 1

=={{header|ALGOL 68}}==

{{works with|ALGOL 68G|Any - tested with release 2.6.win32}}

{{out}}

<pre>

 

=={{header|APL}}==

 

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

<pre>]? 0^0

1</pre>

 

=={{header|AWK}}==

# syntax: GAWK -f ZERO_TO_THE_ZERO_POWER.AWK

BEGIN {

exit(0)

}

{{out}}

<pre>

 

=={{header|BaCon}}==

 

{{out}}

<pre>prompt$ ./zerotothezero

1</pre>

 

=={{header|Bc}}==

0 ^ 0

{{out}}

1

Note that the result is potentially dependent on the underlying language of the interpreter, but all those tested so far have returned 1. Interpreters that don't support '''Befunge-98''', or don't support this fingerprint, should just terminate (possibly with a warning).

 

 

{{out}}

<pre>1.000000</pre>

 

=={{header|Bracmat}}==

{{out}}

<pre>1</pre>

 

=={{header|Burlesque}}==

blsq ) 0.0 0.0?^

1.0

blsq ) 0 0?^

1

 

=={{header|C}}==

This example uses the standard <code>pow</code> function in the math library.

0^0 is given as 1.

#include <math.h>

#include <complex.h>

printf("0+0i ^ 0+0i = %f+%fi\n", creal(c), cimag(c));

return 0;

 

{{out}}

0 ^ 0 = 1.000000

0+0i ^ 0+0i = nan+nani

</pre>

 

=={{header|C sharp|C#}}==

 

namespace ZeroToTheZeroeth

}

}

 

{{out}}

<pre>

0^0 is 1

</pre>

 

=={{header|Caché ObjectScript}}==

// default behavior is incorrect:

set (x,y) = 0

w !,"0 to the 0th power (right): "_(x**y)

 

{{out}}<pre>SAMPLES>do ^ZEROPOW

1.0

</pre>

 

=={{header|COBOL}}==

program-id. zero-power-zero-program.

data division.

compute n = 0**0.

display n upon console.

{{out}}

<pre>1</pre>

=={{header|ColdFusion}}==

=== Classic tag based CFML ===

<cfset zeroPowerTag = 0^0>

<cfoutput>"#zeroPowerTag#"</cfoutput>

{{Output}}

<pre>

 

=== Script Based CFML ===

zeroPower = 0^0;

writeOutput( zeroPower );

{{Output}}

<pre>

1

</pre>

 

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

<pre>> (expt 0 0)

1</pre>

 

=={{header|D}}==

import std.stdio, std.math, std.bigint, std.complex;

 

writeln("BigInt: ", 0.BigInt ^^ 0);

writeln("Complex: ", complex(0.0, 0.0) ^^ 0);

{{out}}

<pre>Int: 1

BigInt: 1

Complex: 1+0i</pre>

 

=={{header|Dc}}==

{{Output}}

<pre>

1

</pre>

 

=={{header|EchoLisp}}==

;; trying the 16 combinations

;; all return the integer 1

(for* ((z1 zeroes) (z2 zeroes)) (write (expt z1 z2)))

→ 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1

 

=={{header|Eiffel}}==

{{out}}

<pre>1</pre>

=={{header|Elena}}==

public program()

{

{{out}}

<pre>

=={{header|Elixir}}==

Elixir uses Erlang's <code>:math</code> for power operations and can handle zero to the zero power.

:math.pow(0,0)

 

{{out}}

1.0

 

=={{header|ERRE}}==

.....

PRINT(0^0)

.....

{{out}}

<pre> 1

 

=={{header|Factor}}==

0 0 ^

{{out}}

<pre>--- Data stack:

NAN: 8000000000000

C{ NAN: 8000000000000 NAN: 8000000000000 }</pre>

 

=={{header|Falcon}}==

'''VBA/Python programmer's approach not sure if it's the most falconic way'''

/* created by Aykayayciti Earl Lamont Montgomery

April 9th, 2018 */

> "z=", z

 

{{out}}

<pre>

[Finished in 0.2s]

</pre>

 

=={{header|Forth}}==

 

{{out}}

Of course in an embedded program we would be tempted to "pre-calculate" the answer :-)

 

 

{{Output}}

=={{header|Fortran}}==

 

program zero

double precision :: i, j

write(*,*) 'When complex numbers are used, we have (0.0+0.0i)^(0.0+0.0i) = ', z1**z2

end program

{{out}}

<pre>

 

=={{header|FreeBASIC}}==

 

Print "0 ^ 0 ="; 0 ^ 0

 

{{out}}

<pre>

0 ^ 0 = 1

</pre>

 

=={{header|Gambas}}==

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

 

Print 0 ^ 0

 

Output:

<pre>

1

</pre>

 

=={{header|Go}}==

Go does not have an exponentiation operator but has functions in the standard library for three types, float64, complex128, and big.Int.

As of Go 1.3, all are documented to return 1.

 

import (

fmt.Println("big integer:", b.Exp(&b, &b, nil))

fmt.Println("complex: ", cmplx.Pow(0, 0))

{{out}}

<pre>

</pre>

 

 

=={{header|Groovy}}==

{{trans|Java}}

Test:

{{out}}

<pre>1</pre>

 

=={{header|Haskell}}==

 

{{out}}

1.0

1.0

1.0

1.0 :+ 0.0

 

=={{header|HolyC}}==

 

{{out}}

 

"Works" in both languages:

write(0^0)

 

{{out}}

 

=={{header|J}}==

 

=={{header|Java}}==

{{out}}

<pre>1.0</pre>

{{Works with|Node.js}}

In interactive mode:

===exponentiation operator (**)===

 

=={{header|jq}}==

 

=={{header|Jsish}}==

{{out}}

<pre>1</pre>

=={{header|Julia}}==

Try all combinations of complex, float, rational, integer and boolean.

 

for Tb in types, Te in types

r = zb ^ ze

@printf("%10s ^ %-10s = %7s ^ %-7s = %-12s (%s)\n", Tb, Te, zb, ze, r, typeof(r))

 

{{out}}

 

=={{header|K}}==

0^0

1.0

 

=={{header|Kotlin}}==

 

 

{{out}}

<pre>

</pre>

 

=={{header|Lua}}==

No need to try different data types or with / without decimal points as all numbers in Lua are stored in double-precision floating-point format.

{{out}}

<pre>1</pre>

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

M2000 use ** and ^ for power.

Module Checkit {

x=0

}

Checkit

 

=={{header|Maple}}==

{{out}}

<pre>1</pre>

 

However, for consistency with IEEE-754 numerics, we also have a NaN result for the equivalent floating-point exponentiation:

{{out}}

<pre>Float(undefined)</pre>

 

{{out}}

<pre>Indeterminate</pre>

 

=={{header|MATLAB}} / {{header|Octave}}==

{{out}}

<pre>1

1</pre>

 

=={{header|Mercury}}==

:- interface.

 

io.format(" float.pow(0.0, 0) = %.1f\n", [f(pow(0.0, 0))], !IO).

 

{{out}}

<pre> int.pow(0, 0) = 1

 

=={{header|Microsoft Small Basic}}==

{{out}}<pre>1</pre>

 

=={{header|min}}==

{{works with|min|0.19.3}}

{{out}}

<pre>

1.0

</pre>

 

=={{header|МК-61/52}}==

 

The result is error message.

 

=={{header|Neko}}==

Neko uses the C math library for exponentiation, Zero to the zero in math.pow(x, y) is treated as being 1.

 

Zero to the zeroth power, in Neko

*/

var math_pow = $loader.loadprim("std@math_pow", 2)

 

 

{{out}}

 

=={{header|NetRexx}}==

{{out}}

=={{header|NewLISP}}==

{{out}}

<pre>1</pre>

Create an exponentiation table for all type combinations (of integer <code>0</code>, float <code>0.0</code> and boolean <code>o</code>):

 

+--+--+--+

| 1|1.| 1|

+--+--+--+

| 1|1.| 1|

 

=={{header|Nim}}==

 

{{out}}

 

=={{header|OCaml}}==

=={{header|Oforth}}==

 

 

{{out}}

 

=={{header|Ol}}==

(print "0^0: " (expt 0 0))

(print "0.0^0: " (expt (inexact 0) 0))

{{out}}

<pre>

 

=={{header|ooRexx}}==

* 21.04.2014 Walter Pachl

**********************************************************************/

Say 'rxCalcpower(0,0) ->' rxCalcpower(0,0)

Say '0**0 ->' 0**0

{{out}}

<pre>

0**0 -> 1

</pre>

 

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

0.^0

{{out}}

<pre>%1 = 1

=={{header|Pascal}}==

{{works with|Free Pascal}} {{Libheader|math}}

uses

math;

write('0.0 ^ 0 :',IntPower(0.0,0):4:2);

writeln(' 0.0 ^ 0.0 :',Power(0.0,0.0):4:2);

;output:

<pre>0.0 ^ 0 :1.00 0.0 ^ 0.0 :1.00</pre>

 

=={{header|Perl}}==

 

use Math::Complex;

 

{{out}}

<pre>

</pre>

 

{{out}}

<pre>

</pre>

 

{{out}}

<pre>1</pre>

 

=={{header|PHP}}==

echo pow(0,0);

echo 0 ** 0; // PHP 5.6+ only

{{out}}

<pre>

 

=={{header|PicoLisp}}==

(** 0 0)

{{out}}

1

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

Dcl a dec float(10) Init(1);

Dcl b dec float(10) Init(0);

Put skip list('0**1=',b**a);

Put skip list('0**0=',b**b);

{{out}}

<pre>

At offset +0000025B in procedure with entry ZHZ

</pre>

=={{header|PowerShell}}==

 

 

Output :

 

=={{header|PureBasic}}==

If OpenConsole()

PrintN("Zero to the zero power is " + Pow(0,0))

CloseConsole()

EndIf

 

{{out}}

Zero to the zero power is 1

</pre>

 

=={{header|Python}}==

===Python3===

from fractions import Fraction

from itertools import product

except:

ans = '<Exception raised>'

{{out}}

<pre> 0 ** 0 = 1

 

===Python2===

from fractions import Fraction

for n in (Decimal(0), Fraction(0, 1), complex(0), float(0), int(0)):

except:

n2 = '<Raised exception>'

{{out}}

<pre>

int: ** -> 1; pow -> 1

</pre>

 

=={{header|R}}==

{{out}}

<pre>1</pre>

=={{header|Racket}}==

 

;; as many zeros as I can think of...

(define zeros (list

(printf "(~a)^(~a) = ~s~%" z p

(with-handlers [(exn:fail:contract:divide-by-zero? exn-message)]

 

{{out}}

(0.0+0.0i)^(0) = 1

(0.0+0.0i)^(0.0+0.0i) = +nan.0+nan.0i</pre>

 

=={{header|REXX}}==

<br>using PC/REXX

<br>using Personal REXX

 

=={{header|Ring}}==

x = 0

y = 0

z = pow(x,y)

see "z=" + z + nl # z=1

 

=={{header|Ruby}}==

 

printf "%10s: ** -> %s\n" % [n.class, n**n]

{{out}}

<pre>

Float: ** -> 1.0

Complex: ** -> 1+0i

Rational: ** -> 1/1

</pre>

 

=={{header|Rust}}==

println!("{}",0u32.pow(0));

 

{{out}}

<pre>1</pre>

 

=={{header|S-lang}}==

{{out}}

<pre>1.0</pre>

 

=={{header|Scala}}==

 

=={{header|Scheme}}==

(display (expt 0.0 0.0)) (newline)

{{out}}

<pre>1

 

=={{header|Seed7}}==

include "float.s7i";

include "complex.s7i";

writeln("0.0+0i ** 0 = " <& complex(0.0) ** 0);

end func;

 

{{out}}

0.0+0i ** 0 = 1.0+0.0i

</pre>

 

=={{header|Sidef}}==

say n**n

{{out}}

<pre>

Taking the 0'th root of a number and raising it back to the zero power, we also get a 1:

 

 

=={{header|Sinclair ZX81 BASIC}}==

{{out}}

<pre>1</pre>

=={{header|Smalltalk}}==

 

0 raisedTo: 0

0.0 raisedTo: 0.0

{{out}}

<pre>

1.0

</pre>

 

=={{header|smart BASIC}}==

 

{{out}}

</pre>

 

 

SQL> select power(0,0) from dual;

{{out}}

<pre>

 

=={{header|Stata}}==

 

=={{header|Swift}}==

{{out}}

<pre>1.0</pre>

 

=={{header|Tcl}}==

Interactively…

1

% expr 0.0**0.0

 

=={{header|TI-83_BASIC}}==

{{out}}

<pre>ERROR:DOMAIN</pre>

 

=={{header|uBasic/4tH}}==

{{out}}

<pre>1

=={{header|Ursa}}==

Cygnus/X Ursa is written in Java, and as a result returns 1.0 when raising 0 to the 0.

 

=={{header|VBA}}==

x = 0

y = 0

z = 0 ^ 0

Debug.Print "z ="; z

<pre>z = 1</pre>

=={{header|VBScript}}==

{{Out}}

<pre>1</pre>

 

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

Sub Main()

Console.Write(0^0)

End Sub

 

{{out}}

<pre>1</pre>

 

=={{header|XLISP}}==

[1] (expt 0 0)

 

1

 

=={{header|zkl}}==

var BN=Import("zklBigNum"); // big ints