Zero to the zero power: Difference between revisions

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

{{out}}

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

0 0 ^ .

{{out}}

1

=={{header|Action!}}==

{{libheader|Action! Tool Kit}}

PROC Main()

PrintR(z) Print("=")

PrintRE(res)

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Zero_to_the_zero_power.png Screenshot from Atari 8-bit computer]

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

=={{header|Asymptote}}==

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

=={{header|BASIC}}==

==={{header|BASIC256}}===

==={{header|QBasic}}===

{{works with|QBasic|1.1}}

{{works with|QuickBasic|4.5}}

==={{header|True BASIC}}===

{{works with|QBasic}}

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

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

{{out}}

<pre>1</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 in my case could just be an implementation detail.

zz_int: int := 0 ** 0

zz_real: real := 0.0 ** 0.0

stream$putl(po, "integer 0**0: " || int$unparse(zz_int))

stream$putl(po, "real 0**0: " || f_form(zz_real, 1, 1))

{{out}}

<pre>integer 0**0: 1

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

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

ELENA 4.x

public program()

{

console.printLine("0^0 is ",0.power:0)

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

=={{header|GAP}}==

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

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>

{{trans|Java}}

Test:

{{out}}

<pre>1</pre>

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

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

=={{header|Haskell}}==

main = do

print $ 0 ** 0

print $ (0 :+ 0) ^ 0

{{out}}

<pre>

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

a definition that makes a special case of 0^0 should be considered, e.g.

along the following lines:

This definition will however be unsatisfactory for many purposes

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

fun main(args: Array<String>) {

println("0 ^ 0 = ${Math.pow(0.0, 0.0)}")

{{out}}

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

=={{header|Openscad}}==

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

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

[0, 0.0, Complex(0), Rational(0), BigDecimal("0")].each do |n|

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

{{out}}

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

=={{header|SNOBOL4}}==

=={{header|SQL}}==

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>