Zero to the zero power

Some computer programming languages are not exactly consistent (with other computer programming languages)
when raising zero to the zeroth power: 0⁰

Task

Show the results of raising zero to the zeroth power.

If your computer language objects to 0**0 or 0^0 at compile time, you may also try something like:

           x = 0
           y = 0
           z = x**y
           say  'z='  z

Show the result here.
And of course use any symbols or notation that is supported in your computer programming language for exponentiation.

See also

The Wiki entry: Zero to the power of zero.
The Wiki entry: History of differing points of view.
The MathWorld™ entry: exponent laws.
- Also, in the above MathWorld™ entry, see formula (9): $x^{0}=1$ .
The OEIS entry: The special case of zero to the zeroth power

11l

<lang 11l>print(0 ^ 0)</lang>

Output:

8th

Output:

1

Action!

Library: Action! Tool Kit

<lang Action!>INCLUDE "D2:REAL.ACT" ;from the Action! Tool Kit

PROC Main()

 REAL z,res

 Put(125) PutE() ;clear the screen

 IntToReal(0,z)
 Power(z,z,res)

 PrintR(z) Print("^")
 PrintR(z) Print("=")
 PrintRE(res)

RETURN</lang>

Output:

Screenshot from Atari 8-bit computer

0^0=.9999999998

Ada

<lang Ada>with Ada.Text_IO, Ada.Integer_Text_IO, Ada.Long_Integer_Text_IO,

 Ada.Long_Long_Integer_Text_IO, Ada.Float_Text_IO, Ada.Long_Float_Text_IO,
 Ada.Long_Long_Float_Text_IO;

use Ada.Text_IO, Ada.Integer_Text_IO, Ada.Long_Integer_Text_IO,

 Ada.Long_Long_Integer_Text_IO, Ada.Float_Text_IO, Ada.Long_Float_Text_IO,
 Ada.Long_Long_Float_Text_IO;

procedure Test5 is

  I    : Integer           := 0;
  LI   : Long_Integer      := 0;
  LLI  : Long_Long_Integer := 0;
  F    : Float             := 0.0;
  LF   : Long_Float        := 0.0;
  LLF  : Long_Long_Float   := 0.0;
  Zero : Natural           := 0;

begin

  Put ("Integer           0^0 = "); 
  Put (I ** Zero, 2);   New_Line;
  Put ("Long Integer      0^0 = ");
  Put (LI ** Zero, 2);  New_Line;
  Put ("Long Long Integer 0^0 = ");
  Put (LLI ** Zero, 2); New_Line;
  Put ("Float           0.0^0 = ");           
  Put (F ** Zero);   New_Line;
  Put ("Long Float      0.0^0 = ");      
  Put (LF ** Zero);  New_Line;
  Put ("Long Long Float 0.0^0 = "); 
  Put (LLF ** Zero); New_Line;

end Test5; </lang>

Output:

Integer           0^0 =  1
Long Integer      0^0 =  1
Long Long Integer 0^0 =  1
Float           0.0^0 =  1.00000E+00
Long Float      0.0^0 =  1.00000000000000E+00
Long Long Float 0.0^0 =  1.00000000000000000E+00

ALGOL 68

Works with: ALGOL 68G version Any - tested with release 2.6.win32

<lang algol68>print( ( 0 ^ 0, newline ) ) </lang>

Output:

+1

AppleScript

<lang applescript> return 0 ^ 0</lang>

Output:

Applesoft BASIC

]? 0^0
1

Arturo

<lang rebol>print 0 ^ 0 print 0.0 ^ 0</lang>

Output:

1
1.0

Asymptote

<lang Asymptote>write("0 ^ 0 = ", 0 ** 0);</lang>

AutoHotkey

<lang AutoHotkey>MsgBox % 0 ** 0</lang>

Output:

BaCon

<lang freebasic>PRINT POW(0, 0)</lang>

Output:

prompt$ ./zerotothezero
1

BASIC

BASIC256

<lang BASIC256>print "0 ^ 0 = "; 0 ^ 0</lang>

QBasic

Works with: QBasic version 1.1

Works with: QuickBasic version 4.5

<lang qbasic>PRINT "0 ^ 0 ="; 0 ^ 0</lang>

True BASIC

Works with: QBasic

<lang qbasic>PRINT "0 ^ 0 ="; 0 ^ 0 END</lang>

BBC BASIC

<lang bbcbasic> PRINT 0^0</lang>

Output:

Befunge-93 doesn't have explicit support for exponentiation, but there are a couple of fingerprint extensions for Befunge-98 which add that functionality. The example below makes use of the FPDP fingerprint (double precision floating point).

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).

Output:

1.000000

BQN

BQN doesn't specify the details of arithmetic functions; existing implementations use IEEE doubles and the pow function, giving a result of 1. <lang BQN>0⋆0</lang>

Output:

Bracmat

Output:

Burlesque

C

Works with: C99

This example uses the standard pow function in the math library. 0^0 is given as 1. <lang c>#include <stdio.h>

include <math.h>
include <complex.h>

int main() { printf("0 ^ 0 = %f\n", pow(0,0));

       double complex c = cpow(0,0);

printf("0+0i ^ 0+0i = %f+%fi\n", creal(c), cimag(c)); return 0; }</lang>

Output:

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

C#

<lang csharp>using System;

namespace ZeroToTheZeroeth {

   class Program
   {
       static void Main(string[] args)
       {
           double k = Math.Pow(0, 0);
           Console.Write("0^0 is {0}", k);           
       }
   }

}</lang>

Output:

0^0 is 1

C++

<lang cpp>#include <iostream>

include <cmath>
include <complex>

int main() {

 std::cout << "0 ^ 0 = " << std::pow(0,0) << std::endl;
 std::cout << "0+0i ^ 0+0i = " <<
   std::pow(std::complex<double>(0),std::complex<double>(0)) << std::endl;
 return 0;

}</lang>

Output:

0 ^ 0 = 1
0+0i ^ 0+0i = (nan,nan)

Caché ObjectScript

<lang Caché ObjectScript>ZEROPOW

 // default behavior is incorrect:
 set (x,y) = 0
 w !,"0 to the 0th power (wrong): "_(x**y)  ; will output 0
 
 // if one or both of the values is a double, this works
 set (x,y) = $DOUBLE(0)
 w !,"0 to the 0th power (right): "_(x**y)
 
 quit</lang>

Output:

SAMPLES>do ^ZEROPOW
0 to the 0th power (wrong): 0

0 to the 0th power (right): 1

Clojure

user=> (use 'clojure.math.numeric-tower)
user=> (expt 0 0)
1

; alternative java-interop route:
user=> (Math/pow 0 0)
1.0

CLU

The CLU reference manual doesn't mention the issue, so the fact that it returns 1 in my case could just be an implementation detail.

<lang clu>start_up = proc ()

   zz_int: int := 0 ** 0
   zz_real: real := 0.0 ** 0.0
   
   po: stream := stream$primary_output()
   stream$putl(po, "integer 0**0: " || int$unparse(zz_int))
   stream$putl(po, "real 0**0: " || f_form(zz_real, 1, 1))

end start_up</lang>

Output:

integer 0**0: 1
real 0**0: 1.0

COBOL

<lang cobol>identification division. program-id. zero-power-zero-program. data division. working-storage section. 77 n pic 9. procedure division.

   compute n = 0**0.
   display n upon console.
   stop run.</lang>

Output:

ColdFusion

Classic tag based CFML

<lang cfm> <cfset zeroPowerTag = 0^0> <cfoutput>"#zeroPowerTag#"</cfoutput> </lang>

Output:

"1"

Script Based CFML

 zeroPower = 0^0;
 writeOutput( zeroPower );

</cfscript></lang>

Output:

Commodore BASIC

Commodore computers use the up arrow key ↑ as the exponent operator.

Output:

ready.
print 0↑0
1

ready.
█

Common Lisp

> (expt 0 0)
1

Crystal

<lang crystal>puts "Int32: #{0_i32**0_i32}" puts "Negative Int32: #{-0_i32**-0_i32}" puts "Float32: #{0_f32**0_f32}" puts "Negative Float32: #{-0_f32**-0_f32}"</lang>

Output:

Int32:            1
Negative Int32:   1
Float32:          1.0
Negative Float32: 1.0

D

<lang d>void main() {

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

   writeln("Int:     ", 0 ^^ 0);
   writeln("Ulong:   ", 0UL ^^ 0UL);
   writeln("Float:   ", 0.0f ^^ 0.0f);
   writeln("Double:  ", 0.0 ^^ 0.0);
   writeln("Real:    ", 0.0L ^^ 0.0L);
   writeln("pow:     ", pow(0, 0));
   writeln("BigInt:  ", 0.BigInt ^^ 0);
   writeln("Complex: ", complex(0.0, 0.0) ^^ 0);

}</lang>

Output:

Int:     1
Ulong:   1
Float:   1
Double:  1
Real:    1
pow:     1
BigInt:  1
Complex: 1+0i

Dc

Output:

Delphi

See Pascal.

EasyLang

<lang>print pow 0 0</lang>

EchoLisp

trying the 16 combinations all return the integer 1

(lib 'bigint) (define zeroes '(integer: 0 inexact=float: 0.000 complex: 0+0i bignum: #0)) (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

</lang>

Eiffel

<lang Eiffel>print (0^0)</lang>

Output:

Elena

ELENA 4.x <lang elena>import extensions;

public program() {

   console.printLine("0^0 is ",0.power:0)

}</lang>

Output:

0^0 is 0

Elixir

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

math.pow(0,0)

</lang>

Output:

1.0

Emacs Lisp

Output:

ERRE

<lang ERRE> ..... PRINT(0^0) ..... </lang>

Output:

F#

In the REPL:

> let z = 0.**0.;;

val z : float = 1.0

Factor

<lang factor>USING: math.functions.private ; ! ^complex 0 0 ^ C{ 0 0 } C{ 0 0 } ^complex</lang>

Output:

--- Data stack:
NAN: 8000000000000
C{ NAN: 8000000000000 NAN: 8000000000000 }

Falcon

VBA/Python programmer's approach not sure if it's the most falconic way <lang falcon> /* created by Aykayayciti Earl Lamont Montgomery April 9th, 2018 */

x = 0 y = 0 z = x**y > "z=", z

</lang>

Output:

z=1
[Finished in 0.2s]

Fermat

Output:

Forth

Output:

1.

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

Output:

0 ^0 . 1 ok

Fortran

<lang Fortran> program zero double precision :: i, j double complex :: z1, z2 i = 0.0D0 j = 0.0D0 z1 = (0.0D0,0.0D0) z2 = (0.0D0,0.0D0) write(*,*) 'When integers are used, we have 0^0 = ', 0**0 write(*,*) 'When double precision numbers are used, we have 0.0^0.0 = ', i**j write(*,*) 'When complex numbers are used, we have (0.0+0.0i)^(0.0+0.0i) = ', z1**z2 end program </lang>

Output:

 When integers are used, we have 0^0 =            1
 When double precision numbers are used, we have 0.0^0.0 =    1.0000000000000000     
 When complex numbers are used, we have (0.0+0.0i)^(0.0+0.0i) =  (             NaN,             NaN)

FreeBASIC

<lang freebasic>' FB 1.05.0 Win64

Print "0 ^ 0 ="; 0 ^ 0 Sleep</lang>

Output:

0 ^ 0 = 1

Frink

<lang frink>println[0^0]</lang>

Output:

FutureBasic

<lang futurebasic> include "ConsoleWindow"

print 0^0 </lang> Output:

Gambas

Click this link to run this code <lang gambas>Public Sub Main()

Print 0 ^ 0

End</lang> Output:

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. <lang go>package main

import (

   "fmt"
   "math"
   "math/big"
   "math/cmplx"

)

func main() {

   fmt.Println("float64:    ", math.Pow(0, 0))
   var b big.Int
   fmt.Println("big integer:", b.Exp(&b, &b, nil))
   fmt.Println("complex:    ", cmplx.Pow(0, 0))

}</lang>

Output:

float64:     1
big integer: 1
complex:     (1+0i)

Groovy

Translation of: Java

Test: <lang groovy>println 0**0</lang>

Output:

GW-BASIC

<lang gwbasic>PRINT 0^0</lang>

Output:

Haskell

<lang haskell>import Data.Complex

main = do

 print $ 0 ^ 0
 print $ 0.0 ^ 0
 print $ 0 ^^ 0
 print $ 0 ** 0
 print $ (0 :+ 0) ^ 0
 print $ (0 :+ 0) ** (0 :+ 0)</lang>

Output:

1
1.0
1.0
1.0
1.0 :+ 0.0
NaN :+ NaN

HolyC

<lang holyc>F64 a = 0 ` 0; Print("0 ` 0 = %5.3f\n", a);</lang>

Output:

0 ` 0 = 1.000

Icon and Unicon

"Works" in both languages: <lang unicon>procedure main()

   write(0^0)

end</lang>

Output:

->z2z

Run-time error 204
File z2z.icn; Line 2
real overflow, underflow, or division by zero
Traceback:
   main()
   {0 ^ 0} from line 2 in z2z.icn
->

J

Java

<lang java>System.out.println(Math.pow(0, 0));</lang>

Output:

1.0

JavaScript

Math.pow

Works with: Node.js

In interactive mode: <lang javascript>> Math.pow(0, 0); 1</lang>

exponentiation operator (**)

jq

jq version 1.4 does not have a builtin "power" function. If it were to be defined using the exp and log builtins as 'log * y | exp', then 0 | power(0) would yield null, and therefore a definition that makes a special case of 0^0 should be considered, e.g. along the following lines: <lang jq>def power(y): y as $y | if $y == 0 then 1 elif . == 0 then 0 else log * $y | exp end;</lang>

This definition will however be unsatisfactory for many purposes because it does not maintain precision for integer values of the input (.) and y.

Jsish

Output:

Julia

Try all combinations of complex, float, rational, integer and boolean. <lang Julia>using Printf

const types = (Complex, Float64, Rational, Int, Bool)

for Tb in types, Te in types

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

end</lang>

Output:

   Complex ^ Complex    = 0 + 0im ^ 0 + 0im = 1.0 + 0.0im  (Complex{Float64})
   Complex ^ Float64    = 0 + 0im ^ 0.0     = 1.0 + 0.0im  (Complex{Float64})
   Complex ^ Rational   = 0 + 0im ^ 0//1    = 1.0 + 0.0im  (Complex{Float64})
   Complex ^ Int64      = 0 + 0im ^ 0       = 1 + 0im      (Complex{Int64})
   Complex ^ Bool       = 0 + 0im ^ false   = 1 + 0im      (Complex{Int64})
   Float64 ^ Complex    =     0.0 ^ 0 + 0im = 1.0 + 0.0im  (Complex{Float64})
   Float64 ^ Float64    =     0.0 ^ 0.0     = 1.0          (Float64)
   Float64 ^ Rational   =     0.0 ^ 0//1    = 1.0          (Float64)
   Float64 ^ Int64      =     0.0 ^ 0       = 1.0          (Float64)
   Float64 ^ Bool       =     0.0 ^ false   = 1.0          (Float64)
  Rational ^ Complex    =    0//1 ^ 0 + 0im = 1.0 + 0.0im  (Complex{Float64})
  Rational ^ Float64    =    0//1 ^ 0.0     = 1.0          (Float64)
  Rational ^ Rational   =    0//1 ^ 0//1    = 1.0          (Float64)
  Rational ^ Int64      =    0//1 ^ 0       = 1//1         (Rational{Int64})
  Rational ^ Bool       =    0//1 ^ false   = 1//1         (Rational{Int64})
     Int64 ^ Complex    =       0 ^ 0 + 0im = 1.0 + 0.0im  (Complex{Float64})
     Int64 ^ Float64    =       0 ^ 0.0     = 1.0          (Float64)
     Int64 ^ Rational   =       0 ^ 0//1    = 1.0          (Float64)
     Int64 ^ Int64      =       0 ^ 0       = 1            (Int64)
     Int64 ^ Bool       =       0 ^ false   = 1            (Int64)
      Bool ^ Complex    =   false ^ 0 + 0im = 1.0 + 0.0im  (Complex{Float64})
      Bool ^ Float64    =   false ^ 0.0     = 1.0          (Float64)
      Bool ^ Rational   =   false ^ 0//1    = 1.0          (Float64)
      Bool ^ Int64      =   false ^ 0       = true         (Bool)
      Bool ^ Bool       =   false ^ false   = true         (Bool)

K

0^0

1.0 </lang>

Klingphix

<lang Klingphix>:mypower

   dup not (
     [ drop sign dup 0 equal [ drop 1 ] if ]
     [ power ]
   ) if

0 0 mypower print nl

"End " input</lang>

Output:

1
End

Kotlin

<lang scala>// version 1.0.6

fun main(args: Array<String>) {

  println("0 ^ 0 = ${Math.pow(0.0, 0.0)}")

}</lang>

Output:

0 ^ 0 = 1.0

Lambdatalk

Liberty BASIC

<lang lb> '******** print 0^0 '******** </lang>

Output:

Locomotive Basic

<lang locobasic>print 0🠅0</lang>

Output:

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. <lang Lua>print(0^0)</lang>

Output:

M2000 Interpreter

M2000 use ** and ^ for power. <lang M2000 Interpreter> Module Checkit {

     x=0
     y=0
     Print x**y=1, x^y=1    ' True True

} Checkit </lang>

Maple

Output:

However, for consistency with IEEE-754 numerics, we also have a NaN result for the equivalent floating-point exponentiation: <lang Maple>0^0.0</lang>

Output:

Float(undefined)

Mathematica/Wolfram Language

Output:

Indeterminate

MATLAB / Octave

<lang Matlab>0^0 complex(0,0)^0</lang>

Output:

1
1

Maxima

Output:

                  0
expt: undefined: 0

Mercury

<lang Mercury>:- module zero_to_the_zero_power.

- interface.

- import_module io.

- pred main(io::di, io::uo) is det.

- implementation.

- import_module float, int, integer, list, string.

main(!IO) :-

  io.format("    int.pow(0, 0) = %d\n", [i(pow(0, 0))], !IO),
  io.format("integer.pow(zero, zero) = %s\n",
       [s(to_string(pow(zero, zero)))], !IO),
  io.format("  float.pow(0.0, 0) = %.1f\n", [f(pow(0.0, 0))], !IO).

- end_module zero_to_the_zero_power.</lang>

Output:

    int.pow(0, 0) = 1
integer.pow(zero, zero) = 1
  float.pow(0.0, 0) = 1.0

Microsoft Small Basic

<lang smallbasic>TextWindow.WriteLine(Math.Power(0,0))</lang>

Output:

min

Works with: min version 0.19.3

Output:

1.0

MiniScript

<lang MiniScript>print "The result of zero to the zero power is " + 0^0</lang>

Output:

The result of zero to the zero power is 1

МК-61/52

The result is error message.

Nanoquery

<lang nanoquery>println 0^0</lang>

Output:

Neko

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

<lang ActionScript>/**

Zero to the zeroth power, in Neko

/

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

$print(math_pow(0, 0), "\n")</lang>

Output:

prompt$ nekoc zero-to-the-zero.neko
prompt$ neko zero-to-the-zero.n
1

NetRexx

Output:

0**0=1

NewLISP

Output:

Nial

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

<lang nial> 0 0.0 o outer power 0 0.0 o +--+--+--+ | 1|1.| 1| +--+--+--+ |1.|1.|1.| +--+--+--+ | 1|1.| 1| +--+--+--+</lang>

Nim

<lang nim>import math

echo pow(0.0, 0.0) # Floating point exponentiation. echo 0 ^ 0 # Integer exponentiation.</lang>

Output:

1.0
1

OCaml

In the interpreter:

# 0.0 ** 0.0;;
- : float = 1.
# Complex.pow Complex.zero Complex.zero;;
- : Complex.t = {Complex.re = nan; Complex.im = nan}
# #load "nums.cma";;
# open Num;;
# Int 0 **/ Int 0;;                 
- : Num.num = Int 1

Oforth

<lang Oforth>0 0 pow println</lang>

Output:

Ol

<lang scheme> (print "0^0: " (expt 0 0)) (print "0.0^0: " (expt (inexact 0) 0)) </lang>

Output:

0^0: 1
0.0^0: 1

ooRexx

<lang oorexx>/**********************************************************************

21.04.2014 Walter Pachl
- - - - /

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

requires rxmath library</lang>

Output:

rxCalcpower(0,0)  -> 1
0**0              -> 1

Openscad

PARI/GP

0 raised to the power of exact 0 is 0, but 0 cannot be raised to the power of an inexact 0: <lang parigp>0^0 0.^0 0^0.</lang>

Output:

%1 = 1
%2 = 1
  ***   at top-level: 0^0.
  ***                   ^---
  *** _^_: domain error in gpow(0,n): n <= 0
  ***   Break loop: type 'break' to go back to GP prompt

Pascal

Works with: Free Pascal

Library: math

<lang Pascal>program ZToZ; uses

 math;

begin

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

end.</lang>

output

0.0 ^ 0 :1.00   0.0 ^ 0.0 :1.00

Perl

<lang perl>print 0 ** 0, "\n";

use Math::Complex;

print cplx(0,0) ** cplx(0,0), "\n";</lang>

Output:

1
1

Phix

Library: Phix/basics

?power(0,0)
requires("0.8.4") -- (now fixed/crashes on earlier versions)
include complex.e
complex a = complex_new(0,0),
        b = complex_power(a,a)
string sa = complex_sprint(a,true),
       sb = complex_sprint(b,true)
printf(1,"%s ^ %s = %s\n",{sa,sa,sb})

Output:

1
0+0i ^ 0+0i = 1+0i

Phixmonti

<lang Phixmonti>def mypower

   dup not if
       . sign dup 0 == if . 1 endif
   else
       power
   endif

enddef

0 0 mypower print</lang>

Output:

PHP

Output:

1
1

PicoLisp

Output:

1

Pike

<lang Pike>write( pow(0, 0) +"\n" );</lang>

Output:

PL/I

<lang pli> zhz: Proc Options(Main);

Dcl a dec float(10) Init(1);
Dcl b dec float(10) Init(0);
Put skip list('1**0=',a**b);
Put skip list('0**1=',b**a);
Put skip list('0**0=',b**b);
End;</lang>

Output:

1**0=                    1.000000000E+0000
0**1=                    0.000000000E+0000
0**0=
IBM0682I  ONCODE=1553  X in EXPONENT(X) was invalid.
   At offset +0000025B in procedure with entry ZHZ

Plain English

<lang plainenglish>To run: Start up. Put 0 into a number. Raise the number to 0. Convert the number to a string. Write the string to the console. Wait for the escape key. Shut down.</lang>

Output:

PowerShell

<lang powershell>Write-Host "0 ^ 0 = " ([math]::pow(0,0))</lang>

Output :

0 ^ 0 =  1

PureBasic

<lang PureBasic> If OpenConsole()

 PrintN("Zero to the zero power is " + Pow(0,0))
 PrintN("")
 PrintN("Press any key to close the console")
 Repeat: Delay(10) : Until Inkey() <> ""
 CloseConsole()

EndIf </lang>

Output:

Zero to the zero power is 1

Pyret

Output:

1

Python

Python3

<lang python>from decimal import Decimal from fractions import Fraction from itertools import product

zeroes = [0, 0.0, 0j, Decimal(0), Fraction(0, 1), -0.0, -0.0j, Decimal(-0.0)] for i, j in product(zeroes, repeat=2):

   try:
       ans = i**j
   except:
       ans = '<Exception raised>'
   print(f'{i!r:>15} ** {j!r:<15} = {ans!r}')</lang>

Output:

              0 ** 0               = 1
              0 ** 0.0             = 1.0
              0 ** 0j              = (1+0j)
              0 ** Decimal('0')    = '<Exception raised>'
              0 ** Fraction(0, 1)  = 1
              0 ** -0.0            = 1.0
              0 ** (-0-0j)         = (1+0j)
              0 ** Decimal('-0')   = '<Exception raised>'
            0.0 ** 0               = 1.0
            0.0 ** 0.0             = 1.0
            0.0 ** 0j              = (1+0j)
            0.0 ** Decimal('0')    = '<Exception raised>'
            0.0 ** Fraction(0, 1)  = 1.0
            0.0 ** -0.0            = 1.0
            0.0 ** (-0-0j)         = (1+0j)
            0.0 ** Decimal('-0')   = '<Exception raised>'
             0j ** 0               = (1+0j)
             0j ** 0.0             = (1+0j)
             0j ** 0j              = (1+0j)
             0j ** Decimal('0')    = '<Exception raised>'
             0j ** Fraction(0, 1)  = (1+0j)
             0j ** -0.0            = (1+0j)
             0j ** (-0-0j)         = (1+0j)
             0j ** Decimal('-0')   = '<Exception raised>'
   Decimal('0') ** 0               = '<Exception raised>'
   Decimal('0') ** 0.0             = '<Exception raised>'
   Decimal('0') ** 0j              = '<Exception raised>'
   Decimal('0') ** Decimal('0')    = '<Exception raised>'
   Decimal('0') ** Fraction(0, 1)  = '<Exception raised>'
   Decimal('0') ** -0.0            = '<Exception raised>'
   Decimal('0') ** (-0-0j)         = '<Exception raised>'
   Decimal('0') ** Decimal('-0')   = '<Exception raised>'
 Fraction(0, 1) ** 0               = Fraction(1, 1)
 Fraction(0, 1) ** 0.0             = 1.0
 Fraction(0, 1) ** 0j              = (1+0j)
 Fraction(0, 1) ** Decimal('0')    = '<Exception raised>'
 Fraction(0, 1) ** Fraction(0, 1)  = Fraction(1, 1)
 Fraction(0, 1) ** -0.0            = 1.0
 Fraction(0, 1) ** (-0-0j)         = (1+0j)
 Fraction(0, 1) ** Decimal('-0')   = '<Exception raised>'
           -0.0 ** 0               = 1.0
           -0.0 ** 0.0             = 1.0
           -0.0 ** 0j              = (1+0j)
           -0.0 ** Decimal('0')    = '<Exception raised>'
           -0.0 ** Fraction(0, 1)  = 1.0
           -0.0 ** -0.0            = 1.0
           -0.0 ** (-0-0j)         = (1+0j)
           -0.0 ** Decimal('-0')   = '<Exception raised>'
        (-0-0j) ** 0               = (1+0j)
        (-0-0j) ** 0.0             = (1+0j)
        (-0-0j) ** 0j              = (1+0j)
        (-0-0j) ** Decimal('0')    = '<Exception raised>'
        (-0-0j) ** Fraction(0, 1)  = (1+0j)
        (-0-0j) ** -0.0            = (1+0j)
        (-0-0j) ** (-0-0j)         = (1+0j)
        (-0-0j) ** Decimal('-0')   = '<Exception raised>'
  Decimal('-0') ** 0               = '<Exception raised>'
  Decimal('-0') ** 0.0             = '<Exception raised>'
  Decimal('-0') ** 0j              = '<Exception raised>'
  Decimal('-0') ** Decimal('0')    = '<Exception raised>'
  Decimal('-0') ** Fraction(0, 1)  = '<Exception raised>'
  Decimal('-0') ** -0.0            = '<Exception raised>'
  Decimal('-0') ** (-0-0j)         = '<Exception raised>'
  Decimal('-0') ** Decimal('-0')   = '<Exception raised>'

Python2

<lang python>from decimal import Decimal from fractions import Fraction for n in (Decimal(0), Fraction(0, 1), complex(0), float(0), int(0)): try: n1 = n**n except: n1 = '<Raised exception>' try: n2 = pow(n, n) except: n2 = '<Raised exception>' print('%8s: ** -> %r; pow -> %r' % (n.__class__.__name__, n1, n2))</lang>

Output:

 Decimal: ** -> '<Raised exception>'; pow -> '<Raised exception>'
Fraction: ** -> Fraction(1, 1); pow -> Fraction(1, 1)
 complex: ** -> (1+0j); pow -> (1+0j)
   float: ** -> 1.0; pow -> 1.0
     int: ** -> 1; pow -> 1

QB64

<lang qb64>Print 0 ^ 0</lang>

Output:

Alternatively: <lang QB64>i% = 0 'Integer l& = 0 'Long integer s! = 0.0 'Single precision floating point d# = 0.0 'Double precision floating point b` = 0 '_Bit bb%% = 0 '_Byte isf&& = 0 '_Integer64

Print i% ^ i% Print l& ^ l& Print s! ^ s! Print d# ^ d# Print b` ^ b` Print bb%% ^ bb%% Print isf&& ^ isf&&</lang>

Output:

NB: Values with 0 decimals are trimmed by Print's casting from number value to String.

Quackery

As a dialogue in the Quackery shell.

<lang Quackery>/O> 0 0 ** ...

Stack: 1 </lang>

R

<lang rsplus>print(0^0)</lang>

Output:

Racket

<lang racket>#lang racket

as many zeros as I can think of...

(define zeros (list

              0  ; unspecified number type
              0. ; hinted as float
              #e0 ; explicitly exact
              #i0 ; explicitly inexact
              0+0i ; exact complex
              0.+0.i ; float inexact
              ))

(for*((z zeros) (p zeros))

 (printf "(~a)^(~a) = ~s~%" z p
 (with-handlers [(exn:fail:contract:divide-by-zero? exn-message)]
   (expt z p))))</lang>

Output:

(0)^(0) = 1
(0)^(0.0) = 1.0
(0)^(0) = 1
(0)^(0.0) = 1.0
(0)^(0) = 1
(0)^(0.0+0.0i) = "expt: undefined for 0 and 0.0+0.0i"
(0.0)^(0) = 1
(0.0)^(0.0) = 1.0
(0.0)^(0) = 1
(0.0)^(0.0) = 1.0
(0.0)^(0) = 1
(0.0)^(0.0+0.0i) = +nan.0+nan.0i
(0)^(0) = 1
(0)^(0.0) = 1.0
(0)^(0) = 1
(0)^(0.0) = 1.0
(0)^(0) = 1
(0)^(0.0+0.0i) = "expt: undefined for 0 and 0.0+0.0i"
(0.0)^(0) = 1
(0.0)^(0.0) = 1.0
(0.0)^(0) = 1
(0.0)^(0.0) = 1.0
(0.0)^(0) = 1
(0.0)^(0.0+0.0i) = +nan.0+nan.0i
(0)^(0) = 1
(0)^(0.0) = 1.0
(0)^(0) = 1
(0)^(0.0) = 1.0
(0)^(0) = 1
(0)^(0.0+0.0i) = "expt: undefined for 0 and 0.0+0.0i"
(0.0+0.0i)^(0) = 1
(0.0+0.0i)^(0.0) = 1.0+0.0i
(0.0+0.0i)^(0) = 1
(0.0+0.0i)^(0.0) = 1.0+0.0i
(0.0+0.0i)^(0) = 1
(0.0+0.0i)^(0.0+0.0i) = +nan.0+nan.0i

Raku

(formerly Perl 6)

Works with: Rakudo version 2018.03

<lang perl6>say ' type n n**n exp(n,n)'; say '-------- -------- -------- --------';

for 0, 0.0, FatRat.new(0), 0e0, 0+0i {

   printf "%8s  %8s  %8s  %8s\n", .^name, $_, $_**$_, exp($_,$_);

}</lang>

Output:

    type         n      n**n  exp(n,n)
--------  --------  --------  --------
     Int         0         1         1
     Rat         0         1         1
  FatRat         0         1         1
     Num         0         1         1
 Complex      0+0i      1+0i      1+0i

Red

Shown using the operator, the function, and the math mini-DSL that uses the order of operations from mathematics: <lang rebol>Red[] print 0 ** 0 print power 0 0 print math [0 ** 0]</lang>

Output:

1
1
1

Relation

REXX

<lang rexx>/*REXX program shows the results of raising zero to the zeroth power.*/ say '0 ** 0 (zero to the zeroth power) ───► ' 0**0</lang>
using PC/REXX
using Personal REXX
using REGINA
using ooRexx

Output:

0 ** 0  (zero to the zeroth power) ───►  1

using R4

Output:

Error 26 : Invalid whole number (SYNTAX)
Information: 0 ** 0 is undefined
Error occurred in statement# 2
Statement source: say '0 ** 0  (zero to the zeroth power) ───► ' 0**0
Statement context: C:\ZERO_TO0.REX, procedure: ZERO_TO0

using ROO

Output:

Error 26 : Invalid whole number (SYNTAX)
Information: 0 ** 0 is undefined
Error occurred in statement# 2
Statement source: say '0 ** 0  (zero to the zeroth power) ───► ' 0**0
Statement context: C:\ZERO_TO0.REX, procedure: ZERO_TO0

Ring

Ruby

<lang ruby>require 'bigdecimal'

[0, 0.0, Complex(0), Rational(0), BigDecimal("0")].each do |n|

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

end</lang>

Output:

   Integer: ** -> 1
     Float: ** -> 1.0
   Complex: ** -> 1+0i
  Rational: ** -> 1/1
BigDecimal: ** -> 0.1e1

Rust

<lang rust>fn main() {

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

}</lang>

Output:

S-lang

<lang S-lang>print(0^0);</lang>

Output:

1.0

Scala

Library: Scala

<lang Scala> assert(math.pow(0, 0) == 1, "Scala blunder, should go back to school !")</lang>

Scheme

<lang scheme>(display (expt 0 0)) (newline) (display (expt 0.0 0.0)) (newline) (display (expt 0+0i 0+0i)) (newline)</lang>

Output:

1
1.0
1.0

Seed7

<lang seed7>$ include "seed7_05.s7i";

 include "float.s7i";
 include "complex.s7i";

const proc: main is func

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

</lang>

Output:

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

SenseTalk

<lang sensetalk>set a to 0 set b to 0

put a to the power of b // Prints: 1</lang>

Sidef

<lang ruby>[0, Complex(0, 0)].each {|n|

   say n**n

}</lang>

Output:

1
1

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

Sinclair ZX81 BASIC

<lang basic>PRINT 0**0</lang>

Output:

Smalltalk

<lang smalltalk> 0 raisedTo: 0 0.0 raisedTo: 0.0 </lang>

Output:

1
1.0

smart BASIC

<lang qbasic>PRINT 0^0</lang>

Output:

SNOBOL4

<lang snobol4> OUTPUT = (0 ** 0) END</lang>

SQL

<lang SQL> SQL> select power(0,0) from dual; </lang>

Output:

POWER(0,0)
----------
         1

Standard ML

In the interpreter:

- Math.pow (0.0, 0.0);
val it = 1.0 : real

Stata

<lang stata>. display 0^0 1</lang>

Swift

<lang swift>import Darwin print(pow(0.0,0.0))</lang>

Output:

1.0

Symsyn

(0^0) []

</lang>

Output:

Tcl

Interactively… <lang tcl>% expr 0**0 1 % expr 0.0**0.0 1.0</lang>

TI-83_BASIC

Output:

ERROR:DOMAIN

uBasic/4tH

<lang>Print 0^0</lang>

Output:

1

0 OK, 0:9

Ursa

Cygnus/X Ursa is written in Java, and as a result returns 1.0 when raising 0 to the 0. <lang ursa>> out (pow 0 0) endl console 1.0</lang>

VBA

<lang vb>Public Sub zero()

   x = 0
   y = 0
   z = 0 ^ 0
   Debug.Print "z ="; z

End Sub</lang>

Output:

z = 1

VBScript

<lang vb>WScript.Echo 0 ^ 0</lang>

Output:

Verilog

<lang Verilog>module main;

 initial begin
   $display("0 ^ 0 = ", 0**0);
   $finish ;
 end

endmodule</lang>

Output:

0 ^ 0 =           1

Visual Basic .NET

<lang vbnet>Module Program

   Sub Main()
       Console.Write(0^0)
   End Sub

End Module</lang>

Output:

Vlang

<lang go>// Zero to the zero power, in V // Tectonics: v run zero-to-the-zero-power.v module main import math

// starts here // V does not include an exponentiation operator, but uses a math module pub fn main() {

   println(math.pow(0, 0))

}</lang>

Output:

prompt$ v run rosetta/zero-to-the-zero-power.v
1.

Wren

<lang ecmascript>System.print(0.pow(0))</lang>

Output:

XLISP

1 [2] </lang>

XPL0

<lang XPL0>RlOut(0, Pow(0., 0.))</lang>

Output:

    1.00000

zkl

<lang zkl>(0.0).pow(0) //--> 1.0 var BN=Import("zklBigNum"); // big ints BN(0).pow(0) //--> 1</lang>