Zero to the zero power: Difference between revisions
m
→{{header|Binary Lambda Calculus}}
m (Emacs Lisp: Fix formatting) |
|||
(34 intermediate revisions by 22 users not shown) | |||
Line 2:
[[Category:Simple]]
{{omit from|6502 Assembly|There is no built in multiplication, let alone exponentiation. Thus the outcome is decided by the programmer not the language.}}
{{omit from|8080 Assembly|See 6502 Assembly.}}
{{omit from|Computer/zero Assembly|See 6502 Assembly.}}
{{omit from|Z80 Assembly|See 6502 Assembly.}}
{{omit from|68000 Assembly|There is no built-in exponentiation so the programmer's implementation decides the outcome.}}
{{omit from|8086 Assembly|There is no built-in exponentiation so the programmer's implementation decides the outcome.}}
{{omit from|MIPS Assembly|There is no built-in exponentiation so the programmer's implementation decides the outcome.}}
{{omit from|ARM Assembly|See 8086 Assembly.}}
Some computer programming languages are not exactly consistent (with other computer programming languages)
<br>when ''raising zero to the zeroth power'': <b><big>0<sup>0</sup></big></b>
Line 25 ⟶ 29:
;See also:
* The Wiki entry: [[wp:
* The Wiki entry: [[wp:
* 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>.
Line 33 ⟶ 37:
=={{header|11l}}==
<syntaxhighlight lang
{{out}}
Line 41 ⟶ 45:
=={{header|8th}}==
<
0 0 ^ .
</syntaxhighlight>
{{out}}
1
Line 52 ⟶ 56:
=={{header|Action!}}==
{{libheader|Action! Tool Kit}}
<
PROC Main()
Line 65 ⟶ 69:
PrintR(z) Print("=")
PrintRE(res)
RETURN</
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Zero_to_the_zero_power.png Screenshot from Atari 8-bit computer]
Line 73 ⟶ 77:
=={{header|Ada}}==
<
Ada.Long_Long_Integer_Text_IO, Ada.Float_Text_IO, Ada.Long_Float_Text_IO,
Ada.Long_Long_Float_Text_IO;
Line 104 ⟶ 108:
Put (LLF ** Zero); New_Line;
end Test5;
</syntaxhighlight>
{{out}}
<pre>Integer 0^0 = 1
Line 116 ⟶ 120:
=={{header|ALGOL 68}}==
{{works with|ALGOL 68G|Any - tested with release 2.6.win32}}
<
</syntaxhighlight>
{{out}}
<pre>
Line 124 ⟶ 128:
=={{header|APL}}==
<
1</
=={{header|AppleScript}}==
<syntaxhighlight lang
{{output}}
<syntaxhighlight lang
=={{header|Applesoft BASIC}}==
Line 141 ⟶ 145:
=={{header|Arturo}}==
<
print 0.0 ^ 0</
{{out}}
Line 148 ⟶ 152:
<pre>1
1.0</pre>
=={{header|Asymptote}}==
<syntaxhighlight lang="asymptote">write("0 ^ 0 = ", 0 ** 0);</syntaxhighlight>
=={{header|AutoHotkey}}==
<syntaxhighlight lang
{{out}}
<pre>1</pre>
=={{header|AWK}}==
<syntaxhighlight lang="awk">
# syntax: GAWK -f ZERO_TO_THE_ZERO_POWER.AWK
BEGIN {
Line 161 ⟶ 168:
exit(0)
}
</syntaxhighlight>
{{out}}
<pre>
Line 168 ⟶ 175:
=={{header|BaCon}}==
<syntaxhighlight lang
{{out}}
Line 176 ⟶ 183:
=={{header|BASIC}}==
==={{header|BASIC256}}===
<
==={{header|Chipmunk Basic}}===
<syntaxhighlight lang="qbasic">10 print "0 ^ 0 = ";0^0</syntaxhighlight>
==={{header|MSX Basic}}===
<syntaxhighlight lang="qbasic">10 PRINT "0 ^ 0 = "; 0 ^ 0</syntaxhighlight>
==={{header|QBasic}}===
{{works with|QBasic|1.1}}
{{works with|QuickBasic|4.5}}
<
==={{header|Run BASIC}}===
{{works with|Just BASIC}}
{{works with|Liberty BASIC}}
<syntaxhighlight lang="lb">print "0 ^ 0 = "; 0 ^ 0</syntaxhighlight>
==={{header|True BASIC}}===
{{works with|QBasic}}
<
END</
==={{header|XBasic}}===
{{works with|Windows XBasic}}
<syntaxhighlight lang="xbasic">PROGRAM "progname"
VERSION "0.0000"
IMPORT "xma" 'required for POWER
DECLARE FUNCTION Entry ()
FUNCTION Entry ()
PRINT "0 ^ 0 = "; 0 ** 0
PRINT "0 ^ 0 = "; POWER(0, 0)
END FUNCTION
END PROGRAM</syntaxhighlight>
==={{header|ZX Spectrum Basic}}===
<syntaxhighlight lang="zxbasic">PRINT 0↑0</syntaxhighlight>
{{out}}
<pre>
1
0 OK, 0:1
</pre>
=={{header|BBC BASIC}}==
<
{{out}}
Line 198 ⟶ 240:
=={{header|Bc}}==
<syntaxhighlight lang="bc">
0 ^ 0
</syntaxhighlight>
{{out}}
1
Line 209 ⟶ 251:
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|Binary Lambda Calculus}}==
In lambda calculus, <code>\n. n n</code> is a function mapping a Church numeral n to the Church numeral n^n. The following BLC program computes this for n=0 by using its empty input as a Church numeral (since nil coincides with Church numeral 0), and outputting in unary (i.e as a string of 0^0 1s), as generated from https://github.com/tromp/AIT/blob/master/rosetta/exp00.lam :
<pre>0001010110100000010110111011010</pre>
Output:
<pre>1</pre>
=={{header|BQN}}==
BQN doesn't specify the details of arithmetic functions; existing implementations use IEEE doubles and the <code>pow</code> function, giving a result of 1.
<syntaxhighlight lang
{{out}}
<pre>1</pre>
=={{header|Bracmat}}==
<syntaxhighlight lang
{{out}}
<pre>1</pre>
=={{header|Burlesque}}==
<
blsq ) 0.0 0.0?^
1.0
blsq ) 0 0?^
1
</syntaxhighlight>
=={{header|C}}==
Line 237 ⟶ 289:
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>
Line 247 ⟶ 299:
printf("0+0i ^ 0+0i = %f+%fi\n", creal(c), cimag(c));
return 0;
}</
{{out}}
Line 256 ⟶ 308:
=={{header|C sharp|C#}}==
<
namespace ZeroToTheZeroeth
Line 268 ⟶ 320:
}
}
}</
{{out}}
Line 276 ⟶ 328:
=={{header|C++}}==
<
#include <cmath>
#include <complex>
Line 286 ⟶ 338:
std::pow(std::complex<double>(0),std::complex<double>(0)) << std::endl;
return 0;
}</
{{out}}
Line 295 ⟶ 347:
=={{header|Caché ObjectScript}}==
<
// default behavior is incorrect:
set (x,y) = 0
Line 304 ⟶ 356:
w !,"0 to the 0th power (right): "_(x**y)
quit</
{{out}}<pre>SAMPLES>do ^ZEROPOW
Line 326 ⟶ 378:
1 in my case could just be an implementation detail.
<
zz_int: int := 0 ** 0
zz_real: real := 0.0 ** 0.0
Line 333 ⟶ 385:
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</
{{out}}
<pre>integer 0**0: 1
Line 339 ⟶ 391:
=={{header|COBOL}}==
<
program-id. zero-power-zero-program.
data division.
Line 347 ⟶ 399:
compute n = 0**0.
display n upon console.
stop run.</
{{out}}
<pre>1</pre>
Line 353 ⟶ 405:
=={{header|ColdFusion}}==
=== Classic tag based CFML ===
<
<cfset zeroPowerTag = 0^0>
<cfoutput>"#zeroPowerTag#"</cfoutput>
</syntaxhighlight>
{{Output}}
<pre>
Line 363 ⟶ 415:
=== Script Based CFML ===
<
zeroPower = 0^0;
writeOutput( zeroPower );
</cfscript></
{{Output}}
<pre>
Line 390 ⟶ 442:
=={{header|Crystal}}==
<
puts "Negative Int32: #{-0_i32**-0_i32}"
puts "Float32: #{0_f32**0_f32}"
puts "Negative Float32: #{-0_f32**-0_f32}"</
{{Output}}
Line 402 ⟶ 454:
=={{header|D}}==
<
import std.stdio, std.math, std.bigint, std.complex;
Line 413 ⟶ 465:
writeln("BigInt: ", 0.BigInt ^^ 0);
writeln("Complex: ", complex(0.0, 0.0) ^^ 0);
}</
{{out}}
<pre>Int: 1
Line 423 ⟶ 475:
BigInt: 1
Complex: 1+0i</pre>
=={{header|Dart}}==
<syntaxhighlight lang="dart">import 'dart:math';
void main() {
var resul = pow(0, 0);
print("0 ^ 0 = $resul");
}</syntaxhighlight>
{{out}}
<pre>0 ^ 0 = 1</pre>
=={{header|Dc}}==
<
</syntaxhighlight>
{{Output}}
<pre>
Line 437 ⟶ 499:
=={{header|EasyLang}}==
<syntaxhighlight lang="text">print pow 0 0</
=={{header|EchoLisp}}==
<
;; trying the 16 combinations
;; all return the integer 1
Line 448 ⟶ 510:
(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
</syntaxhighlight>
=={{header|Eiffel}}==
<syntaxhighlight lang
{{out}}
<pre>1</pre>
=={{header|Elena}}==
ELENA
<
public program()
{
console.printLine("0^0 is ",0.power
}</
{{out}}
<pre>
Line 470 ⟶ 532:
=={{header|Elixir}}==
Elixir uses Erlang's <code>:math</code> for power operations and can handle zero to the zero power.
<syntaxhighlight lang="elixir">
:math.pow(0,0)
</syntaxhighlight>
{{out}}
1.0
=={{header|Emacs Lisp}}==
<syntaxhighlight lang
{{out}}
1
=={{header|EMal}}==
<syntaxhighlight lang="emal">
writeLine(0 ** 0) # an integer
writeLine(0.0 ** 0.0) # a real
</syntaxhighlight>
{{out}}
<pre>
1
1.0
</pre>
=={{header|ERRE}}==
<syntaxhighlight lang="erre">
.....
PRINT(0^0)
.....
</syntaxhighlight>
{{out}}
<pre> 1
Line 498 ⟶ 571:
=={{header|Factor}}==
<
0 0 ^
C{ 0 0 } C{ 0 0 } ^complex</
{{out}}
<pre>--- Data stack:
Line 508 ⟶ 581:
=={{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 */
Line 517 ⟶ 590:
> "z=", z
</syntaxhighlight>
{{out}}
<pre>
Line 525 ⟶ 598:
=={{header|Fermat}}==
<syntaxhighlight lang
{{out}}<pre>1</pre>
=={{header|Forth}}==
<syntaxhighlight lang
{{out}}
Line 536 ⟶ 609:
Of course in an embedded program we would be tempted to "pre-calculate" the answer :-)
<
{{Output}}
Line 545 ⟶ 618:
=={{header|Fortran}}==
<syntaxhighlight lang="fortran">
program zero
double precision :: i, j
Line 557 ⟶ 630:
write(*,*) 'When complex numbers are used, we have (0.0+0.0i)^(0.0+0.0i) = ', z1**z2
end program
</syntaxhighlight>
{{out}}
<pre>
Line 566 ⟶ 639:
=={{header|FreeBASIC}}==
<
Print "0 ^ 0 ="; 0 ^ 0
Sleep</
{{out}}
Line 577 ⟶ 650:
=={{header|Frink}}==
<syntaxhighlight lang
{{out}}
Line 586 ⟶ 659:
=={{header|FutureBasic}}==
<
print 0^0
HandleEvents</syntaxhighlight>
Output:
<pre>
Line 598 ⟶ 671:
=={{header|Gambas}}==
'''[https://gambas-playground.proko.eu/?gist=7d505dbe89227e9b4423f92ef12d6829 Click this link to run this code]'''
<
Print 0 ^ 0
End</
Output:
<pre>
1
</pre>
=={{header|GAP}}==
<syntaxhighlight lang="gap">0^0;</syntaxhighlight>
{{out}}<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 (
Line 625 ⟶ 702:
fmt.Println("big integer:", b.Exp(&b, &b, nil))
fmt.Println("complex: ", cmplx.Pow(0, 0))
}</
{{out}}
<pre>
Line 632 ⟶ 709:
complex: (1+0i)
</pre>
=={{header|Golfscript}}==
<syntaxhighlight lang="golfscript">0 0?</syntaxhighlight>
{{out}}
<pre>1</pre>
=={{header|Groovy}}==
{{trans|Java}}
Test:
<syntaxhighlight lang
{{out}}
<pre>1</pre>
=={{header|GW-BASIC}}==
<syntaxhighlight lang
{{out}}<pre>1</pre>
=={{header|Haskell}}==
<
main
main = mapM_ print
(0 :+ 0) ** (0 :+ 0)
]</syntaxhighlight>
{{out}}
<pre>1
1.0
1.0
1.0
1.0 :+ 0.0
=={{header|HolyC}}==
<
Print("0 ` 0 = %5.3f\n", a);</
{{out}}
Line 676 ⟶ 758:
"Works" in both languages:
<
write(0^0)
end</
{{out}}
Line 694 ⟶ 776:
=={{header|J}}==
<
1</
Note also that this is the multiplicative identity (which means that it's consistent with <code>1*0</code> representing <code>0^1</code> and with <code>1*0*0</code> representing <code>0^2</code> and with <code>1*0*0*0</code> representing <code>0^3</code> and with <code>1*2*2*2</code> representing <code>2^3</code> and so on. Also, this is the result of finding the product of an empty list:
<syntaxhighlight lang="J"> */''
1</syntaxhighlight>
(In <code><nowiki>*/''</nowiki></code> we're finding the product of a list which contains no characters. This is, of course, the same as the product of a list which contains no numbers when both lists contain neither. That said, characters are outside the domain of multiplication in J, so if the list had contained any characters the product would have been an error rather than a result.)
=={{header|Java}}==
<
{{out}}
<pre>1.0</pre>
Line 706 ⟶ 795:
{{Works with|Node.js}}
In interactive mode:
<
1</
===exponentiation operator (**)===
<
1</
=={{header|jq}}==
{{works with|jq|1.5}}
'''Also works with gojq and fq'''
<pre>
$ jq -n 'pow(0;0)'
1
</pre>
It is also worth noting that in jq, gojq, and fq, `pow(0; infinite)` yields 0.
=={{header|Jsish}}==
<
{{out}}
<pre>1</pre>
Line 729 ⟶ 817:
=={{header|Julia}}==
Try all combinations of complex, float, rational, integer and boolean.
<
const types = (Complex, Float64, Rational, Int, Bool)
Line 737 ⟶ 825:
r = zb ^ ze
@printf("%10s ^ %-10s = %7s ^ %-7s = %-12s (%s)\n", Tb, Te, zb, ze, r, typeof(r))
end</
{{out}}
Line 767 ⟶ 855:
=={{header|K}}==
<syntaxhighlight lang="k">
0^0
1.0
</syntaxhighlight>
=={{header|Klingphix}}==
<
dup not (
[ drop sign dup 0 equal [ drop 1 ] if ]
Line 782 ⟶ 870:
0 0 mypower print nl
"End " input</
{{out}}
<pre>1
Line 788 ⟶ 876:
=={{header|Kotlin}}==
<syntaxhighlight lang="kotlin">import kotlin.math.pow
fun main(
println(
}</
{{out}}
<pre>
</pre>
=={{header|Lambdatalk}}==
<syntaxhighlight lang="scheme">
{pow 0 0}
-> 1
{exp 0 0}
-> 1
</syntaxhighlight>
=={{header|LDPL}}==
<syntaxhighlight lang="ldpl">data:
x is number
procedure:
raise 0 to 0 in x
display x lf
</syntaxhighlight>
{{out}}
<pre>
1
</pre>
=={{header|Liberty BASIC}}==
<syntaxhighlight lang="lb">
'********
print 0^0
'********
</syntaxhighlight>
{{out}}
<pre>1</pre>
Line 818 ⟶ 919:
=={{header|Locomotive Basic}}==
<syntaxhighlight lang
{{out}}
<pre> 1</pre>
Line 824 ⟶ 925:
=={{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.
<syntaxhighlight lang
{{out}}
<pre>1</pre>
Line 830 ⟶ 931:
=={{header|M2000 Interpreter}}==
M2000 use ** and ^ for power.
<syntaxhighlight lang="m2000 interpreter">
Module Checkit {
x=0
Line 837 ⟶ 938:
}
Checkit
</syntaxhighlight>
=={{header|Maple}}==
<syntaxhighlight lang
{{out}}
<pre>1</pre>
However, for consistency with IEEE-754 numerics, we also have a NaN result for the equivalent floating-point exponentiation:
<syntaxhighlight lang
{{out}}
<pre>Float(undefined)</pre>
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<syntaxhighlight lang
{{out}}
<pre>Indeterminate</pre>
=={{header|MATLAB}} / {{header|Octave}}==
<syntaxhighlight lang="matlab">0^0
complex(0,0)^0</
{{out}}
<pre>1
1</pre>
=={{header|Maxima}}==
<syntaxhighlight lang
{{out}}<pre> 0
expt: undefined: 0</pre>
=={{header|Mercury}}==
<
:- interface.
Line 883 ⟶ 984:
io.format(" float.pow(0.0, 0) = %.1f\n", [f(pow(0.0, 0))], !IO).
:- end_module zero_to_the_zero_power.</
{{out}}
<pre> int.pow(0, 0) = 1
Line 890 ⟶ 991:
=={{header|Microsoft Small Basic}}==
<
{{out}}<pre>1</pre>
=={{header|min}}==
{{works with|min|0.19.3}}
<syntaxhighlight lang
{{out}}
<pre>
Line 902 ⟶ 1,003:
=={{header|MiniScript}}==
<
{{out}}
<pre>
Line 909 ⟶ 1,010:
=={{header|МК-61/52}}==
<syntaxhighlight lang="text">Сx ^ x^y С/П</
The result is error message.
=={{header|Nanoquery}}==
<syntaxhighlight lang
{{out}}
<pre>1</pre>
Line 921 ⟶ 1,022:
Neko uses the C math library for exponentiation, Zero to the zero in math.pow(x, y) is treated as being 1.
<syntaxhighlight lang="actionscript">/**
Zero to the zeroth power, in Neko
*/
Line 927 ⟶ 1,028:
var math_pow = $loader.loadprim("std@math_pow", 2)
$print(math_pow(0, 0), "\n")</
{{out}}
Line 935 ⟶ 1,036:
=={{header|NetRexx}}==
<
Say '0**0='||x**x</
{{out}}
<pre>0**0=1</pre>
=={{header|NewLISP}}==
<syntaxhighlight lang
{{out}}
<pre>1</pre>
Line 949 ⟶ 1,050:
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|
Line 956 ⟶ 1,057:
+--+--+--+
| 1|1.| 1|
+--+--+--+</
=={{header|Nim}}==
<
echo pow(0.0, 0.0) # Floating point exponentiation.
echo 0 ^ 0 # Integer exponentiation.</
{{out}}
<pre>1.0
Line 982 ⟶ 1,083:
=={{header|Oforth}}==
<syntaxhighlight lang
{{out}}
Line 990 ⟶ 1,091:
=={{header|Ol}}==
<
(print "0^0: " (expt 0 0))
(print "0.0^0: " (expt (inexact 0) 0))
</syntaxhighlight>
{{out}}
<pre>
Line 1,001 ⟶ 1,102:
=={{header|ooRexx}}==
<
* 21.04.2014 Walter Pachl
**********************************************************************/
Say 'rxCalcpower(0,0) ->' rxCalcpower(0,0)
Say '0**0 ->' 0**0
::requires rxmath library</
{{out}}
<pre>
Line 1,015 ⟶ 1,116:
=={{header|Openscad}}==
<syntaxhighlight lang
=={{header|PARI/GP}}==
0 raised to the power of exact 0 is
<
0.^0
0^0.</
{{out}}
<pre>%1 = 1
Line 1,033 ⟶ 1,134:
=={{header|Pascal}}==
{{works with|Free Pascal}} {{Libheader|math}}
<
uses
math;
Line 1,039 ⟶ 1,140:
write('0.0 ^ 0 :',IntPower(0.0,0):4:2);
writeln(' 0.0 ^ 0.0 :',Power(0.0,0.0):4:2);
end.</
;output:
<pre>0.0 ^ 0 :1.00 0.0 ^ 0.0 :1.00</pre>
=={{header|Perl}}==
<
use Math::Complex;
print cplx(0,0) ** cplx(0,0), "\n";</
{{out}}
<pre>
Line 1,057 ⟶ 1,158:
=={{header|Phix}}==
{{libheader|Phix/basics}}
<!--<
<span style="color: #0000FF;">?</span><span style="color: #7060A8;">power</span><span style="color: #0000FF;">(</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #000000;">0</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">requires</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"0.8.4"</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- (now fixed/crashes on earlier versions)</span>
Line 1,066 ⟶ 1,167:
<span style="color: #000000;">sb</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">complex_sprint</span><span style="color: #0000FF;">(</span><span style="color: #000000;">b</span><span style="color: #0000FF;">,</span><span style="color: #004600;">true</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%s ^ %s = %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">sa</span><span style="color: #0000FF;">,</span><span style="color: #000000;">sa</span><span style="color: #0000FF;">,</span><span style="color: #000000;">sb</span><span style="color: #0000FF;">})</span>
<!--</
{{out}}
<pre>
Line 1,074 ⟶ 1,175:
=={{header|Phixmonti}}==
<
dup not if
. sign dup 0 == if . 1 endif
Line 1,082 ⟶ 1,183:
enddef
0 0 mypower print</
{{out}}
<pre>1</pre>
=={{header|PHP}}==
<
echo pow(0,0);
echo 0 ** 0; // PHP 5.6+ only
?></
{{out}}
<pre>
Line 1,098 ⟶ 1,199:
=={{header|PicoLisp}}==
<syntaxhighlight lang="picolisp">
(** 0 0)
</syntaxhighlight>
{{out}}
1
=={{header|Pike}}==
<
{{Out}}
<pre>
Line 1,112 ⟶ 1,213:
=={{header|PL/I}}==
<
Dcl a dec float(10) Init(1);
Dcl b dec float(10) Init(0);
Line 1,118 ⟶ 1,219:
Put skip list('0**1=',b**a);
Put skip list('0**0=',b**b);
End;</
{{out}}
<pre>
Line 1,129 ⟶ 1,230:
=={{header|Plain English}}==
<
Start up.
Put 0 into a number.
Line 1,136 ⟶ 1,237:
Write the string to the console.
Wait for the escape key.
Shut down.</
{{out}}
<pre>
Line 1,144 ⟶ 1,245:
=={{header|PowerShell}}==
<
Output :
Line 1,153 ⟶ 1,254:
=={{header|PureBasic}}==
<syntaxhighlight lang="purebasic">
If OpenConsole()
PrintN("Zero to the zero power is " + Pow(0,0))
Line 1,161 ⟶ 1,262:
CloseConsole()
EndIf
</syntaxhighlight>
{{out}}
Line 1,169 ⟶ 1,270:
=={{header|Pyret}}==
<syntaxhighlight lang
{{out}}
1
Line 1,175 ⟶ 1,276:
=={{header|Python}}==
===Python3===
<
from fractions import Fraction
from itertools import product
Line 1,185 ⟶ 1,286:
except:
ans = '<Exception raised>'
print(f'{i!r:>15} ** {j!r:<15} = {ans!r}')</
{{out}}
<pre> 0 ** 0 = 1
Line 1,253 ⟶ 1,354:
===Python2===
<
from fractions import Fraction
for n in (Decimal(0), Fraction(0, 1), complex(0), float(0), int(0)):
Line 1,264 ⟶ 1,365:
except:
n2 = '<Raised exception>'
print('%8s: ** -> %r; pow -> %r' % (n.__class__.__name__, n1, n2))</
{{out}}
<pre>
Line 1,275 ⟶ 1,376:
=={{header|QB64}}==
<syntaxhighlight lang
{{out}}
<pre>1</pre>
Alternatively:
<
l& = 0 'Long integer
s! = 0.0 'Single precision floating point
Line 1,293 ⟶ 1,394:
Print b` ^ b`
Print bb%% ^ bb%%
Print isf&& ^ isf&&</
{{out}}
NB: Values with 0 decimals are trimmed by Print's casting from number value to String.
Line 1,307 ⟶ 1,408:
As a dialogue in the Quackery shell.
<
...
Stack: 1
</syntaxhighlight>
=={{header|R}}==
<syntaxhighlight lang
{{out}}
<pre>1</pre>
Line 1,320 ⟶ 1,421:
=={{header|Racket}}==
<
;; as many zeros as I can think of...
(define zeros (list
Line 1,333 ⟶ 1,434:
(printf "(~a)^(~a) = ~s~%" z p
(with-handlers [(exn:fail:contract:divide-by-zero? exn-message)]
(expt z p))))</
{{out}}
Line 1,377 ⟶ 1,478:
{{works with|Rakudo|2018.03}}
<syntaxhighlight lang="raku"
say '-------- -------- -------- --------';
for 0, 0.0, FatRat.new(0), 0e0, 0+0i {
printf "%8s %8s %8s %8s\n", .^name, $_, $_**$_, exp($_,$_);
}</
{{out}}
Line 1,397 ⟶ 1,498:
=={{header|Red}}==
Shown using the operator, the function, and the <code>math</code> mini-DSL that uses the order of operations from mathematics:
<
print 0 ** 0
print power 0 0
print math [0 ** 0]</
{{out}}
<pre>
Line 1,409 ⟶ 1,510:
=={{header|Relation}}==
<syntaxhighlight lang="relation">
echo pow(0,0)
// 1
</syntaxhighlight>
=={{header|REXX}}==
<
say '0 ** 0 (zero to the zeroth power) ───► ' 0**0</
<br>using PC/REXX
<br>using Personal REXX
Line 1,447 ⟶ 1,548:
=={{header|Ring}}==
<
x = 0
y = 0
z = pow(x,y)
see "z=" + z + nl # z=1
</syntaxhighlight>
=={{header|RPL}}==
0 0 ^
====Output for HP-48G and older models====
1: 1
====Output for HP-49 and newer models====
1: ?
=={{header|Ruby}}==
<
[0, 0.0, Complex(0), Rational(0), BigDecimal("0")].each do |n|
printf "%10s: ** -> %s\n" % [n.class, n**n]
end</
{{out}}
<pre>
Line 1,470 ⟶ 1,578:
=={{header|Rust}}==
<
println!("{}",0u32.pow(0));
}</
{{out}}
Line 1,478 ⟶ 1,586:
=={{header|S-lang}}==
<syntaxhighlight lang
{{out}}
<pre>1.0</pre>
=={{header|Scala}}==
{{libheader|Scala}}<
=={{header|Scheme}}==
<
(display (expt 0.0 0.0)) (newline)
(display (expt 0+0i 0+0i)) (newline)</
{{out}}
<pre>1
Line 1,495 ⟶ 1,603:
=={{header|Seed7}}==
<
include "float.s7i";
include "complex.s7i";
Line 1,506 ⟶ 1,614:
writeln("0.0+0i ** 0 = " <& complex(0.0) ** 0);
end func;
</syntaxhighlight>
{{out}}
Line 1,517 ⟶ 1,625:
=={{header|SenseTalk}}==
<
set b to 0
put a to the power of b
// Prints: 1</
=={{header|Sidef}}==
<
say n**n
}</
{{out}}
<pre>
Line 1,535 ⟶ 1,643:
Taking the 0'th root of a number and raising it back to the zero power, we also get a 1:
<
say ((0**(1/0))**0) # => 1</
=={{header|Sinclair ZX81 BASIC}}==
<syntaxhighlight lang
{{out}}
<pre>1</pre>
Line 1,545 ⟶ 1,653:
=={{header|Smalltalk}}==
<
0 raisedTo: 0
0.0 raisedTo: 0.0
</syntaxhighlight>
{{out}}
<pre>
Line 1,556 ⟶ 1,664:
=={{header|smart BASIC}}==
<syntaxhighlight lang
{{out}}
Line 1,565 ⟶ 1,673:
=={{header|SNOBOL4}}==
<
END</
=={{header|SQL}}==
<syntaxhighlight lang="sql">
SQL> select power(0,0) from dual;
</syntaxhighlight>
{{out}}
<pre>
Line 1,588 ⟶ 1,696:
=={{header|Stata}}==
<
1</
=={{header|Swift}}==
<
print(pow(0.0,0.0))</
{{out}}
<pre>1.0</pre>
=={{header|Symsyn}}==
<syntaxhighlight lang="symsyn">
(0^0) []
</syntaxhighlight>
{{out}}
<pre> 1 </pre>
Line 1,606 ⟶ 1,714:
=={{header|Tcl}}==
Interactively…
<
1
% expr 0.0**0.0
1.0</
=={{header|TI SR-56}}==
<syntaxhighlight lang="text">0 Yx 0 =</syntaxhighlight>
{{out}}
<pre> 1 </pre>
=={{header|TI-83_BASIC}}==
<syntaxhighlight lang
{{out}}
<pre>ERROR:DOMAIN</pre>
=={{header|uBasic/4tH}}==
<syntaxhighlight lang="text">Print 0^0</
{{out}}
<pre>1
Line 1,625 ⟶ 1,739:
=={{header|Ursa}}==
Cygnus/X Ursa is written in Java, and as a result returns 1.0 when raising 0 to the 0.
<
1.0</
=={{header|VBA}}==
<
x = 0
y = 0
z = 0 ^ 0
Debug.Print "z ="; z
End Sub</
<pre>z = 1</pre>
=={{header|VBScript}}==
<syntaxhighlight lang
{{Out}}
<pre>1</pre>
Line 1,644 ⟶ 1,758:
=={{header|Verilog}}==
<
initial begin
$display("0 ^ 0 = ", 0**0);
$finish ;
end
endmodule</
{{out}}
<pre>0 ^ 0 = 1</pre>
Line 1,655 ⟶ 1,769:
=={{header|Visual Basic .NET}}==
<
Sub Main()
Console.Write(0^0)
End Sub
End Module</
{{out}}
<pre>1</pre>
=={{header|V (Vlang)}}==
<
// Tectonics: v run zero-to-the-zero-power.v
module main
Line 1,674 ⟶ 1,788:
pub fn main() {
println(math.pow(0, 0))
}</
{{out}}<pre>prompt$ v run rosetta/zero-to-the-zero-power.v
1.</pre>
=={{header|Wren}}==
<syntaxhighlight lang
{{out}}
Line 1,687 ⟶ 1,801:
=={{header|XLISP}}==
<
[1] (expt 0 0)
1
[2] </
=={{header|XPL0}}==
<
{{out}}
<pre> 1.00000</pre>
=={{header|Zig}}==
<syntaxhighlight lang="zig">const std = @import("std");
pub fn main() !void {
const stdout = std.io.getStdOut().writer();
try stdout.print("0^0 = {d:.8}\n", .{std.math.pow(f32, 0, 0)});
}</syntaxhighlight>
{{out}}
<pre>0^0 = 1.00000000</pre>
=={{header|zkl}}==
<
var BN=Import("zklBigNum"); // big ints
BN(0).pow(0) //--> 1</
|