Zero to the zero power: Difference between revisions
Add Red |
Not a robot (talk | contribs) Add CLU |
||
Line 278: | Line 278: | ||
1.0 |
1.0 |
||
</pre> |
</pre> |
||
=={{header|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> |
|||
{{out}} |
|||
<pre>integer 0**0: 1 |
|||
real 0**0: 1.0</pre> |
|||
=={{header|COBOL}}== |
=={{header|COBOL}}== |
Revision as of 22:39, 1 December 2021
You are encouraged to solve this task according to the task description, using any language you may know.
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 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): .
- The OEIS entry: The special case of zero to the zeroth power
11l
<lang 11l>print(0 ^ 0)</lang>
- Output:
1
8th
<lang forth> 0 0 ^ . </lang>
- Output:
1
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
<lang algol68>print( ( 0 ^ 0, newline ) ) </lang>
- Output:
+1
APL
<lang apl> 0*0 1</lang>
AppleScript
<lang applescript> return 0 ^ 0</lang>
- Output:
<lang applescript>1.0</lang>
Applesoft BASIC
]? 0^0 1
Arturo
<lang rebol>print 0 ^ 0 print 0.0 ^ 0</lang>
- Output:
1 1.0
AutoHotkey
<lang AutoHotkey>MsgBox % 0 ** 0</lang>
- Output:
1
AWK
<lang AWK>
- syntax: GAWK -f ZERO_TO_THE_ZERO_POWER.AWK
BEGIN {
print(0 ^ 0) exit(0)
} </lang>
- Output:
1
BaCon
<lang freebasic>PRINT POW(0, 0)</lang>
- Output:
prompt$ ./zerotothezero 1
BBC BASIC
<lang bbcbasic> PRINT 0^0</lang>
- Output:
1
Bc
<lang Bc> 0 ^ 0 </lang>
- Output:
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).
<lang befunge>"PDPF"4#@(0F0FYP)@</lang>
- Output:
1.000000
Bracmat
<lang bracmat>0^0</lang>
- Output:
1
Burlesque
<lang blsq> blsq ) 0.0 0.0?^ 1.0 blsq ) 0 0?^ 1 </lang>
C
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 ^ZEROPOW0 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:
1
ColdFusion
Classic tag based CFML
<lang cfm> <cfset zeroPowerTag = 0^0> <cfoutput>"#zeroPowerTag#"</cfoutput> </lang>
- Output:
"1"
Script Based CFML
<lang cfm><cfscript>
zeroPower = 0^0; writeOutput( zeroPower );
</cfscript></lang>
- Output:
1
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
<lang dc>0 0^p </lang>
- Output:
1
Delphi
See Pascal.
EasyLang
<lang>print pow 0 0</lang>
EchoLisp
<lang scheme>
- 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:
1
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
<lang Lisp>(expt 0 0)</lang>
- Output:
1
ERRE
<lang ERRE> ..... PRINT(0^0) ..... </lang>
- Output:
1
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
<lang fermat>0^0</lang>
- Output:
1
Forth
<lang forth>0e 0e f** f.</lang>
- Output:
1.
Of course in an embedded program we would be tempted to "pre-calculate" the answer :-)
<lang Forth>: ^0 DROP 1 ;</lang>
- 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:
1
FutureBasic
<lang futurebasic> include "ConsoleWindow"
print 0^0 </lang> Output:
1
Gambas
Click this link to run this code <lang gambas>Public Sub Main()
Print 0 ^ 0
End</lang> 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. <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
Test: <lang groovy>println 0**0</lang>
- Output:
1
GW-BASIC
<lang gwbasic>PRINT 0^0</lang>
- Output:
1
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
<lang j> 0 ^ 0 1</lang>
Java
<lang java>System.out.println(Math.pow(0, 0));</lang>
- Output:
1.0
JavaScript
Math.pow
In interactive mode: <lang javascript>> Math.pow(0, 0); 1</lang>
exponentiation operator (**)
<lang javascript>> 0**0 1</lang>
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
<lang javascript>puts(Math.pow(0,0));</lang>
- Output:
1
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
<lang 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
<lang Scheme> {pow 0 0} -> 1 {exp 0 0} -> 1 </lang>
Liberty BASIC
<lang lb> '******** print 0^0 '******** </lang>
- Output:
1
Locomotive Basic
<lang locobasic>print 0🠅0</lang>
- Output:
1
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:
1
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
<lang Maple>0^0</lang>
- Output:
1
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
<lang Mathematica>0^0</lang>
- Output:
Indeterminate
MATLAB / Octave
<lang Matlab>0^0 complex(0,0)^0</lang>
- Output:
1 1
Maxima
<lang maxima>0^0;</lang>
- 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:
1
min
<lang min>0 0 pow puts</lang>
- 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
<lang>Сx ^ x^y С/П</lang>
The result is error message.
Nanoquery
<lang nanoquery>println 0^0</lang>
- Output:
1
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
<lang netrexx>x=0 Say '0**0='||x**x</lang>
- Output:
0**0=1
NewLISP
<lang newlisp>(pow 0 0)</lang>
- Output:
1
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:
1
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
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
<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
?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:
1
PHP
<lang PHP><?php echo pow(0,0); echo 0 ** 0; // PHP 5.6+ only ?></lang>
- Output:
1 1
PicoLisp
<lang PicoLisp> (** 0 0) </lang>
- Output:
1
Pike
<lang Pike>write( pow(0, 0) +"\n" );</lang>
- Output:
1
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:
1
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
<lang Pyret>num-expt(0, 0)</lang>
- 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:
1
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.
1 1 1 1 1 1 1
Quackery
As a dialogue in the Quackery shell.
<lang Quackery>/O> 0 0 ** ...
Stack: 1 </lang>
R
<lang rsplus>print(0^0)</lang>
- Output:
1
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)
<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
<lang Relation> echo pow(0,0) // 1 </lang>
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
<lang ring> x = 0 y = 0 z = pow(x,y) see "z=" + z + nl # z=1 </lang>
Ruby
<lang 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</lang>
- Output:
Fixnum: ** -> 1 Float: ** -> 1.0 Complex: ** -> 1+0i Rational: ** -> 1/1 BigDecimal: ** -> 0.1E1
Rust
<lang rust>fn main() {
println!("{}",0u32.pow(0));
}</lang>
- Output:
1
S-lang
<lang S-lang>print(0^0);</lang>
- Output:
1.0
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:
<lang ruby>say 0.root(0).pow(0) # => 1 say ((0**(1/0))**0) # => 1</lang>
Sinclair ZX81 BASIC
<lang basic>PRINT 0**0</lang>
- Output:
1
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:
1
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
<lang Symsyn>
(0^0) []
</lang>
- Output:
1
Tcl
Interactively… <lang tcl>% expr 0**0 1 % expr 0.0**0.0 1.0</lang>
TI-83_BASIC
<lang tibasic>0^0</lang>
- 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:
1
Visual Basic .NET
<lang vbnet>Module Program
Sub Main() Console.Write(0^0) End Sub
End Module</lang>
- Output:
1
Wren
<lang ecmascript>System.print(0.pow(0))</lang>
- Output:
1
XLISP
<lang scheme>XLISP 3.3, September 6, 2002 Copyright (c) 1984-2002, by David Betz [1] (expt 0 0)
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>
- Programming Tasks
- Solutions by Programming Task
- Simple
- 6502 Assembly/Omit
- Z80 Assembly/Omit
- 68000 Assembly/Omit
- 8086 Assembly/Omit
- 11l
- 8th
- AArch64 Assembly/Omit
- ARM Assembly/Omit
- Ada
- ALGOL 68
- APL
- AppleScript
- Applesoft BASIC
- Arturo
- AutoHotkey
- AWK
- BaCon
- BBC BASIC
- Bc
- Befunge
- Bracmat
- Burlesque
- C
- C sharp
- C++
- Caché ObjectScript
- Clojure
- CLU
- COBOL
- ColdFusion
- Commodore BASIC
- Common Lisp
- Crystal
- D
- Dc
- Delphi
- EasyLang
- EchoLisp
- Eiffel
- Elena
- Elixir
- Emacs Lisp
- ERRE
- F Sharp
- Factor
- Falcon
- Fermat
- Forth
- Fortran
- FreeBASIC
- Frink
- FutureBasic
- Gambas
- Go
- Groovy
- GW-BASIC
- Haskell
- HolyC
- Icon
- Unicon
- J
- Java
- JavaScript
- Jq
- Jsish
- Julia
- K
- Klingphix
- Kotlin
- Lambdatalk
- Liberty BASIC
- Locomotive Basic
- Lua
- M2000 Interpreter
- Maple
- Mathematica
- Wolfram Language
- MATLAB
- Octave
- Maxima
- Mercury
- Microsoft Small Basic
- Min
- MiniScript
- МК-61/52
- Nanoquery
- Neko
- NetRexx
- NewLISP
- Nial
- Nim
- OCaml
- Oforth
- Ol
- OoRexx
- PARI/GP
- Pascal
- Math
- Perl
- Phix
- Phix/basics
- Phixmonti
- PHP
- PicoLisp
- Pike
- PL/I
- Plain English
- PowerShell
- PureBasic
- Pyret
- Python
- QB64
- Quackery
- R
- Racket
- Raku
- Red
- Relation
- REXX
- Ring
- Ruby
- Rust
- S-lang
- Scala
- Scheme
- Seed7
- SenseTalk
- Sidef
- Sinclair ZX81 BASIC
- Smalltalk
- Smart BASIC
- SQL
- Standard ML
- Stata
- Swift
- Symsyn
- Tcl
- TI-83 BASIC
- UBasic/4tH
- Ursa
- VBA
- VBScript
- Visual Basic .NET
- Wren
- XLISP
- XPL0
- Zkl