⚠️ Warning: This is a draft ⚠️
This means it might contain formatting issues, incorrect code, conceptual problems, or other severe issues.
If you want to help to improve and eventually enable this page, please fork RosettaGit's repository and open a merge request on GitHub.
{{task}} [[Category:Simple]]
Some computer programming languages are not exactly consistent (with other computer programming languages)
when ''raising zero to the zeroth power'': 00
;Task: Show the results of raising zero to the zeroth power.
If your computer language objects to '''00''' or '''0^0''' at compile time, you may also try something like: x = 0 y = 0 z = xy 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: [[wp:Exponentiation#Zero_to_the_power_of_zero|Zero to the power of zero]].
- The Wiki entry: [[wp:Exponentiation#History_of_differing_points_of_view|History of differing points of view]].
- The MathWorld™ entry: [http://mathworld.wolfram.com/ExponentLaws.html exponent laws]. ** Also, in the above MathWorld™ entry, see formula ('''9'''): .
- 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]
8th
0 0 ^ .
{{out}} 1
ARM Assembly
{{omit from|ARM Assembly}}
AutoHotkey
MsgBox % 0 ** 0
{{out}}
1
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;
{{out}}
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|Any - tested with release 2.6.win32}}
print( ( 0 ^ 0, newline ) )
{{out}}
+1
APL
0*0
1
Applesoft BASIC
]? 0^0
1
AWK
# syntax: GAWK -f ZERO_TO_THE_ZERO_POWER.AWK
BEGIN {
print(0 ^ 0)
exit(0)
}
{{out}}
1
BaCon
PRINT POW(0, 0)
{{out}}
prompt$ ./zerotothezero
1
Bc
0 ^ 0
{{out}} 1
Befunge
'''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).
"PDPF"4#@(0F0FYP)@
{{out}}
1.000000
Bracmat
0^0
{{out}}
1
Burlesque
blsq ) 0.0 0.0?^
1.0
blsq ) 0 0?^
1
BBC BASIC
PRINT 0^0
{{out}}
1
C
{{works with|C99}}
This example uses the standard pow function in the math library.
0^0 is given as 1.
#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;
}
{{out}}
0 ^ 0 = 1.000000
0+0i ^ 0+0i = nan+nani
C++
#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;
}
{{out}}
0 ^ 0 = 1
0+0i ^ 0+0i = (nan,nan)
C#
using System;
namespace ZeroToTheZeroeth
{
class Program
{
static void Main(string[] args)
{
double k = Math.Pow(0, 0);
Console.Write("0^0 is {0}", k);
}
}
}
{{out}}
0^0 is 1
=={{header|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
{{out}}
```txt
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
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.
{{out}}
1
ColdFusion
Classic tag based CFML
<cfset zeroPowerTag = 0^0>
<cfoutput>"#zeroPowerTag#"</cfoutput>
{{Output}}
"1"
Script Based CFML
zeroPower = 0^0;
writeOutput( zeroPower );
</cfscript>
{{Output}}
1
Common Lisp
> (expt 0 0)
1
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);
}
{{out}}
Int: 1
Ulong: 1
Float: 1
Double: 1
Real: 1
pow: 1
BigInt: 1
Complex: 1+0i
Dc
0 0^p
{{Output}}
1
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
Eiffel
print (0^0)
{{out}}
1
Elena
ELENA 4.x
import extensions;
public program()
{
console.printLine("0^0 is ",0.power:0)
}
{{out}}
0^0 is 0
Elixir
Elixir uses Erlang's :math for power operations and can handle zero to the zero power.
:math.pow(0,0)
{{out}} 1.0
ERRE
.....
PRINT(0^0)
.....
{{out}}
1
=={{header|F_Sharp|F#}}== In the REPL:
> let z = 0.**0.;;
val z : float = 1.0
Factor
USING: math.functions.private ; ! ^complex
0 0 ^
C{ 0 0 } C{ 0 0 } ^complex
{{out}}
--- Data stack:
NAN: 8000000000000
C{ NAN: 8000000000000 NAN: 8000000000000 }
Falcon
'''VBA/Python programmer's approach not sure if it's the most falconic way'''
/* created by Aykayayciti Earl Lamont Montgomery
April 9th, 2018 */
x = 0
y = 0
z = x**y
> "z=", z
{{out}}
z=1
[Finished in 0.2s]
Forth
0e 0e f** f.
{{out}}
1.
Of course in an embedded program we would be tempted to "pre-calculate" the answer :-)
: ^0 DROP 1 ;
{{Output}}
0 ^0 . 1 ok
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
{{out}}
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
' FB 1.05.0 Win64
Print "0 ^ 0 ="; 0 ^ 0
Sleep
{{out}}
0 ^ 0 = 1
Gambas
'''[https://gambas-playground.proko.eu/?gist=7d505dbe89227e9b4423f92ef12d6829 Click this link to run this code]'''
Public Sub Main()
Print 0 ^ 0
End
Output:
1
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.
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))
}
{{out}}
float64: 1
big integer: 1
complex: (1+0i)
FutureBasic
include "ConsoleWindow"
print 0^0
Output:
1
Groovy
{{trans|Java}} Test:
println 0**0
{{out}}
1
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)
{{out}}
1
1.0
1.0
1.0
1.0 :+ 0.0
NaN :+ NaN
HolyC
F64 a = 0 ` 0;
Print("0 ` 0 = %5.3f\n", a);
{{out}}
0 ` 0 = 1.000
=={{header|Icon}} and {{header|Unicon}}==
"Works" in both languages:
procedure main()
write(0^0)
end
{{out}}
->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
0 ^ 0
1
Java
System.out.println(Math.pow(0, 0));
{{out}}
1.0
JavaScript
Math.pow
{{Works with|Node.js}} In interactive mode:
Math.pow(0, 0);
1
===exponentiation operator (**)===
0**0
1
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:
def power(y): y as $y | if $y == 0 then 1 elif . == 0 then 0 else log * $y | exp end;
This definition will however be unsatisfactory for many purposes because it does not maintain precision for integer values of the input (.) and y.
Jsish
puts(Math.pow(0,0));
{{out}}
1
Julia
Try all combinations of complex, float, rational, integer and boolean.
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
{{out}}
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
Kotlin
// version 1.0.6
fun main(args: Array<String>) {
println("0 ^ 0 = ${Math.pow(0.0, 0.0)}")
}
{{out}}
0 ^ 0 = 1.0
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.
print(0^0)
{{out}}
1
M2000 Interpreter
M2000 use ** and ^ for power.
Module Checkit {
x=0
y=0
Print x**y=1, x^y=1 ' True True
}
Checkit
Maple
0^0
{{out}}
1
However, for consistency with IEEE-754 numerics, we also have a NaN result for the equivalent floating-point exponentiation:
0^0.0
{{out}}
Float(undefined)
Mathematica
0^0
{{out}}
Indeterminate
=={{header|MATLAB}} / {{header|Octave}}==
0^0
complex(0,0)^0
{{out}}
1
1
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.
{{out}}
int.pow(0, 0) = 1
integer.pow(zero, zero) = 1
float.pow(0.0, 0) = 1.0
Microsoft Small Basic
TextWindow.WriteLine(Math.Power(0,0))
{{out}}
1
min
{{works with|min|0.19.3}}
{{out}}
```txt
1.0
MiniScript
print "The result of zero to the zero power is " + 0^0
{{out}}
The result of zero to the zero power is 1
=={{header|MK-61/52}}==
The result is error message.
## Neko
Neko uses the C math library for exponentiation, Zero to the zero in math.pow(x, y) is treated as being 1.
```ActionScript
/**
Zero to the zeroth power, in Neko
*/
var math_pow = $loader.loadprim("std@math_pow", 2)
$print(math_pow(0, 0), "\n")
{{out}}
prompt$ nekoc zero-to-the-zero.neko
prompt$ neko zero-to-the-zero.n
1
NetRexx
x=0
Say '0**0='||x**x
{{out}}
0**0=1
NewLISP
(pow 0 0)
{{out}}
1
Nial
Create an exponentiation table for all type combinations (of integer 0, float 0.0 and boolean o):
0 0.0 o outer power 0 0.0 o
+--+--+--+
| 1|1.| 1|
+--+--+--+
|1.|1.|1.|
+--+--+--+
| 1|1.| 1|
+--+--+--+
Nim
import math
echo pow(0, 0)
{{out}}
1.0
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
{{out}}
```txt
1
Ol
(print "0^0: " (expt 0 0))
(print "0.0^0: " (expt (inexact 0) 0))
{{out}}
0^0: 1
0.0^0: 1
ooRexx
/**********************************************************************
* 21.04.2014 Walter Pachl
**********************************************************************/
Say 'rxCalcpower(0,0) ->' rxCalcpower(0,0)
Say '0**0 ->' 0**0
::requires rxmath library
{{out}}
rxCalcpower(0,0) -> 1
0**0 -> 1
PARI/GP
0 raised to the power of exact 0 is 0, but 0 cannot be raised to the power of an inexact 0:
0^0
0.^0
0^0.
{{out}}
%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}} {{Libheader|math}}
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.
;output:
0.0 ^ 0 :1.00 0.0 ^ 0.0 :1.00
Perl
print 0 ** 0, "\n";
use Math::Complex;
print cplx(0,0) ** cplx(0,0), "\n";
{{out}}
1
1
Perl 6
{{works with|Rakudo|2018.03}}
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($_,$_);
}
{{out}}
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
Phix
Fair enough, I have no strong opinions on this matter, so I have just removed the test/error that was present in previous versions. Should you for any reason want to change it back, just edit builtins/VM/pPower.e, search for the two mods dated 3/11/15 (32 and 64 bit, both are two lines, test eax/rax; jz :e102cr0tple0), save and rebuild (run "p -c p"), which should take less than 10 seconds.
?power(0,0)
{{out}}
1
PHP
<?php
echo pow(0,0);
echo 0 ** 0; // PHP 5.6+ only
?>
{{out}}
1
1
PicoLisp
(** 0 0)
{{out}} 1
PL/I
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;
{{out}}
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
PowerShell
Write-Host "0 ^ 0 = " ([math]::pow(0,0))
Output :
0 ^ 0 = 1
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
{{out}}
Zero to the zero power is 1
Pyret
num-expt(0, 0)
{{out}} 1
Python
Python3
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}')
{{out}}
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
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))
{{out}}
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
R
print(0^0)
{{out}}
1
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))))
{{out}}
(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
REXX
/*REXX program shows the results of raising zero to the zeroth power.*/
say '0 ** 0 (zero to the zeroth power) ───► ' 0**0
using PC/REXX
using Personal REXX
using REGINA
using ooRexx {{out}}
0 ** 0 (zero to the zeroth power) ───► 1
using R4 {{out}}
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 {{out}}
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
x = 0
y = 0
z = pow(x,y)
see "z=" + z + nl # z=1
Ruby
require 'bigdecimal'
[0, 0.0, Complex(0), Rational(0), BigDecimal.new("0")].each do |n|
printf "%10s: ** -> %s\n" % [n.class, n**n]
end
{{out}}
Fixnum: ** -> 1
Float: ** -> 1.0
Complex: ** -> 1+0i
Rational: ** -> 1/1
BigDecimal: ** -> 0.1E1
Rust
fn main() {
println!("{}",0u32.pow(0));
}
{{out}}
1
=={{header|S-lang}}==
{{out}}
```txt
1.0
Scala
{{libheader|Scala}}
assert(math.pow(0, 0) == 1, "Scala blunder, should go back to school !")
Scheme
(display (expt 0 0)) (newline)
(display (expt 0.0 0.0)) (newline)
(display (expt 0+0i 0+0i)) (newline)
{{out}}
1
1.0
1.0
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;
{{out}}
0 ** 0 = 1
0.0 ** 0 = 1.0
0.0 ** 0.0 = 1.0
0.0+0i ** 0 = 1.0+0.0i
Sidef
[0, Complex(0, 0)].each {|n|
say n**n
}
{{out}}
1
1
Taking the 0'th root of a number and raising it back to the zero power, we also get a 1:
say 0.root(0).pow(0) # => 1
say ((0**(1/0))**0) # => 1
Sinclair ZX81 BASIC
PRINT 0**0
{{out}}
1
Smalltalk
0 raisedTo: 0
0.0 raisedTo: 0.0
{{out}}
1
1.0
smart BASIC
PRINT 0^0
{{out}}
1
SQL
SQL> select power(0,0) from dual;
{{out}}
POWER(0,0)
----------
1
Standard ML
In the interpreter:
- Math.pow (0.0, 0.0);
val it = 1.0 : real
Stata
. display 0^0
1
Swift
import Darwin
print(pow(0.0,0.0))
{{out}}
1.0
Tcl
Interactively…
% expr 0**0
1
% expr 0.0**0.0
1.0
=={{header|TI-83_BASIC}}==
0^0
{{out}}
ERROR:DOMAIN
uBasic/4tH
{{out}}
```txt
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.
out (pow 0 0) endl console
1.0
VBA
Public Sub zero()
x = 0
y = 0
z = 0 ^ 0
Debug.Print "z ="; z
End Sub
{{out}}
z = 1
VBScript
WScript.Echo 0 ^ 0
{{Out}}
1
Visual Basic .NET
Module Program
Sub Main()
Console.Write(0^0)
End Sub
End Module
{{out}}
1
XLISP
XLISP 3.3, September 6, 2002 Copyright (c) 1984-2002, by David Betz
[1] (expt 0 0)
1
[2]
zkl
(0.0).pow(0) //--> 1.0
var BN=Import("zklBigNum"); // big ints
BN(0).pow(0) //--> 1