Zero to the zero power
You are encouraged to solve this task according to the task description, using any language you may know.
Some programming languages are not exactly consistent (with other 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 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
8th
<lang forth> 0 0 ^ . </lang>
- Output:
1
AutoHotkey
<lang AutoHotkey>MsgBox % 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>
Applesoft BASIC
]? 0^0 1
AWK
<lang AWK>
- syntax: GAWK -f ZERO_TO_THE_ZERO_POWER.AWK
BEGIN {
print(0 ^ 0) exit(0)
} </lang>
- Output:
1
Bc
0 ^ 0 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>
BBC BASIC
<lang bbcbasic> PRINT 0^0</lang>
- Output:
1
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 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)
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
Clojure
user=> (use 'clojure.math.numeric-tower) user=> (expt 0 0) 1 ; alternative java-interop route: user=> (Math/pow 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
Common Lisp
> (expt 0 0) 1
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
0 0^p
- Output:
1
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
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
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 }
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
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)
FutureBasic
<lang futurebasic> include "ConsoleWindow"
print 0^0 </lang> Output:
1
Groovy
Test: <lang groovy>println 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
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
In interactive mode: <lang javascript>> Math.pow(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.
Julia
Try all combinations of complex, float, rational, integer and boolean. <lang Julia> zs = Any[zero(Complex),
zero(FloatingPoint), zero(Rational), zero(Integer), zero(Bool)]
for i in zs, j in zs
println(i, "^", j, " = ", i^j, " (", typeof(i^j), ")")
end
</lang>
Note that if zs
is not annotated as being of type Any
all of the zeros will be promoted to complex when zs
is constructed.
- Output:
0 + 0im^0 + 0im = 1.0 + 0.0im (Complex{Float64}) 0 + 0im^0.0 = 1.0 + 0.0im (Complex{Float64}) 0 + 0im^0//1 = 1.0 + 0.0im (Complex{Float64}) 0 + 0im^0 = 1 + 0im (Complex{Int64}) 0 + 0im^false = 1 + 0im (Complex{Int64}) 0.0^0 + 0im = 1.0 + 0.0im (Complex{Float64}) 0.0^0.0 = 1.0 (Float64) 0.0^0//1 = 1.0 (Float64) 0.0^0 = 1.0 (Float64) 0.0^false = 1.0 (Float64) 0//1^0 + 0im = 1.0 + 0.0im (Complex{Float64}) 0//1^0.0 = 1.0 (Float64) 0//1^0//1 = 1.0 (Float64) 0//1^0 = 1//1 (Rational{Int64}) 0//1^false = 1//1 (Rational{Int64}) 0^0 + 0im = 1.0 + 0.0im (Complex{Float64}) 0^0.0 = 1.0 (Float64) 0^0//1 = 1.0 (Float64) 0^0 = 1 (Int64) 0^false = 1 (Int64) false^0 + 0im = 1.0 + 0.0im (Complex{Float64}) false^0.0 = 1.0 (Float64) false^0//1 = 1.0 (Float64) false^0 = true (Bool) false^false = true (Bool)
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
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
<lang Mathematica>0^0</lang>
- Output:
Indeterminate
MATLAB / Octave
<lang Matlab>0^0</lang>
- Output:
1
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
МК-61/52
<lang>Сx ^ x^y С/П</lang>
The result is error message.
NetRexx
<lang netrexx>x=0 Say '0**0='||x**x</lang>
- Output:
0**0=1
NewLISP
<lang newlisp>(pow 0 0)</lang>
- Output:
1
Nim
<lang nim>import math
echo pow(0, 0)</lang>
- Output:
1.0
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
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
<lang parigp>0^0</lang>
- Output:
%1 = 1
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
Perl 6
<lang perl 6>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 0+0i 0+0i
Phix
Fair enough, I have no strong opinions on this matter, so I have just removed the test/error that was present in previous versions. Should you for any reason want to change it back, just edit builtins/VM/pPower.e, search for the two mods dated 3/11/15 (32 and 64 bit, both are two lines, test eax/rax; jz :e102cr0tple0), save and rebuild (run "p -c p"), which should take less than 10 seconds. <lang Phix>?power(0,0)</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
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
PowerShell
<lang PowerShell>[math]::pow(0,0)</lang>
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
Python
<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
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
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
Sidef
<lang ruby>[0, Complex(0, 0)].each {|n|
say n**n; say n.pow(n); say pow(n, n); say Math.pow(n, n);
}</lang>
- Output:
1 1 1 1 1 1 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>
Smalltalk
<lang smalltalk> 0 raisedTo: 0 0.0 raisedTo: 0.0 </lang>
- Output:
1 1.0
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
Swift
<lang swift>import Darwin print(pow(0.0,0.0))</lang>
- Output:
1.0
Tcl
Interactively… <lang tcl>% expr 0**0 1 % expr 0.0**0.0 1.0</lang>
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>
VBScript
<lang vb>WScript.Echo 0 ^ 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>
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
- 8th
- AutoHotkey
- Ada
- ALGOL 68
- APL
- Applesoft BASIC
- AWK
- Bc
- Befunge
- Bracmat
- Burlesque
- BBC BASIC
- C
- C++
- C sharp
- Clojure
- COBOL
- Common Lisp
- D
- Dc
- EchoLisp
- Eiffel
- Elixir
- ERRE
- F Sharp
- Factor
- Forth
- Fortran
- FreeBASIC
- Go
- FutureBasic
- Groovy
- Haskell
- Icon
- Unicon
- J
- Java
- JavaScript
- Jq
- Julia
- Lua
- Maple
- Mathematica
- MATLAB
- Octave
- Mercury
- МК-61/52
- NetRexx
- NewLISP
- Nim
- OCaml
- Oforth
- OoRexx
- PARI/GP
- Pascal
- Math
- Perl
- Perl 6
- Phix
- PHP
- PicoLisp
- PL/I
- PowerShell
- PureBasic
- Python
- R
- Racket
- REXX
- Ring
- Ruby
- Rust
- S-lang
- Scala
- Scheme
- Seed7
- Sidef
- Smalltalk
- SQL
- Standard ML
- Swift
- Tcl
- UBasic/4tH
- Ursa
- VBScript
- XLISP
- Zkl