Exponentiation order
You are encouraged to solve this task according to the task description, using any language you may know.
This task will demonstrate the order of exponentiation (xy) when there are multiple exponents.
(Many programming languages, especially those with extended─precision integer arithmetic, usually support one of **, ^, ↑ or some such for exponentiation.)
- Task requirements
Show the result of a language's evaluation of multiple exponentiation (either as an integer or floating point).
If your language's exponentiation operator is not one of the usual ones, please comment on how to recognize it.
Using whatever operator or syntax your language supports (if any), show the results in three lines (with identification):
- 5**3**2
- (5**3)**2
- 5**(3**2)
If there are other methods (or formats) of multiple exponentiations, show them as well.
- See also
- MathWorld entry: exponentiation
- Related tasks
- exponentiation operator
- arbitrary-precision integers (included)
- Exponentiation with infix operators in (or operating on) the base
11l
<lang 11l>print(5 ^ 3 ^ 2) print((5 ^ 3) ^ 2) print(5 ^ (3 ^ 2))</lang>
- Output:
1.95313e+06 15625 1.95313e+06
Ada
5**3**2 is not a valid Ada expression. Parenthesis are mandatory.
<lang Ada>with Ada.Text_IO;
procedure Exponentation_Order is
use Ada.Text_IO;
begin
-- Put_Line ("5**3**2 : " & Natural'(5**3**2)'Image);
Put_Line ("(5**3)**2 : " & Natural'((5**3)**2)'Image);
Put_Line ("5**(3**2) : " & Natural'(5**(3**2))'Image);
end Exponentation_Order;</lang>
- Output:
(5**3)**2 : 15625 5**(3**2) : 1953125
ALGOL 68
Algol 68 provides various alternative symbols for the exponentiation operator generally, "**", "^" and "UP" can be used. <lang algol68>print( ( "5**3**2: ", 5**3**2, newline ) ); print( ( "(5**3)**2: ", (5**3)**2, newline ) ); print( ( "5**(3**2): ", 5**(3**2), newline ) )</lang>
- Output:
5**3**2: +15625 (5**3)**2: +15625 5**(3**2): +1953125
ALGOL W
The Algol W exponentiation operator always produces a real result and requires an integer right operand, hence the round functions in the following. <lang algolw>begin
write( "5**3**2: ", round( 5 ** 3 ** 2 ) ); write( "(5**3)**2: ", round( ( 5 ** 3 ) ** 2 ) ); write( "5**(3**2): ", round( 5 ** round( 3 ** 2 ) ) )
end.</lang>
- Output:
5**3**2: 15625 (5**3)**2: 15625 5**(3**2): 1953125
APL
APL has no order of precedence other than right-to-left operation. * is the APL exponentiation operator.
5*3*2
1953125
(5*3)*2
15625
5*(3*2)
1953125
AppleScript
AppleScript's compiler inserts its own parentheses with 5 ^ 3 ^ 2.
<lang applescript>set r1 to 5 ^ 3 ^ 2 -- Changes to 5 ^ (3 ^ 2) when compiled. set r2 to (5 ^ 3) ^ 2 set r3 to 5 ^ (3 ^ 2)
return "5 ^ 3 ^ 2 = " & r1 & " (5 ^ 3) ^ 2 = " & r2 & " 5 ^ (3 ^ 2) = " & r3</lang>
- Output:
"5 ^ 3 ^ 2 = 1.953125E+6 (5 ^ 3) ^ 2 = 1.5625E+4 5 ^ (3 ^ 2) = 1.953125E+6"
AWK
<lang AWK>
- syntax: GAWK -f EXPONENTIATION_ORDER.AWK
BEGIN {
printf("5^3^2 = %d\n",5^3^2)
printf("(5^3)^2 = %d\n",(5^3)^2)
printf("5^(3^2) = %d\n",5^(3^2))
exit(0)
} </lang>
output:
5^3^2 = 1953125 (5^3)^2 = 15625 5^(3^2) = 1953125
BASIC
Sinclair ZX81 BASIC
<lang basic>10 PRINT "5**3**2 = ";5**3**2 20 PRINT "(5**3)**2 = ";(5**3)**2 30 PRINT "5**(3**2) = ";5**(3**2)</lang>
- Output:
5**3**2 = 15625 (5**3)**2 = 15625 5**(3**2) = 1953125
BBC BASIC
<lang bbcbasic>PRINT "5^3^2 = "; 5^3^2 PRINT "(5^3)^2 = "; (5^3)^2 PRINT "5^(3^2) = "; 5^(3^2)</lang>
- Output:
5^3^2 = 15625 (5^3)^2 = 15625 5^(3^2) = 1953125
IS-BASIC
<lang IS-BASIC>100 PRINT "5^3^2 =";5^3^2 110 PRINT "(5^3)^2 =";(5^3)^2 120 PRINT "5^(3^2) =";5^(3^2)</lang>
- Output:
5^3^2 = 15625 (5^3)^2 = 15625 5^(3^2) = 1953125
Bracmat
<lang Bracmat>put$str$("5^3^2: " 5^3^2 "\n(5^3)^2: " (5^3)^2 "\n5^(3^2): " 5^(3^2) \n) </lang>
- Output:
5^3^2: 1953125 (5^3)^2: 15625 5^(3^2): 1953125
C
C does not have an exponentiation operator. The caret operator '^' performs xor bitwise operation in C. The function pow in the standard C Math library takes two arguments.
<lang C>#include<stdio.h>
- include<math.h>
int main() {
printf("(5 ^ 3) ^ 2 = %.0f",pow(pow(5,3),2));
printf("\n5 ^ (3 ^ 2) = %.0f",pow(5,pow(3,2)));
return 0;
}</lang>
- Output:
(5 ^ 3) ^ 2 = 15625 5 ^ (3 ^ 2) = 1953125
C++
<lang cpp>#include <iostream>
- include <cmath>
int main() {
std::cout << "(5 ^ 3) ^ 2 = " << (uint) pow(pow(5,3), 2) << std::endl; std::cout << "5 ^ (3 ^ 2) = "<< (uint) pow(5, (pow(3, 2)));
return EXIT_SUCCESS;
}</lang>
With permissive flag: <lang cpp>#include <iostream>
- include <cmath>
enum my_int {}; inline my_int operator^(my_int a, my_int b) { return static_cast<my_int>(pow(a,b)); }
int main() {
my_int x = 5, y = 3, z = 2; std::cout << "(5 ^ 3) ^ 2 = " << ((x^y)^z) << std::endl; std::cout << "5 ^ (3 ^ 2) = "<< (x^(y^z));
return EXIT_SUCCESS;
}</lang>
- Output:
(5 ^ 3) ^ 2 = 15625 5 ^ (3 ^ 2) = 1953125
C#
<lang csharp>using System;
namespace exponents {
class Program
{
static void Main(string[] args)
{
/*
* Like C, C# does not have an exponent operator.
* Exponentiation is done via Math.Pow, which
* only takes two arguments
*/
Console.WriteLine(Math.Pow(Math.Pow(5, 3), 2));
Console.WriteLine(Math.Pow(5, Math.Pow(3, 2)));
Console.Read();
}
}
} </lang>
- Output:
15625 1953125
Clojure
Clojure uses prefix notation and expt only takes 2 arguments for exponentiation, so "5**3**2" isn't represented.
<lang clojure>(use 'clojure.math.numeric-tower)
- (5**3)**2
(expt (expt 5 3) 2) ; => 15625
- 5**(3**2)
(expt 5 (expt 3 2)) ; => 1953125
- (5**3)**2 alternative
- use reduce
(reduce expt [5 3 2]) ; => 15625
- 5**(3**2) alternative
- evaluating right-to-left with reduce requires a small modification
(defn rreduce [f coll] (reduce #(f %2 %) (reverse coll))) (rreduce expt [5 3 2]) ; => 1953125</lang>
Common Lisp
Because Common Lisp uses prefix notation and expt accepts only two arguments, it doesn't have an expression for 5**3**2. Just showing expressions for the latter two.
<lang lisp>(expt (expt 5 3) 2)
(expt 5 (expt 3 2))</lang>
- Output:
15625 1953125
D
<lang d>void main() {
import std.stdio, std.math, std.algorithm;
writefln("5 ^^ 3 ^^ 2 = %7d", 5 ^^ 3 ^^ 2);
writefln("(5 ^^ 3) ^^ 2 = %7d", (5 ^^ 3) ^^ 2);
writefln("5 ^^ (3 ^^ 2) = %7d", 5 ^^ (3 ^^ 2));
writefln("[5, 3, 2].reduce!pow = %7d", [5, 3, 2].reduce!pow);
}</lang>
- Output:
5 ^^ 3 ^^ 2 = 1953125 (5 ^^ 3) ^^ 2 = 15625 5 ^^ (3 ^^ 2) = 1953125 [5, 3, 2].reduce!pow = 15625
EchoLisp
<lang scheme>
- the standard and secure way is to use the (expt a b) function
(expt 5 (expt 3 2)) ;; 5 ** ( 3 ** 2)
→ 1953125
(expt (expt 5 3) 2) ;; (5 ** 3) ** 2
→ 15625
- infix EchoLisp may use the ** operator, which right associates
(lib 'match) (load 'infix.glisp)
(5 ** 3 ** 2)
→ 1953125
((5 ** 3) ** 2)
→ 15625
(5 ** (3 ** 2))
→ 1953125
</lang>
Factor
Factor is a stack language where expressions take the form of reverse Polish notation, so there is no ambiguity here. It is up to you, the programmer, to perform operations in the order you intend. <lang factor>USING: formatting math.functions ;
5 3 2 ^ ^ "5 3 2 ^ ^ %d\n" printf
5 3 ^ 2 ^ "5 3 ^ 2 ^ %d\n" printf</lang>
- Output:
5 3 2 ^ ^ 1953125 5 3 ^ 2 ^ 15625
Factor also has syntax for infix arithmetic via the the infix vocabulary.
<lang factor>USING: formatting infix ;
[infix 5**3**2 infix] "5**3**2 = %d\n" printf
[infix (5**3)**2 infix] "(5**3)**2 = %d\n" printf
[infix 5**(3**2) infix] "5**(3**2) = %d\n" printf</lang>
- Output:
5**3**2 = 15625 (5**3)**2 = 15625 5**(3**2) = 1953125
Fortran
<lang Fortran>write(*, "(a, i0)") "5**3**2 = ", 5**3**2 write(*, "(a, i0)") "(5**3)**2 = ", (5**3)**2 write(*, "(a, i0)") "5**(3**2) = ", 5**(3**2)</lang>
- Output:
5**3**2 = 1953125 (5**3)**2 = 15625 5**(3**2) = 1953125
FreeBASIC
<lang freebasic>' FB 1.05.0
' The exponentation operator in FB is ^ rather than **. ' In the absence of parenthesis this operator is ' left-associative. So the first example ' will have the same value as the second example.
Print "5^3^2 =>"; 5^3^2 Print "(5^3)^2 =>"; (5^3)^2 Print "5^(3^2) =>"; 5^(3^2) Sleep</lang>
- Output:
5^3^2 => 15625 (5^3)^2 => 15625 5^(3^2) => 1953125
Frink
Frink correctly follows standard mathematical notation that exponent towers are performed from "top to bottom" or "right to left."
<lang Frink>println["5^3^2 = " + 5^3^2] println["(5^3)^2 = " + (5^3)^2] println["5^(3^2) = " + 5^(3^2)] </lang>
- Output:
5^3^2 = 1953125 (5^3)^2 = 15625 5^(3^2) = 1953125
Go
<lang Go>package main
import "fmt" import "math"
func main() {
var a, b, c float64
a = math.Pow(5, math.Pow(3, 2))
b = math.Pow(math.Pow(5, 3), 2)
c = math.Pow(5, math.Pow(3, 2))
fmt.Printf("5^3^2 = %.0f\n", a)
fmt.Printf("(5^3)^2 = %.0f\n", b)
fmt.Printf("5^(3^2) = %.0f\n", c)
}</lang>
- Output:
5^3^2 = 1953125 (5^3)^2 = 15625 5^(3^2) = 1953125
Groovy
Solution: <lang groovy>println(" 5 ** 3 ** 2 == " + 5**3**2) println("(5 ** 3)** 2 == " + (5**3)**2) println(" 5 **(3 ** 2)== " + 5**(3**2))</lang>
Output:
5 ** 3 ** 2 == 15625 (5 ** 3)** 2 == 15625 5 **(3 ** 2)== 1953125
Haskell
Haskell has three infix exponentiation operators dealing with different domains:
λ> :i (^) (^) :: (Num a, Integral b) => a -> b -> a -- Defined in ‘GHC.Real’ infixr 8 ^ λ> :i (**) class Fractional a => Floating a where ... (**) :: a -> a -> a ... -- Defined in ‘GHC.Float’ infixr 8 ** λ> :i (^^) (^^) :: (Fractional a, Integral b) => a -> b -> a -- Defined in ‘GHC.Real’ infixr 8 ^^
All of them are right-associative.
λ> 5^3^2 1953125 λ> (5^3)^2 15625 λ> 5^(3^2) 1953125 λ> 5**3**2 == 5**(3**2) True
However natural chaining of (^^) operator is impossible:
5^^3^^2 = 5^^(3^^2)
but (3^^2) is not Integral any longer, so evaluation leads to the type error. Left-assiciative chain is Ok:
λ> (5^^3)^^2 15625.0 λ> ((5^^3)^^2)^^4 5.9604644775390624e16
Io
Io> 5**3**2
==> 15625
Io> (5**3)**2
==> 15625
Io> 5**(3**2)
==> 1953125
Io> 5 pow(3) pow(2)
==> 15625
Io> 5 **(3) **(2)
==> 15625
Io> Number getSlot("**") == Number getSlot("pow")
==> true
Io>
Operators in Io are implemented as methods. Here the ** method is the same as the pow method. Syntax sugar converts "normal" mathematical expressions to messages.
J
J uses the same evaluation order for exponentiation as it does for assignment. That is to say: the bottom up view is right-to-left and the top-down view is left-to-right.
<lang J> 5^3^2 1.95312e6
(5^3)^2
15625
5^(3^2)
1.95312e6</lang>
Java
Java has no exponentiation operator, but uses the static method java.lang.Math.pow(double a, double b). There are no associativity issues.
jq
Requires: jq 1.5 or higher
jq's built-in for exponentiation is an arity-two function and thus no ambiguity arising from infix-notation is possible. Here's an example:
<lang jq>jq -n 'pow(pow(5;3);2)' 15625</lang>
For chaining, one could use `reduce`:
<lang jq> def pow: reduce .[1:] as $i (.[0]; pow(.;$i))
[5,3,2] | pow</lang>
Result: 15625
Julia
<lang julia>@show 5 ^ 3 ^ 2 # default: power operator is read right-to-left @show (5 ^ 3) ^ 2 @show 5 ^ (3 ^ 2) @show reduce(^, [5, 3, 2]) @show foldl(^, [5, 3, 2]) # guarantees left associativity @show foldr(^, [5, 3, 2]) # guarantees right associativity</lang>
- Output:
5 ^ (3 ^ 2) = 1953125 (5 ^ 3) ^ 2 = 15625 5 ^ (3 ^ 2) = 1953125 reduce(^, [5, 3, 2]) = 15625 foldl(^, [5, 3, 2]) = 15625 foldr(^, [5, 3, 2]) = 1953125
Kotlin
Kotlin does not have a dedicated exponentiation operator and we would normally use Java's Math.pow function instead. However, it's possible to define an infix function which would look like an operator and here we do so for integer base and exponent. For simplicity we disallow negative exponents altogether and consider 0 ** 0 == 1. Associativity would, of course, be the same as for a normal function call. <lang scala>// version 1.0.5-2
infix fun Int.ipow(exp: Int): Int = when {
exp < 0 -> throw IllegalArgumentException("negative exponents not allowed")
exp == 0 -> 1
else -> {
var ans = 1
var base = this
var e = exp
while(e != 0) {
if (e and 1 == 1) ans *= base
e = e shr 1
base *= base
}
ans
}
}
fun main(args: Array<String>) {
println("5**3**2 = ${5 ipow 3 ipow 2}")
println("(5**3)**2 = ${(5 ipow 3) ipow 2}")
println("5**(3**2) = ${5 ipow (3 ipow 2)}")
}</lang>
- Output:
5**3**2 = 15625 (5**3)**2 = 15625 5**(3**2) = 1953125
Lambdatalk
Because lambdatalk uses prefix notation and {pow a b} accepts only two arguments, it doesn't have an expression for 5**3**2. Just showing expressions for the latter two.
<lang scheme> '{pow {pow 5 3} 2} -> {pow {pow 5 3} 2} '{pow 5 {pow 3 2}} -> {pow 5 {pow 3 2}} </lang>
Latitude
<lang latitude>5 ^ 3 ^ 2. ;; 1953125 (5 ^ 3) ^ 2. ;; 15625 5 ^ (3 ^ 2). ;; 1953125</lang>
Lua
<lang Lua>print("5^3^2 = " .. 5^3^2) print("(5^3)^2 = " .. (5^3)^2) print("5^(3^2) = " .. 5^(3^2))</lang>
- Output:
5^3^2 = 1953125 (5^3)^2 = 15625 5^(3^2) = 1953125
Lua also has math.pow(a, b), which is identical to pow(a, b) in C. Since function arguments are contained in brackets anyway, the associativity of nested uses of math.pow will be obvious.
Maple
<lang Maple>5^3^2; (5^3)^2; 5^(3^2);</lang>
- Output:
Error, ambiguous use of `^`, please use parentheses 15625 1953125
Mathematica / Wolfram Language
<lang Mathematica>a = "5^3^2"; Print[a <> " = " <> ToString[ToExpression[a]]] b = "(5^3)^2"; Print[b <> " = " <> ToString[ToExpression[b]]] c = "5^(3^2)"; Print[c <> " = " <> ToString[ToExpression[c]]]</lang>
- Output:
5^3^2 = 1953125 (5^3)^2 = 15625 5^(3^2) = 1953125
min
As with other postfix languages, there is no ambiguity because all operators have the same precedence.
<lang min>5 3 2 pow pow "5 3 2 ^ ^ " print! puts!
5 3 pow 2 pow "5 3 ^ 2 ^ " print! puts!</lang>
- Output:
5 3 2 ^ ^ 1953125.0 5 3 ^ 2 ^ 15625.0
Nanoquery
Nanoquery uses the '^' operator, which performs exponentiation in order like multiplication. Parenthesis are often needed to perform operations like 5^3^2 correctly. <lang Nanoquery>% println 5^3^2 15625 % println (5^3)^2 15625 % println 5^(3^2) 1953125</lang>
Nim
<Lang Nim>import math, sequtils
echo "5^3^2 = ", 5^3^2 echo "(5^3)^2 = ", (5^3)^2 echo "5^(3^2) = ", 5^(3^2) echo "foldl([5, 3, 2], a^b) = ", foldl([5, 3, 2], a^b) echo "foldr([5, 3, 2], a^b) = ", foldr([5, 3, 2], a^b)</lang>
- Output:
5^3^2 = 1953125 (5^3)^2 = 15625 5^(3^2) = 1953125 foldl([5, 3, 2], a^b) = 15625 foldr([5, 3, 2], a^b) = 1953125
OCaml
OCaml language has '**' as an exponentiation symbol for floating point integers <OCaml code>
- 5. ** 3. ** 2. ;;
- 5. **( 3. ** 2.) ;;
- (5. ** 3. ) **2. ;;
- Output:
- : float = 1953125. - : float = 1953125. - : float = 15625.
PARI/GP
Exponentiation is right-associative in GP. <lang parigp>f(s)=print(s" = "eval(s)); apply(f, ["5^3^2", "(5^3)^2", "5^(3^2)"]);</lang>
- Output:
5^3^2 = 1953125 (5^3)^2 = 15625 5^(3^2) = 1953125
Perl
<lang perl>say "$_ = " . eval($_) for qw/5**3**2 (5**3)**2 5**(3**2)/;</lang>
- Output:
5**3**2 = 1953125 (5**3)**2 = 15625 5**(3**2) = 1953125
Phix
Phix has a power function rather than an infix power operator, hence there is no possible confusion.
?power(power(5,3),2)
?power(5,power(3,2))
- Output:
15625 1953125
PicoLisp
The PicoLisp '**' exponentiation function takes 2 arguments <lang PicoLisp>: (** (** 5 3) 2) -> 15625
- (** 5 (** 3 2))
-> 1953125</lang>
Python
<lang python>>>> 5**3**2 1953125 >>> (5**3)**2 15625 >>> 5**(3**2) 1953125 >>> # The following is not normally done >>> try: from functools import reduce # Py3K except: pass
>>> reduce(pow, (5, 3, 2)) 15625 >>> </lang>
Quackery
Quackery uses Reverse Polish Notation, so there is no ambiguity and no need for parenthesising.
As a dialogue in the Quackery Shell…
Welcome to Quackery. Enter "leave" to leave the shell. /O> $ "5 3 2 ** **" dup echo$ say " returns " quackery echo cr ... $ "5 3 ** 2 **" dup echo$ say " returns " quackery echo cr ... 5 3 2 ** ** returns 1953125 5 3 ** 2 ** returns 15625 Stack empty.
R
The 'Operator Syntax and Precedence' documentation tells us that "^" is "exponentiation (right to left)". The 'Arithmetic Operators' documentation also tells us that the parser translates "**" to "^", but its depreciation status is complicated.
It turns out that the parser is so blind to "**" that we cannot even quote it. The following are identical: <lang r>print(quote(5**3)) print(quote(5^3))</lang>
Another method is to use "^" as if it is an ordinary function of two arguments. It appears that "**" does not support this. As there is no potential for ambiguity in the operator precedence, we will not print this result below. For example: <lang r>'^'('^'(5, 3), 2)</lang> is clearly (5^3)^2 i.e. 15625, whereas <lang r>^'(5, '^'(3, 2))</lang> is clearly 5^(3^2) i.e. 1953125.
As for actually solving the task, the requirement that each output be on a new line causes us a surprising amount of difficulty. To avoid repeating ourselves, we must almost resort to metaprogramming: <lang r>inputs<-alist(5^3^2, (5^3)^2, 5^(3^2), 5**3**2, (5**3)**2, 5**(3**2)) invisible(sapply(inputs, function(x) cat(deparse(x), "returns: ", eval(x), "\n")))</lang>
Alternatively, we could print out a matrix or data frame: <lang r>print(matrix(sapply(inputs, eval), dimnames = list(inputs, "Outputs"))) print(data.frame(Inputs=sapply(inputs, deparse), Outputs=sapply(inputs, eval))))</lang>
- Output:
> print(quote(5**3))
5^3
> print(quote(5^3))
5^3
> invisible(sapply(inputs, function(x) cat(deparse(x), "returns: ", eval(x), "\n")))
5^3^2 returns: 1953125
(5^3)^2 returns: 15625
5^(3^2) returns: 1953125
5^3^2 returns: 1953125
(5^3)^2 returns: 15625
5^(3^2) returns: 1953125
> print(matrix(sapply(inputs, eval), dimnames = list(inputs, "Outputs")))
Outputs
5^3^2 1953125
(5^3)^2 15625
5^(3^2) 1953125
5^3^2 1953125
(5^3)^2 15625
5^(3^2) 1953125
> print(data.frame(Inputs=sapply(inputs, deparse), Outputs=sapply(inputs, eval)))
Inputs Outputs
1 5^3^2 1953125
2 (5^3)^2 15625
3 5^(3^2) 1953125
4 5^3^2 1953125
5 (5^3)^2 15625
6 5^(3^2) 1953125
Racket
<lang racket>#lang racket
- 5**3**2 depends on associativity of **
- Racket's (scheme's) prefix function
- calling syntax only allows for pairs of arguments for expt.
- So no can do for 5**3**2
- (5**3)**2
(displayln "prefix") (expt (expt 5 3) 2)
- (5**3)**2
(expt 5 (expt 3 2))
- There is also a less-used infix operation (for all functions, not just expt)... which I suppose
- might do with an airing. But fundamentally nothing changes.
(displayln "\"in\"fix") ((5 . expt . 3) . expt . 2) (5 . expt . (3 . expt . 2))
- everyone's doing a reduction, it seems
(displayln "reduction") (require (only-in srfi/1 reduce reduce-right)) (reduce expt 1 '(5 3 2)) (reduce-right expt 1 '(5 3 2))</lang>
- Output:
prefix 15625 1953125 "in"fix 15625 1953125 reduction 14134776518227074636666380005943348126619871175004951664972849610340958208 1953125
Raku
(formerly Perl 6)
Note that the reduction forms automatically go right-to-left because the base operator is right-associative. Most other operators are left-associative and would automatically reduce left-to-right instead.
<lang perl6>use MONKEY-SEE-NO-EVAL; sub demo($x) { say " $x\t───► ", EVAL $x }
demo '5**3**2'; # show ** is right associative demo '(5**3)**2'; demo '5**(3**2)';
demo '[**] 5,3,2'; # reduction form, show only final result demo '[\**] 5,3,2'; # triangle reduction, show growing results
- Unicode postfix exponents are supported as well:
demo '(5³)²'; demo '5³²'; </lang>
- Output:
5**3**2 ───► 1953125 (5**3)**2 ───► 15625 5**(3**2) ───► 1953125 [**] 5,3,2 ───► 1953125 [\**] 5,3,2 ───► 2 9 1953125 (5³)² ───► 15625 5³² ───► 23283064365386962890625
The Unicode exponent form without parentheses ends up raising to the 32nd power. Nor are you even allowed to parenthesize it the other way: 5(³²) would be a syntax error. Despite all that, for programs that do a lot of squaring or cubing, the postfix forms can enhance both readability and concision.
REXX
<lang rexx>/*REXX program demonstrates various ways of multiple exponentiations. */ /*┌────────────────────────────────────────────────────────────────────┐
│ The REXX language uses ** for exponentiation. │ │ Also, * * can be used. │ | and even */*power of*/* | └────────────────────────────────────────────────────────────────────┘*/
say ' 5**3**2 ───► ' 5**3**2 say ' (5**3)**2 ───► ' (5**3)**2 say ' 5**(3**2) ───► ' 5**(3**2)
/*stick a fork in it, we're done.*/</lang>
output
5**3**2 ───► 15625 (5**3)**2 ───► 15625 5**(3**2) ───► 1953125
Ring
In the Ring it is impossible to show the result of: 5^3^2
<lang ring> see "(5^3)^2 =>" + pow(pow(5,3),2) + nl see "5^(3^2) =>" + pow(5,pow(3,2)) + nl </lang> Output:
(5^3)^2 =>15625 5^(3^2) =>1953125
Ruby
<lang ruby>ar = ["5**3**2", "(5**3)**2", "5**(3**2)", "[5,3,2].inject(:**)"] ar.each{|exp| puts "#{exp}:\t#{eval exp}"} </lang>
- Output:
5**3**2: 1953125 (5**3)**2: 15625 5**(3**2): 1953125 [5,3,2].inject(:**): 15625
Rust
<lang rust>fn main() {
println!("5**3**2 = {:7}", 5u32.pow(3).pow(2));
println!("(5**3)**2 = {:7}", (5u32.pow(3)).pow(2));
println!("5**(3**2) = {:7}", 5u32.pow(3u32.pow(2)));
}</lang>
- Output:
5**3**2 = 15625 (5**3)**2 = 15625 5**(3**2) = 1953125
Scala
Scal has no exponentiation operator, but uses the function (scala.)math.pow(x: Double, y: Double): Double function in the Scala runtime library.
Integer exponentiation can be done with e.g. BigInt or BigInteger.pow(n: Int) method.
There are no associativity issues.
Seed7
<lang seed7>$ include "seed7_05.s7i";
const proc: main is func
begin
writeln("5**3**2 = " <& 5**3**2);
writeln("(5**3)**2 = " <& (5**3)**2);
writeln("5**(3**2) = " <& 5**(3**2));
end func;</lang>
- Output:
5**3**2 = 1953125 (5**3)**2 = 15625 5**(3**2) = 1953125
Sidef
In Sidef, the whitespace between the operands and the operator controls the precedence of the operation. <lang ruby>var a = [
'5**3**2', '(5**3)**2', '5**(3**2)', '5 ** 3 ** 2', '5 ** 3**2', '5**3 ** 2', '[5,3,2]«**»',
]
a.each {|e|
"%-12s == %s\n".printf(e, eval(e))
}</lang>
- Output:
5**3**2 == 1953125 (5**3)**2 == 15625 5**(3**2) == 1953125 5 ** 3 ** 2 == 15625 5 ** 3**2 == 1953125 5**3 ** 2 == 15625 [5,3,2]«**» == 15625
Simula
<lang Simula>OutText("5** 3 **2: "); OutInt(5** 3 **2, 0); Outimage; OutText("(5**3)**2: "); OutInt((5**3)**2, 0); Outimage; OutText("5**(3**2): "); OutInt(5**(3**2), 0); Outimage</lang>
- Output:
5** 3 **2: 15625 (5**3)**2: 15625 5**(3**2): 1953125
Smalltalk
Works in Smalltalk/X ¹
Smalltalk strictly evaluates left to right; operators are not known to the language/parser, but instead message sends to the receiver on the left side (aka: virtual function calls) . <lang smalltalk>Transcript show:'5**3**2 => '; showCR: 5**3**2. Transcript show:'(5**3)**2 => '; showCR: (5**3)**2. Transcript show:'5**(3**2) => '; showCR: 5**(3**2).</lang>
- Output:
5**(3**2) => 1953125 5**3**2 => 15625 (5**3)**2 => 15625
Note ¹ other Smalltalk's may define ** to simply call "raisedTo:", which is standard.
Stata
<lang stata>. di (5^3^2) 15625
. di ((5^3)^2) 15625
. di (5^(3^2)) 1953125</lang>
Likewise in Mata:
<lang stata>. mata (5^3^2)
15625
. mata ((5^3)^2)
15625
. mata (5^(3^2))
1953125</lang>
Tcl
<lang tcl>foreach expression {5**3**2 (5**3)**2 5**(3**2)} {
puts "${expression}:\t[expr $expression]"
}</lang>
- Output:
5**3**2: 1953125 (5**3)**2: 15625 5**(3**2): 1953125
There's also a binary pow() expression function that always converts its arguments to floating point numbers and then applies the exponentiation operation; it's now largely obsolete because of the ** operator, but is retained for backward compatibility with older programs.
VBA
<lang vb>Public Sub exp()
Debug.Print "5^3^2", 5 ^ 3 ^ 2 Debug.Print "(5^3)^2", (5 ^ 3) ^ 2 Debug.Print "5^(3^2)", 5 ^ (3 ^ 2)
End Sub</lang>
- Output:
5^3^2 15625 (5^3)^2 15625 5^(3^2) 1953125
VBScript
<lang vb> WScript.StdOut.WriteLine "5^3^2 => " & 5^3^2 WScript.StdOut.WriteLine "(5^3)^2 => " & (5^3)^2 WScript.StdOut.WriteLine "5^(3^2) => " & 5^(3^2) </lang>
- Output:
5^3^2 => 15625 (5^3)^2 => 15625 5^(3^2) => 1953125
Verbexx
<lang verbexx>// Exponentiation order example:
@SAY "5**3**2 = " ( 5**3**2 ); @SAY "(5**3)**2 = " ( (5**3)**2 ); @SAY "5**(3**2) = " ( 5**(3**2) );
/] Output:
5**3**2 = 1953125 (5**3)**2 = 15625 5**(3**2) = 1953125</lang>
Wren
Wren doesn't have an exponentiation operator as such but the Num class has a pow method which does the same thing. <lang ecmascript>import "/fmt" for Fmt
var ops = [ "5**3**2", "(5**3)**2", "5**(3**2)" ] var results = [ 5.pow(3).pow(2), (5.pow(3)).pow(2), 5.pow(3.pow(2)) ] for (i in 0...ops.count) {
System.print("%(Fmt.s(-9, ops[i])) -> %(results[i])")
}</lang>
- Output:
5**3**2 -> 15625 (5**3)**2 -> 15625 5**(3**2) -> 1953125
zkl
zkl does not have an exponentiation operator but floats have a pow method. <lang zkl>println("5 ^ 3 ^ 2 = %,d".fmt((5.0).pow((3.0).pow(2)))); println("(5 ^ 3) ^ 2 = %,d".fmt((5.0).pow(3).pow(2))); println("5 ^ (3 ^ 2) = %,d".fmt((5.0).pow((3.0).pow(2))));</lang>
- Output:
5 ^ 3 ^ 2 = 1,953,125 (5 ^ 3) ^ 2 = 15,625 5 ^ (3 ^ 2) = 1,953,125
- Programming Tasks
- Solutions by Programming Task
- 11l
- Ada
- ALGOL 68
- ALGOL W
- APL
- AppleScript
- AWK
- BASIC
- Sinclair ZX81 BASIC
- BBC BASIC
- IS-BASIC
- Bracmat
- C
- C++
- C sharp
- Clojure
- Common Lisp
- D
- EchoLisp
- Factor
- Fortran
- FreeBASIC
- Frink
- Go
- Groovy
- Haskell
- Io
- J
- Java
- Jq
- Julia
- Kotlin
- Lambdatalk
- Latitude
- Lua
- Maple
- Mathematica
- Wolfram Language
- Min
- Nanoquery
- Nim
- OCaml
- PARI/GP
- Perl
- Phix
- Phix/basics
- PicoLisp
- Python
- Quackery
- R
- Racket
- Raku
- REXX
- Ring
- Ruby
- Rust
- Scala
- Seed7
- Sidef
- Simula
- Smalltalk
- Stata
- Tcl
- VBA
- VBScript
- Verbexx
- Wren
- Wren-fmt
- Zkl