Zero to the zero power: Difference between revisions

[[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|Z80 Assembly|See 6502 Assembly.}}

{{omit from|68000 Assembly|There is no built-in exponentiation so the programmer's implementation decides the outcome.}}

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

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

 

;See also:

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

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

 

=={{header|11l}}==

 

{{out}}

 

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

0 0 ^ .

{{out}}

1

 

{{omit from|ARM Assembly}}

 

=={{header|Ada}}==

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

Ada.Long_Long_Float_Text_IO;

Put (LLF ** Zero); New_Line;

end Test5;

{{out}}

<pre>Integer 0^0 = 1

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

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

{{out}}

<pre>

 

=={{header|APL}}==

 

=={{header|AppleScript}}==

 

{{output}}

 

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

=={{header|Arturo}}==

 

 

{{out}}

<pre>1

1.0</pre>

 

=={{header|AutoHotkey}}==

{{out}}

<pre>1</pre>

 

=={{header|AWK}}==

# syntax: GAWK -f ZERO_TO_THE_ZERO_POWER.AWK

BEGIN {

exit(0)

}

{{out}}

<pre>

 

=={{header|BaCon}}==

 

{{out}}

<pre>prompt$ ./zerotothezero

1</pre>

 

=={{header|BBC BASIC}}==

 

{{out}}

 

=={{header|Bc}}==

0 ^ 0

{{out}}

1

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

 

 

{{out}}

<pre>1.000000</pre>

 

=={{header|Bracmat}}==

{{out}}

<pre>1</pre>

 

=={{header|Burlesque}}==

blsq ) 0.0 0.0?^

1.0

blsq ) 0 0?^

1

 

=={{header|C}}==

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

0^0 is given as 1.

#include <math.h>

#include <complex.h>

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

return 0;

 

{{out}}

 

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

 

namespace ZeroToTheZeroeth

}

}

 

{{out}}

 

=={{header|C++}}==

#include <cmath>

#include <complex>

std::pow(std::complex<double>(0),std::complex<double>(0)) << std::endl;

return 0;

 

{{out}}

 

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

// default behavior is incorrect:

set (x,y) = 0

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

 

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

1.0

</pre>

 

=={{header|COBOL}}==

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

data division.

compute n = 0**0.

display n upon console.

{{out}}

<pre>1</pre>

=={{header|ColdFusion}}==

=== Classic tag based CFML ===

<cfset zeroPowerTag = 0^0>

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

{{Output}}

<pre>

 

=== Script Based CFML ===

zeroPower = 0^0;

writeOutput( zeroPower );

{{Output}}

<pre>

 

=={{header|Crystal}}==

puts "Negative Int32: #{-0_i32**-0_i32}"

puts "Float32: #{0_f32**0_f32}"

 

{{Output}}

 

=={{header|D}}==

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

 

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

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

{{out}}

<pre>Int: 1

BigInt: 1

Complex: 1+0i</pre>

 

=={{header|Dc}}==

{{Output}}

<pre>

=={{header|EasyLang}}==

 

 

=={{header|EchoLisp}}==

;; trying the 16 combinations

;; all return the integer 1

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

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

 

=={{header|Eiffel}}==

{{out}}

<pre>1</pre>

 

=={{header|Elena}}==

public program()

{

{{out}}

<pre>

=={{header|Elixir}}==

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

:math.pow(0,0)

 

{{out}}

1.0

=={{header|Emacs Lisp}}==

{{out}}

1

 

=={{header|ERRE}}==

.....

PRINT(0^0)

.....

{{out}}

<pre> 1

 

=={{header|Factor}}==

0 0 ^

{{out}}

<pre>--- Data stack:

=={{header|Falcon}}==

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

/* created by Aykayayciti Earl Lamont Montgomery

April 9th, 2018 */

> "z=", z

 

{{out}}

<pre>

 

=={{header|Fermat}}==

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

 

=={{header|Forth}}==

 

{{out}}

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

 

 

{{Output}}

=={{header|Fortran}}==

 

program zero

double precision :: i, j

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

end program

{{out}}

<pre>

 

=={{header|FreeBASIC}}==

 

Print "0 ^ 0 ="; 0 ^ 0

 

{{out}}

 

=={{header|Frink}}==

 

{{out}}

 

=={{header|FutureBasic}}==

 

print 0^0

Output:

<pre>

=={{header|Gambas}}==

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

 

Print 0 ^ 0

 

Output:

<pre>

1

</pre>

 

=={{header|Go}}==

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

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

 

import (

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

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

{{out}}

<pre>

complex: (1+0i)

</pre>

 

=={{header|Groovy}}==

{{trans|Java}}

Test:

{{out}}

<pre>1</pre>

 

=={{header|GW-BASIC}}==

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

 

=={{header|Haskell}}==

 

{{out}}

1.0

1.0

1.0

1.0 :+ 0.0

 

=={{header|HolyC}}==

 

{{out}}

 

"Works" in both languages:

write(0^0)

 

{{out}}

 

=={{header|J}}==

 

=={{header|Java}}==

{{out}}

<pre>1.0</pre>

{{Works with|Node.js}}

In interactive mode:

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

 

=={{header|jq}}==

 

=={{header|Jsish}}==

{{out}}

<pre>1</pre>

=={{header|Julia}}==

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

 

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

r = zb ^ ze

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

 

{{out}}

 

=={{header|K}}==

0^0

1.0

 

=={{header|Klingphix}}==

dup not (

[ drop sign dup 0 equal [ drop 1 ] if ]

0 0 mypower print nl

 

{{out}}

<pre>1

 

=={{header|Kotlin}}==

 

 

{{out}}

<pre>

</pre>

 

=={{header|Lambdatalk}}==

{pow 0 0}

-> 1

{exp 0 0}

-> 1

 

=={{header|Liberty BASIC}}==

'********

print 0^0

'********

{{out}}

<pre>1</pre>

=={{header|Locomotive Basic}}==

 

{{out}}

<pre> 1</pre>

=={{header|Lua}}==

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

{{out}}

<pre>1</pre>

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

M2000 use ** and ^ for power.

Module Checkit {

x=0

}

Checkit

 

=={{header|Maple}}==

{{out}}

<pre>1</pre>

 

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

{{out}}

<pre>Float(undefined)</pre>

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

{{out}}

<pre>Indeterminate</pre>

 

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

{{out}}

<pre>1

1</pre>

=={{header|Maxima}}==

{{out}}<pre> 0

expt: undefined: 0</pre>

 

=={{header|Mercury}}==

:- interface.

 

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

 

{{out}}

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

 

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

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

 

=={{header|min}}==

{{works with|min|0.19.3}}

{{out}}

<pre>

 

=={{header|MiniScript}}==

{{out}}

<pre>

 

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

 

The result is error message.

 

=={{header|Nanoquery}}==

{{out}}

<pre>1</pre>

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

 

Zero to the zeroth power, in Neko

*/

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

 

 

{{out}}

 

=={{header|NetRexx}}==

{{out}}

<pre>0**0=1</pre>

 

=={{header|NewLISP}}==

{{out}}

<pre>1</pre>

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

 

+--+--+--+

| 1|1.| 1|

+--+--+--+

| 1|1.| 1|

 

=={{header|Nim}}==

 

echo pow(0.0, 0.0) # Floating point exponentiation.

{{out}}

<pre>1.0

=={{header|Oforth}}==

 

 

{{out}}

 

=={{header|Ol}}==

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

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

{{out}}

<pre>

 

=={{header|ooRexx}}==

* 21.04.2014 Walter Pachl

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

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

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

{{out}}

<pre>

0**0 -> 1

</pre>

 

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

0.^0

{{out}}

<pre>%1 = 1

=={{header|Pascal}}==

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

uses

math;

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

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

;output:

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

 

=={{header|Perl}}==

 

use Math::Complex;

 

{{out}}

<pre>

=={{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>

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

 

=={{header|Phixmonti}}==

dup not if

. sign dup 0 == if . 1 endif

enddef

 

{{out}}

<pre>1</pre>

 

=={{header|PHP}}==

echo pow(0,0);

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

{{out}}

<pre>

 

=={{header|PicoLisp}}==

(** 0 0)

{{out}}

1

 

=={{header|Pike}}==

{{Out}}

<pre>

 

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

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

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

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

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

{{out}}

<pre>

 

=={{header|Plain English}}==

Start up.

Put 0 into a number.

Write the string to the console.

Wait for the escape key.

{{out}}

<pre>

=={{header|PowerShell}}==

 

 

Output :

 

=={{header|PureBasic}}==

If OpenConsole()

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

CloseConsole()

EndIf

 

{{out}}

 

=={{header|Pyret}}==

{{out}}

1

=={{header|Python}}==

===Python3===

from fractions import Fraction

from itertools import product

except:

ans = '<Exception raised>'

{{out}}

<pre> 0 ** 0 = 1

 

===Python2===

from fractions import Fraction

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

except:

n2 = '<Raised exception>'

{{out}}

<pre>

 

=={{header|QB64}}==

{{out}}

<pre>1</pre>

Alternatively:

l& = 0 'Long integer

s! = 0.0 'Single precision floating point

Print b` ^ b`

Print bb%% ^ bb%%

{{out}}

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

As a dialogue in the Quackery shell.

 

...

 

Stack: 1

 

=={{header|R}}==

{{out}}

<pre>1</pre>

=={{header|Racket}}==

 

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

(define zeros (list

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

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

 

{{out}}

 

{{works with|Rakudo|2018.03}}

say '-------- -------- -------- --------';

 

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

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

 

{{out}}

=={{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

{{out}}

<pre>

 

=={{header|Relation}}==

echo pow(0,0)

// 1

 

=={{header|REXX}}==

<br>using PC/REXX

<br>using Personal REXX

 

=={{header|Ring}}==

x = 0

y = 0

z = pow(x,y)

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

 

=={{header|Ruby}}==

 

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

{{out}}

<pre>

Float: ** -> 1.0

Complex: ** -> 1+0i

Rational: ** -> 1/1

</pre>

 

=={{header|Rust}}==

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

 

{{out}}

 

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

{{out}}

<pre>1.0</pre>

 

=={{header|Scala}}==

 

=={{header|Scheme}}==

(display (expt 0.0 0.0)) (newline)

{{out}}

<pre>1

 

=={{header|Seed7}}==

include "float.s7i";

include "complex.s7i";

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

end func;

 

{{out}}

 

=={{header|SenseTalk}}==

set b to 0

 

put a to the power of b

 

=={{header|Sidef}}==

say n**n

{{out}}

<pre>

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

 

 

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

{{out}}

<pre>1</pre>

=={{header|Smalltalk}}==

 

0 raisedTo: 0

0.0 raisedTo: 0.0

{{out}}

<pre>

 

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

 

{{out}}

</pre>

 

 

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

{{out}}

<pre>

 

=={{header|Stata}}==

 

=={{header|Swift}}==

{{out}}

<pre>1.0</pre>

 

=={{header|Symsyn}}==

(0^0) []

{{out}}

<pre> 1 </pre>

=={{header|Tcl}}==

Interactively…

1

% expr 0.0**0.0

 

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

{{out}}

<pre>ERROR:DOMAIN</pre>

 

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

{{out}}

<pre>1

=={{header|Ursa}}==

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

 

=={{header|VBA}}==

x = 0

y = 0

z = 0 ^ 0

Debug.Print "z ="; z

<pre>z = 1</pre>

 

=={{header|VBScript}}==

{{Out}}

<pre>1</pre>

 

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

Sub Main()

Console.Write(0^0)

End Sub

 

{{out}}

<pre>1</pre>

 

=={{header|Wren}}==

 

{{out}}

 

=={{header|XLISP}}==

[1] (expt 0 0)

 

1

 

=={{header|XPL0}}==

{{out}}

<pre> 1.00000</pre>

 

=={{header|zkl}}==

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