# Exponentiation order

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

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.

## 11l

print(5 ^ 3 ^ 2)
print((5 ^ 3) ^ 2)
print(5 ^ (3 ^ 2))
Output:
1.95313e+06
15625
1.95313e+06


## Action!

There is no power operator in Action! Power function for REAL type is used. But the precision is insufficient.

INCLUDE "D2:REAL.ACT" ;from the Action! Tool Kit

PROC Main()
REAL r2,r3,r5,tmp1,tmp2

Put(125) PutE() ;clear screen

IntToReal(2,r2)
IntToReal(3,r3)
IntToReal(5,r5)

PrintE("There is no power operator in Action!")
PrintE("Power function for REAL type is used.")
PrintE("But the precision is insufficient.")
Power(r5,r3,tmp1)
Power(tmp1,r2,tmp2)
Print("(5^3)^2=")
PrintRE(tmp2)

Power(r3,r2,tmp1)
Power(r5,tmp1,tmp2)
Print("5^(3^2)=")
PrintRE(tmp2)
RETURN
Output:
There is no power operator in Action!
Power function for REAL type is used.
But the precision is insufficient.
(5^3)^2=15624.9977
5^(3^2)=1953124.17


5**3**2 is not a valid Ada expression. Parenthesis are mandatory.

with Ada.Text_IO;

procedure Exponentation_Order is
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;

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.

print( ( "5**3**2:   ", 5**3**2, newline ) );
print( ( "(5**3)**2: ", (5**3)**2, newline ) );
print( ( "5**(3**2): ", 5**(3**2), newline ) )
Output:
5**3**2:        +15625
(5**3)**2:      +15625
5**(3**2):    +1953125


## ALGOL-M

The eponentiation operator ** in ALGOL-M works only on integer operands.

begin

write("5**3**2   = ", 5**3**2);
write("(5**3)**2 = ", (5**3)**2);
write("5**(3**2) = ", 5**(3**2));

end
Output:

The third expression results in a value that exceeds the maximum integer value of 16383. Sadly, ALGOL-M emits no warning or error message when this occurs but simply gives the wrong answer.

5**3**2   =  15625
(5**3)**2 =  15625
5**(3**2) = -12955


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

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

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

Output:
"5 ^ 3 ^ 2 = 1.953125E+6
(5 ^ 3) ^ 2 = 1.5625E+4
5 ^ (3 ^ 2) = 1.953125E+6"

## Arturo

print 5^3^2
print (5^3)^2
print 5^(3^2)

Output:
1953125
15625
1953125

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


output:

5^3^2   = 1953125
(5^3)^2 = 15625
5^(3^2) = 1953125


## BASIC

### Applesoft BASIC

?"5^3^2   = "5 ^ 3 ^ 2 CHR$(13)"(5^3)^2 = "(5 ^ 3) ^ 2 CHR$ (13)"5^(3^2) = "5 ^ (3 ^ 2);

Output:
5^3^2   = 15625
(5^3)^2 = 15625
5^(3^2) = 1953125.01

### BASIC256

Works with: QBasic
Works with: FreeBASIC
Works with: True BASIC
Works with: Run BASIC
print "5^3^2   = "; 5^3^2
print "(5^3)^2 = "; (5^3)^2
print "5^(3^2) = "; 5^(3^2)
end

Output:
5^3^2   = 15625
(5^3)^2 = 15625
5^(3^2) = 1953125

### BBC BASIC

PRINT "5^3^2   = "; 5^3^2
PRINT "(5^3)^2 = "; (5^3)^2
PRINT "5^(3^2) = "; 5^(3^2)

Output:
5^3^2   = 15625
(5^3)^2 = 15625
5^(3^2) = 1953125

### Chipmunk Basic

Works with: Chipmunk Basic version 3.6.4
10 print "5^3^2   = "5^3^2
20 print "(5^3)^2 = "(5^3)^2
30 print "5^(3^2) = "5^(3^2)

Output:
5^3^2   = 15625
(5^3)^2 = 15625
5^(3^2) = 1953125

### GW-BASIC

Works with: Applesoft BASIC
Works with: Chipmunk Basic
Works with: MSX_BASIC
Works with: PC-BASIC version any
Works with: QBasic
10 PRINT "5^3^2   =" 5^3^2
20 PRINT "(5^3)^2 =" (5^3)^2
30 PRINT "5^(3^2) =" 5^(3^2)

Output:
5^3^2   = 15625
(5^3)^2 = 15625
5^(3^2) = 1953125

### 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)
Output:
5^3^2   = 15625
(5^3)^2 = 15625
5^(3^2) = 1953125

### MSX 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)

Output:
5^3^2   = 15625
(5^3)^2 = 15625
5^(3^2) = 1953125

### PureBasic

In the PureBasic it is impossible to show the result of: 5^3^2

OpenConsole()
PrintN("(5^3)^2 = " + Str(Pow(Pow(5, 3), 2)))
PrintN("5^(3^2) = " + Str(Pow(5, (Pow(3, 2)))))
CloseConsole()

Output:
(5^3)^2 = 15625
5^(3^2) = 1953125

### QBasic

Works with: QBasic version 1.1
Works with: QuickBasic version 4.5
Works with: FreeBASIC
Works with: True BASIC
Works with: BASIC256
Works with: Run BASIC
PRINT "5^3^2   ="; 5^3^2
PRINT "(5^3)^2 ="; (5^3)^2
PRINT "5^(3^2) ="; 5^(3^2)
END

Output:
5^3^2   = 15625
(5^3)^2 = 15625
5^(3^2) = 1953125

### Run BASIC

Works with: QBasic
Works with: FreeBASIC
Works with: True BASIC
Works with: BASIC256
print "5^3^2   = "; 5^3^2
print "(5^3)^2 = "; (5^3)^2
print "5^(3^2) = "; 5^(3^2)
end

Output:
5^3^2   = 15625
(5^3)^2 = 15625
5^(3^2) = 1953125

### True BASIC

Works with: QBasic
Works with: FreeBASIC
Works with: BASIC256
Works with: Run BASIC
PRINT "5^3^2   ="; 5^3^2
PRINT "(5^3)^2 ="; (5^3)^2
PRINT "5^(3^2) ="; 5^(3^2)
END

Output:
5^3^2   = 15625
(5^3)^2 = 15625
5^(3^2) = 1953125

### XBasic

Works with: Windows XBasic
PROGRAM	"Exponentiation order"
VERSION	"0.0000"

DECLARE FUNCTION  Entry ()

FUNCTION  Entry ()
PRINT "5^3^2   ="; 5**3**2
PRINT "(5^3)^2 ="; (5**3)**2
PRINT "5^(3^2) ="; 5**(3**2)
END FUNCTION
END PROGRAM

Output:
5^3^2   = 15625
(5^3)^2 = 15625
5^(3^2) = 1953125

### Yabasic

Works with: QBasic
Works with: FreeBASIC
Works with: True BASIC
Works with: BASIC256
print "5^3^2   = ", 5^3^2
print "(5^3)^2 = ", (5^3)^2
print "5^(3^2) = ", 5^(3^2)
end

Output:
5^3^2   = 15625
(5^3)^2 = 15625
5^(3^2) = 1953125

### Sinclair ZX81 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)

Output:
5**3**2   = 15625
(5**3)**2 = 15625
5**(3**2) = 1953125

## Bracmat

put$str$("5^3^2: " 5^3^2 "\n(5^3)^2: " (5^3)^2 "\n5^(3^2): " 5^(3^2) \n)
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.

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

Output:
(5 ^ 3) ^ 2 = 15625
5 ^ (3 ^ 2) = 1953125


## C++

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


With permissive flag:

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

Output:
(5 ^ 3) ^ 2 = 15625
5 ^ (3 ^ 2) = 1953125


## C#

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

}
}

Output:
15625
1953125


## Clojure

Clojure uses prefix notation and expt only takes 2 arguments for exponentiation, so "5**3**2" isn't represented.

(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


## CLU

start_up = proc ()
print('5 ^ (3 ^ 2) = ${pow(5, (pow(3, 2)))}'); }  Output: (5 ^ 3) ^ 2 = 15625 5 ^ (3 ^ 2) = 1953125 ## EasyLang print "(5 ^ 3) ^ 2 = " & pow (pow 5 3) 2 print "5 ^ (3 ^ 2) = " & pow 5 pow 3 2  ## EchoLisp ;; 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  ## 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. USING: formatting math.functions ; 5 3 2 ^ ^ "5 3 2 ^ ^ %d\n" printf 5 3 ^ 2 ^ "5 3 ^ 2 ^ %d\n" printf  Output: 5 3 2 ^ ^ 1953125 5 3 ^ 2 ^ 15625  Factor also has syntax for infix arithmetic via the the infix vocabulary. 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  Output: 5**3**2 = 15625 (5**3)**2 = 15625 5**(3**2) = 1953125  ## 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)  Output: 5**3**2 = 1953125 (5**3)**2 = 15625 5**(3**2) = 1953125 ## 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  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." println["5^3^2 = " + 5^3^2] println["(5^3)^2 = " + (5^3)^2] println["5^(3^2) = " + 5^(3^2)] Output: 5^3^2 = 1953125 (5^3)^2 = 15625 5^(3^2) = 1953125  ## FutureBasic FB is translated into C which does not have an exponentiation operator. The caret operator '^' performs xor bitwise operation. FB also has an fn pow function, translated from the the standard C Math library, which takes two arguments. print "(5^3)^2 = "; (5^3)^2 print "5^(3^2) = "; 5^(3^2) print print "fn pow( fn pow(5,3), 2 ) = "; fn pow( fn pow(5,3), 2 ) print "fn pow( 5, fn pow(3,2 ) ) = "; fn pow( 5, fn pow(3,2 ) ) HandleEvents Output: (5^3)^2 = 15625 5^(3^2) = 1953125 fn pow( fn pow(5,3), 2 ) = 15625 fn pow( 5, fn pow(3,2 ) ) = 1953125  ## 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) }  Output: 5^3^2 = 1953125 (5^3)^2 = 15625 5^(3^2) = 1953125  ## Groovy Solution: println(" 5 ** 3 ** 2 == " + 5**3**2) println("(5 ** 3)** 2 == " + (5**3)**2) println(" 5 **(3 ** 2)== " + 5**(3**2))  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.  5^3^2 1.95312e6 (5^3)^2 15625 5^(3^2) 1.95312e6  ## 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: jq -n 'pow(pow(5;3);2)' 15625 For chaining, one could use reduce:  def pow: reduce .[1:] as$i (.[0]; pow(.;$i)) [5,3,2] | pow Result: 15625 ## Julia Works with: Julia version 0.6 @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  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. // 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)}")
}

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.

'{pow {pow 5 3} 2}
-> {pow {pow 5 3} 2}
'{pow 5 {pow 3 2}}
-> {pow 5 {pow 3 2}}


## langur

writeln "  5^3^2: ", 5^3^2
writeln "(5^3)^2: ", (5^3)^2
writeln "5^(3^2): ", 5^(3^2)
Output:
  5^3^2: 1953125
(5^3)^2: 15625
5^(3^2): 1953125


## Latitude

5 ^ 3 ^ 2.   ;; 1953125
(5 ^ 3) ^ 2. ;; 15625
5 ^ (3 ^ 2). ;; 1953125

## Lua

print("5^3^2 = " .. 5^3^2)
print("(5^3)^2 = " .. (5^3)^2)
print("5^(3^2) = " .. 5^(3^2))

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

5^3^2;
(5^3)^2;
5^(3^2);
Output:
Error, ambiguous use of ^, please use parentheses
15625
1953125

## Mathematica / Wolfram Language

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

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.

Works with: min version 0.19.6
5 3 2 pow pow
"5 3 2 ^ ^  " print! puts!

5 3 pow 2 pow
"5 3 ^ 2 ^  " print! puts!
Output:
5 3 2 ^ ^  1953125.0
5 3 ^ 2 ^  15625.0


## MiniScript

REPL output.

Output:
]5^3^2
15625
](5^3)^2
15625
]5^(3^2)
1953125


## Nanoquery

Nanoquery uses the '^' operator, which performs exponentiation in order like multiplication. Parenthesis are often needed to perform operations like 5^3^2 correctly.

% println 5^3^2
15625
% println (5^3)^2
15625
% println 5^(3^2)
1953125

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

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

# 5. ** 3. ** 2. ;;
# 5. **( 3. ** 2.) ;;
#(5. ** 3. ) **2. ;;

Output:
- :   float = 1953125.
- :     float = 1953125.
- :   float = 15625.



## PARI/GP

Exponentiation is right-associative in GP.

f(s)=print(s" = "eval(s));
apply(f, ["5^3^2", "(5^3)^2", "5^(3^2)"]);
Output:
5^3^2 = 1953125
(5^3)^2 = 15625
5^(3^2) = 1953125

## Perl

say "$_ = " . eval($_)  for  qw/5**3**2  (5**3)**2  5**(3**2)/;

Output:
5**3**2 = 1953125
(5**3)**2 = 15625
5**(3**2) = 1953125


## Phix

Library: Phix/basics

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


## Picat

main =>
X = 5**3**2, Y = (5**3)**2, Z = 5**(3**2),
print("5**3**2    = "), println(X),
print("(5**3)**2  = "), println(Y),
print("5**(3**2)  = "), print(Z).
Output:
5**3**2    = 1953125
(5**3)**2  = 15625
5**(3**2)  = 1953125


## PicoLisp

The PicoLisp '**' exponentiation function takes 2 arguments

: (** (** 5 3) 2)
-> 15625

: (** 5 (** 3 2))
-> 1953125

## PL/I

exponentiation: procedure options(main);
put skip edit('5**3**2   = ', 5**3**2)   (A,F(7));
put skip edit('(5**3)**2 = ', (5**3)**2) (A,F(7));
put skip edit('5**(3**2) = ', 5**(3**2)) (A,F(7));
end exponentiation;
Output:
5**3**2   =   15625
(5**3)**2 =   15625
5**(3**2) = 1953125

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


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

print(quote(5**3))
print(quote(5^3))


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:

'^'('^'(5, 3), 2)


is clearly (5^3)^2 i.e. 15625, whereas

'^'(5, '^'(3, 2))


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:

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


Alternatively, we could print out a matrix or data frame:

print(matrix(sapply(inputs, eval), dimnames = list(inputs, "Outputs")))
print(data.frame(Inputs = sapply(inputs, deparse), Outputs = sapply(inputs, eval))))

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

Output:
prefix
15625
1953125
"in"fix
15625
1953125
reduction
14134776518227074636666380005943348126619871175004951664972849610340958208
1953125

## Raku

(formerly Perl 6)

Works with: rakudo version 2016.08

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.

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³²';  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. ## Red In Red, operators simply evaluate left to right. As this differs from mathematical order of operations, Red provides the math function which evaluates a block using math rules instead of Red's default evaluation. One could also use the power function, sidestepping the issue of evaluation order entirely. All three approaches are shown. Red["Exponentiation order"] exprs: [ [5 ** 3 ** 2] [(5 ** 3) ** 2] [5 ** (3 ** 2)] [power power 5 3 2] ;-- functions too [power 5 power 3 2] ] foreach expr exprs [ print [mold/only expr "=" do expr] if find expr '** [ print [mold/only expr "=" math expr "using math"] ] ]  Output: 5 ** 3 ** 2 = 15625 5 ** 3 ** 2 = 1953125 using math (5 ** 3) ** 2 = 15625 (5 ** 3) ** 2 = 15625 using math 5 ** (3 ** 2) = 1953125 5 ** (3 ** 2) = 1953125 using math power power 5 3 2 = 15625 power 5 power 3 2 = 1953125  ## 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.*/  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 see "(5^3)^2 =>" + pow(pow(5,3),2) + nl see "5^(3^2) =>" + pow(5,pow(3,2)) + nl Output: (5^3)^2 =>15625 5^(3^2) =>1953125  ## RPL When using reverse Polish notation, there is no parenthesis: the user must decide the exponentiation order. When using algebraic notation: '5^3^2' →NUM '(5^3)^2' →NUM '5^(3^2)' →NUM  Output: 3: 15625 2: 15625 1: 1953125  ## Ruby ar = ["5**3**2", "(5**3)**2", "5**(3**2)", "[5,3,2].inject(:**)"] ar.each{|exp| puts "#{exp}:\t#{eval exp}"}  Output: 5**3**2: 1953125 (5**3)**2: 15625 5**(3**2): 1953125 [5,3,2].inject(:**): 15625  ## 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))); }  Output: 5**3**2 = 15625 (5**3)**2 = 15625 5**(3**2) = 1953125  ## S-BASIC The exponentiation operator ^ works on both integer and real operands. Numeric constants in expressions are taken to be of type real, which is useful here, because the third result exceeds S-BASIC's manximum integer value of 32767. print "5^3^2 : "; 5 ^ 3 ^ 2 print "(5^3)^2 : "; (5 ^ 3) ^ 2 print "5^(3^2) : "; 5 ^ (3 ^ 2) end  Output: 5^3^2 : 15625 (5^3)^2 : 15625 5^(3^2) : 1.95312E+6  ## 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 $ 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;
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.

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

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

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

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

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

. di (5^3^2)
15625

. di ((5^3)^2)
15625

. di (5^(3^2))
1953125


Likewise in Mata:

. mata (5^3^2)
15625

. mata ((5^3)^2)
15625

. mata (5^(3^2))
1953125


## Swift

Swift doesn't have an exponentiation operator, however it's possible to define one, including the precedence and associativity.

precedencegroup ExponentiationPrecedence {
associativity: left
higherThan: MultiplicationPrecedence
}

infix operator ** : ExponentiationPrecedence

@inlinable
public func ** <T: BinaryInteger>(lhs: T, rhs: T) -> T {
guard lhs != 0 else {
return 1
}

var x = lhs
var n = rhs
var y = T(1)

while n > 1 {
switch n & 1 {
case 0:
n /= 2
case 1:
y *= x
n = (n - 1) / 2
case _:
fatalError()
}

x *= x
}

return x * y
}

print(5 ** 3 ** 2)
print((5 ** 3) ** 2)
print(5 ** (3 ** 2))

Output:
15625
15625
1953125

## Tcl

foreach expression {5**3**2 (5**3)**2 5**(3**2)} {
puts "${expression}:\t[expr$expression]"
}

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

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

Output:
5^3^2          15625
(5^3)^2        15625
5^(3^2)        1953125


## VBScript

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)

Output:
5^3^2 => 15625
(5^3)^2 => 15625
5^(3^2) => 1953125


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

## Wren

Library: Wren-fmt

Wren doesn't have an exponentiation operator as such but the Num class has a pow method which does the same thing.

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) {
Fmt.print("$-9s ->$d", ops[i], results[i])
}

Output:
5**3**2   -> 15625
(5**3)**2 -> 15625
5**(3**2) -> 1953125


## XPL0

XPL0 doesn't have an exponentiation operator, but it does have a Pow intrinsic (in the 32-bit versions).

[Format(1, 0);
Text(0, "5**3**2   = ");  RlOut(0, Pow(5., Pow(3., 2.)));  CrLf(0);     \right associative
Text(0, "(5**3)**2 = ");  RlOut(0, Pow(Pow(5., 3.), 2.));  CrLf(0);
Text(0, "5**(3**2) = ");  RlOut(0, Pow(5., Pow(3., 2.)));  CrLf(0);
]
Output:
5**3**2   = 1953125
(5**3)**2 = 15625
5**(3**2) = 1953125


## zkl

Translation of: C

zkl does not have an exponentiation operator but floats have a pow method.

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))));
Output:
5 ^ 3 ^ 2   = 1,953,125
(5 ^ 3) ^ 2 = 15,625
5 ^ (3 ^ 2) = 1,953,125