Zero to the zero power: Difference between revisions

{{task}}

 

 

'''Show the result here.'''<br>

 

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

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

 

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

0 0 ^ .

{{out}}

1

{{out}}

 

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

+1

</pre>

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

<pre>]? 0^0

1</pre>

 

=={{header|AWK}}==

# syntax: GAWK -f ZERO_TO_THE_ZERO_POWER.AWK

BEGIN {

exit(0)

}

{{out}}

<pre>

</pre>

 

1</pre>

 

=={{header|Befunge}}==

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

0 ^ 0 = 1.000000

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

</pre>

 

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

#include <cmath>

#include <complex>

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

return 0;

 

{{out}}

</pre>

 

 

 

 

=={{header|Clojure}}==

1.0

</pre>

 

=={{header|Common Lisp}}==

<pre>> (expt 0 0)

1</pre>

 

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

.....

PRINT(0^0)

.....

{{out}}

<pre> 1

</pre>

 

=={{header|Factor}}==

0 0 ^

{{out}}

<pre>--- Data stack:

NAN: 8000000000000

C{ NAN: 8000000000000 NAN: 8000000000000 }</pre>

 

=={{header|Forth}}==

 

{{out}}

<pre>1.</pre>

 

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

When complex numbers are used, we have (0.0+0.0i)^(0.0+0.0i) = ( NaN, NaN)

</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|Haskell}}==

 

{{out}}

1.0

1.0

1.0

1.0 :+ 0.0

</pre>

 

 

"Works" in both languages:

write(0^0)

 

{{out}}

 

=={{header|J}}==

 

=={{header|Java}}==

{{out}}

<pre>1.0</pre>

 

=={{header|JavaScript}}==

{{Works with|Node.js}}

In interactive mode:

 

=={{header|jq}}==

 

 

=={{header|Julia}}==

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

 

 

{{out}}

</pre>

 

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

 

{{out}}

<pre>Indeterminate</pre>

 

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

{{out}}

 

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

integer.pow(zero, zero) = 1

float.pow(0.0, 0) = 1.0</pre>

 

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

 

The result is error message.

 

=={{header|NetRexx}}==

{{out}}

=={{header|Nim}}==

 

{{out}}

 

=={{header|OCaml}}==

=={{header|Oforth}}==

 

 

{{out}}

<pre>

1

</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}}==

{{out}}

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

</pre>

 

<pre>

</pre>

 

{{out}}

<pre>1</pre>

=={{header|PicoLisp}}==

(** 0 0)

{{out}}

1

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

At offset +0000025B in procedure with entry ZHZ

</pre>

=={{header|PowerShell}}==

 

=={{header|Python}}==

from fractions import Fraction

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

except:

n2 = '<Raised exception>'

{{out}}

<pre>

int: ** -> 1; pow -> 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}}

(0.0+0.0i)^(0) = 1

(0.0+0.0i)^(0.0+0.0i) = +nan.0+nan.0i</pre>

 

=={{header|REXX}}==

<br>using PC/REXX

<br>using Personal REXX

Statement context: C:\ZERO_TO0.REX, procedure: ZERO_TO0

</pre>

 

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

<pre>1</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}}

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

</pre>

 

=={{header|Sidef}}==

say n**n

{{out}}

<pre>

1

</pre>

 

=={{header|Smalltalk}}==

 

0 raisedTo: 0

0.0 raisedTo: 0.0

{{out}}

<pre>

</pre>

 

 

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

{{out}}

<pre>

val it = 1.0 : real

</pre>

 

=={{header|Swift}}==

{{out}}

<pre>1.0</pre>

 

=={{header|Tcl}}==

Interactively…

1

% expr 0.0**0.0

 

=={{header|VBScript}}==

{{Out}}

<pre>1</pre>

 

=={{header|zkl}}==

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