Exponentiation order: Difference between revisions

← Older edit

Exponentiation order (view source)

Revision as of 11:57, 3 December 2023

35,767 bytes added , 5 months ago

m

→‎{{header|Wren}}: Changed to Wren S/H

PureFox

9,479

edits

Revision as of 04:23, 17 April 2014 (view source) Catskill549 (talk \| contribs) (→‎{{header\|C}}) ← Older edit		Latest revision as of 11:57, 3 December 2023 (view source) PureFox (talk \| contribs) m (→‎{{header\|Wren}}: Changed to Wren S/H)
(131 intermediate revisions by 75 users not shown)
Line 1: {{~~draft~~ task~~\|exponentiation order~~}} ~~This task will demonstrate the order of [[wp:Exponentiation\|exponentiation]] ('''x<sup>y</sup>''') when there are multiple exponents.~~ This task will demonstrate the order of [[wp:Exponentiation\|exponentiation]]   <big>('''x<sup>y</sup>''') </big>   when there are multiple exponents. ~~(Many programming languages, especially those with extended-precision integer arithmetic, usually support one of <code></code>, <code>^</code>, <code>↑</code> or some such for exponentiation.)~~ (Many programming languages,   especially those with extended─precision integer arithmetic,   usually support one of <big> <code></code>, <code>^</code>, <code>↑</code> </big> 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):~~ Using whatever operator or syntax your language supports (if any), show the results in three lines (with identification): * 532 <big> * (53)2 ::::*   5(32) ::::*   (53)2 ::::*   5(32) </big> <br> If there are other methods (or formats) of multiple exponentiations, show them as well. ~~;See also~~ ;See also: * Mathworld entry [http://mathworld.wolfram.com/Exponentiation.html exponentiation] * MathWorld entry:   [http://mathworld.wolfram.com/Exponentiation.html exponentiation] * [[Arbitrary-precision integers (included)]] ;Related tasks: *   [[Exponentiation_operator\|exponentiation operator]] *   [[Arbitrary-precision_integers_(included)\|arbitrary-precision integers (included)]] *   [[Exponentiation with infix operators in (or operating on) the base]] <br><br> =={{header\|11l}}== <syntaxhighlight lang="11l">print(5 ^ 3 ^ 2) print((5 ^ 3) ^ 2) print(5 ^ (3 ^ 2))</syntaxhighlight> {{out}} <pre> 1.95313e+06 15625 1.95313e+06 </pre> =={{header\|Action!}}== There is no power operator in Action! Power function for REAL type is used. But the precision is insufficient. {{libheader\|Action! Tool Kit}} <syntaxhighlight lang="action!">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</syntaxhighlight> {{out}} [https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Exponentiation_order.png Screenshot from Atari 8-bit computer] <pre> 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 </pre> =={{header\|Ada}}== 532 is not a valid Ada expression. Parenthesis are mandatory. <syntaxhighlight lang="ada">with Ada.Text_IO; procedure Exponentation_Order is use Ada.Text_IO; begin -- Put_Line ("532 : " & Natural'(532)'Image); Put_Line ("(53)2 : " & Natural'((53)2)'Image); Put_Line ("5(32) : " & Natural'(5(32))'Image); end Exponentation_Order;</syntaxhighlight> {{out}} <pre>(53)2 : 15625 5(32) : 1953125</pre> =={{header\|ALGOL 68}}== Algol 68 provides various alternative symbols for the exponentiation operator generally, "", "^" and "UP" can be used. <syntaxhighlight lang="algol68">print( ( "532: ", 532, newline ) ); print( ( "(53)2: ", (53)2, newline ) ); print( ( "5(32): ", 5(32), newline ) )</syntaxhighlight> {{out}} <pre> 532: +15625 (53)2: +15625 5(32): +1953125 </pre> =={{header\|ALGOL-M}}== The eponentiation operator in ALGOL-M works only on integer operands. <syntaxhighlight lang = "ALGOL"> begin write("532 = ", 532); write("(53)2 = ", (53)2); write("5(32) = ", 5(32)); end </syntaxhighlight> {{out}} 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. <pre> 532 = 15625 (53)2 = 15625 5(32) = -12955 </pre> =={{header\|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. <syntaxhighlight lang="algolw">begin write( "532: ", round( 5 3 2 ) ); write( "(53)2: ", round( ( 5 3 ) 2 ) ); write( "5(32): ", round( 5 round( 3 2 ) ) ) end.</syntaxhighlight> {{out}} <pre> 532: 15625 (53)2: 15625 5(32): 1953125 </pre> =={{header\|APL}}== APL has no order of precedence other than right-to-left operation. * is the APL exponentiation operator. <pre> 532 1953125 (53)2 15625 5(32) 1953125 </pre> =={{header\|AppleScript}}== AppleScript's compiler inserts its own parentheses with 5 ^ 3 ^ 2. <syntaxhighlight 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</syntaxhighlight> {{output}} <pre>"5 ^ 3 ^ 2 = 1.953125E+6 (5 ^ 3) ^ 2 = 1.5625E+4 5 ^ (3 ^ 2) = 1.953125E+6"</pre> =={{header\|Arturo}}== <syntaxhighlight lang="rebol">print 5^3^2 print (5^3)^2 print 5^(3^2)</syntaxhighlight> {{out}} <pre>1953125 15625 1953125</pre> =={{header\|AWK}}== <syntaxhighlight lang="awk"> ~~<lang AWK>~~ # syntax: GAWK -f EXPONENTIATION_ORDER.AWK BEGIN { Line 26 ⟶ 192: exit(0) } </syntaxhighlight> ~~</lang>~~ <p>output:</p> <pre> Line 33 ⟶ 199: 5^(3^2) = 1953125 </pre> ~~=={{header\|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 2 arguments.~~ =={{header\|BASIC}}== ~~Expressions in C are evaluated by RPN. The RPNs of 5^3^2 and 5^(3^2) are the same and thus also their pow expressions.~~ ==={{header\|Applesoft BASIC}}=== ~~<lang C>~~ <syntaxhighlight lang="gwbasic">?"5^3^2 = "5 ^ 3 ^ 2 CHR$ (13)"(5^3)^2 = "(5 ^ 3) ^ 2 CHR$ (13)"5^(3^2) = "5 ^ (3 ^ 2);</syntaxhighlight> ~~/Abhishek Ghosh, 20th March 2014, Rotterdam/~~ {{out}} <pre>5^3^2 = 15625 (5^3)^2 = 15625 5^(3^2) = 1953125.01</pre> ==={{header\|BASIC256}}=== {{works with\|QBasic}} {{works with\|FreeBASIC}} {{works with\|True BASIC}} {{works with\|Run BASIC}} <syntaxhighlight lang="freebasic">print "5^3^2 = "; 5^3^2 print "(5^3)^2 = "; (5^3)^2 print "5^(3^2) = "; 5^(3^2) end</syntaxhighlight> {{out}} <pre>5^3^2 = 15625 (5^3)^2 = 15625 5^(3^2) = 1953125</pre> ==={{header\|BBC BASIC}}=== ~~include<stdio.h>~~ <syntaxhighlight lang="bbcbasic">PRINT "5^3^2 = "; 5^3^2 PRINT "(5^3)^2 = "; (5^3)^2 PRINT "5^(3^2) = "; 5^(3^2)</syntaxhighlight> {{out}} <pre>5^3^2 = 15625 (5^3)^2 = 15625 5^(3^2) = 1953125</pre> ==={{header\|Chipmunk Basic}}=== {{works with\|Chipmunk Basic\|3.6.4}} <syntaxhighlight lang="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)</syntaxhighlight> {{out}} <pre>5^3^2 = 15625 (5^3)^2 = 15625 5^(3^2) = 1953125</pre> ==={{header\|GW-BASIC}}=== {{works with\|Applesoft BASIC}} {{works with\|Chipmunk Basic}} {{works with\|MSX_BASIC}} {{works with\|PC-BASIC\|any}} {{works with\|QBasic}} <syntaxhighlight lang="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)</syntaxhighlight> {{out}} <pre>5^3^2 = 15625 (5^3)^2 = 15625 5^(3^2) = 1953125</pre> ==={{header\|IS-BASIC}}=== <syntaxhighlight 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)</syntaxhighlight> {{out}} <pre>5^3^2 = 15625 (5^3)^2 = 15625 5^(3^2) = 1953125</pre> ==={{header\|MSX Basic}}=== <syntaxhighlight lang="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)</syntaxhighlight> {{out}} <pre>5^3^2 = 15625 (5^3)^2 = 15625 5^(3^2) = 1953125</pre> ==={{header\|PureBasic}}=== In the PureBasic it is impossible to show the result of: 5^3^2 <syntaxhighlight lang="vb">OpenConsole() PrintN("(5^3)^2 = " + Str(Pow(Pow(5, 3), 2))) PrintN("5^(3^2) = " + Str(Pow(5, (Pow(3, 2))))) CloseConsole()</syntaxhighlight> {{out}} <pre>(5^3)^2 = 15625 5^(3^2) = 1953125</pre> ==={{header\|QBasic}}=== {{works with\|QBasic\|1.1}} {{works with\|QuickBasic\|4.5}} {{works with\|FreeBASIC}} {{works with\|True BASIC}} {{works with\|BASIC256}} {{works with\|Run BASIC}} <syntaxhighlight lang="qbasic">PRINT "5^3^2 ="; 5^3^2 PRINT "(5^3)^2 ="; (5^3)^2 PRINT "5^(3^2) ="; 5^(3^2) END</syntaxhighlight> {{out}} <pre>5^3^2 = 15625 (5^3)^2 = 15625 5^(3^2) = 1953125</pre> ==={{header\|Run BASIC}}=== {{works with\|QBasic}} {{works with\|FreeBASIC}} {{works with\|True BASIC}} {{works with\|BASIC256}} <syntaxhighlight lang="freebasic">print "5^3^2 = "; 5^3^2 print "(5^3)^2 = "; (5^3)^2 print "5^(3^2) = "; 5^(3^2) end</syntaxhighlight> {{out}} <pre>5^3^2 = 15625 (5^3)^2 = 15625 5^(3^2) = 1953125</pre> ==={{header\|True BASIC}}=== {{works with\|QBasic}} {{works with\|FreeBASIC}} {{works with\|BASIC256}} {{works with\|Run BASIC}} <syntaxhighlight lang="qbasic">PRINT "5^3^2 ="; 5^3^2 PRINT "(5^3)^2 ="; (5^3)^2 PRINT "5^(3^2) ="; 5^(3^2) END</syntaxhighlight> {{out}} <pre>5^3^2 = 15625 (5^3)^2 = 15625 5^(3^2) = 1953125</pre> ==={{header\|XBasic}}=== {{works with\|Windows XBasic}} <syntaxhighlight lang="qbasic">PROGRAM "Exponentiation order" VERSION "0.0000" DECLARE FUNCTION Entry () FUNCTION Entry () PRINT "5^3^2 ="; 532 PRINT "(5^3)^2 ="; (53)2 PRINT "5^(3^2) ="; 5(32) END FUNCTION END PROGRAM</syntaxhighlight> {{out}} <pre>5^3^2 = 15625 (5^3)^2 = 15625 5^(3^2) = 1953125</pre> ==={{header\|Yabasic}}=== {{works with\|QBasic}} {{works with\|FreeBASIC}} {{works with\|True BASIC}} {{works with\|BASIC256}} <syntaxhighlight lang="freebasic">print "5^3^2 = ", 5^3^2 print "(5^3)^2 = ", (5^3)^2 print "5^(3^2) = ", 5^(3^2) end</syntaxhighlight> {{out}} <pre>5^3^2 = 15625 (5^3)^2 = 15625 5^(3^2) = 1953125</pre> ==={{header\|Sinclair ZX81 BASIC}}=== <syntaxhighlight lang="basic">10 PRINT "532 = ";532 20 PRINT "(53)2 = ";(53)2 30 PRINT "5(32) = ";5(32)</syntaxhighlight> {{out}} <pre>532 = 15625 (53)2 = 15625 5(32) = 1953125</pre> =={{header\|Bracmat}}== <syntaxhighlight lang="bracmat">put$str$("5^3^2: " 5^3^2 "\n(5^3)^2: " (5^3)^2 "\n5^(3^2): " 5^(3^2) \n) </syntaxhighlight> {{out}} <pre>5^3^2: 1953125 (5^3)^2: 15625 5^(3^2): 1953125</pre> =={{header\|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. <syntaxhighlight lang="c">#include<stdio.h> #include<math.h> int main() { printf("~~\n5~~(5 ^ 3) ^ 2 = %.0f",pow(pow(5,~~pow(~~3),2))); ~~/.0f suppresses decimal output/~~ printf("\~~n(5~~n5 ^ (3) ^ 2) = %.0f",~~pow(~~pow(5,pow(3),2))); ~~printf("\n5 ^ (3 ^ 2) = %.0f",pow(5,pow(3,2)));~~ return 0; }</syntaxhighlight> } ~~</lang>~~ {{out}} <pre> (5 ^ 3) ^ 2 = 15625 5 ^ (3 ^ 2) = 1953125 </pre> =={{header\|C++}}== ~~5 ^ 3 ^ 2 = 1953125~~ <syntaxhighlight 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; }</syntaxhighlight> With permissive flag: <syntaxhighlight 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; }</syntaxhighlight> {{out}} <pre> (5 ^ 3) ^ 2 = 15625 5 ^ (3 ^ 2) = 1953125 </pre> =={{header\|C sharp\|C#}}== <syntaxhighlight 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(); } } } </syntaxhighlight> {{out}} <pre> 15625 1953125 </pre> =={{header\|Clojure}}== Clojure uses prefix notation and expt only takes 2 arguments for exponentiation, so "532" isn't represented. <syntaxhighlight lang="clojure">(use 'clojure.math.numeric-tower) ;; (53)2 (expt (expt 5 3) 2) ; => 15625 ;; 5(32) (expt 5 (expt 3 2)) ; => 1953125 ;; (53)2 alternative: use reduce (reduce expt [5 3 2]) ; => 15625 ;; 5(32) 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</syntaxhighlight> =={{header\|CLU}}== <syntaxhighlight lang="clu">start_up = proc () po: stream := stream$primary_output() stream$putl(po, "532 = " \|\| int$unparse(532)) stream$putl(po, "(53)2 = " \|\| int$unparse((53)2)) stream$putl(po, "5(32) = " \|\| int$unparse(5(32))) end start_up</syntaxhighlight> {{out}} <pre>532 = 1953125 (53)2 = 15625 5(32) = 1953125</pre> =={{header\|Common Lisp}}== Because Common Lisp uses prefix notation and <code>expt</code> accepts only two arguments, it doesn't have an expression for <code>532</code>. Just showing expressions for the latter two. <syntaxhighlight lang="lisp">(expt (expt 5 3) 2) (expt 5 (expt 3 2))</syntaxhighlight> {{out}} <pre>15625 1953125</pre> =={{header\|D}}== <~~lang~~syntaxhighlight lang="d">void main() { import std.stdio, std.math, std.algorithm; Line 68 ⟶ 500: writefln("5 ^^ (3 ^^ 2) = %7d", 5 ^^ (3 ^^ 2)); writefln("[5, 3, 2].reduce!pow = %7d", [5, 3, 2].reduce!pow); }</~~lang~~syntaxhighlight> {{out}} <pre>5 ^^ 3 ^^ 2 = 1953125 Line 75 ⟶ 507: [5, 3, 2].reduce!pow = 15625</pre> =={{header\|~~Perl 6~~Delphi}}== {{works with\|Delphi\|6.0}} ~~<lang perl6>sub demo($x) { say " $x\t───► ", EVAL $x }~~ {{libheader\|Math,SysUtils,StdCtrls}} Delphi doesn't have exponentiation but it does have the "Power" function in the math library <syntaxhighlight lang="Delphi"> ~~demo '532'; # show * is right associative~~ procedure ExponentDemo(Memo: TMemo); ~~demo '(53)2';~~ begin ~~demo '5(32)';~~ Memo.Lines.Add('5^3^2 = '+FloatToStrF(Power(5,Power(3,2)),ffNumber,18,0)); Memo.Lines.Add('(5^3)^2 = '+FloatToStrF(Power(Power(5,3),2),ffNumber,18,0)); Memo.Lines.Add('5^(3^2) = '+FloatToStrF(Power(5,Power(3,2)),ffNumber,18,0)); end; ~~demo '[] 5,3,2'; # reduction form, show only final result~~ </syntaxhighlight> ~~demo '[\] 5,3,2'; # triangle reduction, show growing results</lang>~~ {{out}} <pre> ~~<pre> 532 ───► 1953125~~ 5^3^2 = 1,953,125 ~~(53)2 ───► 15625~~ (5^3)^2 = 15,625 ~~5(32) ───► 1953125~~ 5^(3^2) = 1,953,125 ~~[] 5,3,2 ───► 1953125~~ ~~[\] 5,3,2 ───► 2 9 1953125</pre>~~ 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. </pre> While it is possible to define your own postfix operators to do exponentiation, Unicode does not have multilevel subscripts, and postfixes are always evaluated from inside out, so you can't stack them and expect right associativity: ~~<lang perl6>sub postfix:<²>($n) { $n * $n }~~ ~~sub postfix:<³>($n) { $n * $n * $n }~~ =={{header\|Dart}}== ~~demo '(5³)²';~~ <syntaxhighlight lang="dart">import 'dart:math' show pow; ~~demo '5³²';</lang>~~ void main() { print('(5 ^ 3) ^ 2 = ${pow(pow(5, 3), 2)}'); print('5 ^ (3 ^ 2) = ${pow(5, (pow(3, 2)))}'); }</syntaxhighlight> {{out}} <pre>(5 ^ 3) ^ 2 = 15625 5 ^ (3 ^ 2) = 1953125</pre> =={{header\|EasyLang}}== <syntaxhighlight> print "(5 ^ 3) ^ 2 = " & pow (pow 5 3) 2 print "5 ^ (3 ^ 2) = " & pow 5 pow 3 2 </syntaxhighlight> =={{header\|EchoLisp}}== <syntaxhighlight 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 </syntaxhighlight> =={{header\|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. <syntaxhighlight lang="factor">USING: formatting math.functions ; 5 3 2 ^ ^ "5 3 2 ^ ^ %d\n" printf 5 3 ^ 2 ^ "5 3 ^ 2 ^ %d\n" printf</syntaxhighlight> {{out}} <pre> 5 3 2 ^ ^ 1953125 5 3 ^ 2 ^ 15625 </pre> Factor also has syntax for infix arithmetic via the the <code>infix</code> vocabulary. <syntaxhighlight lang="factor">USING: formatting infix ; [infix 532 infix] "532 = %d\n" printf [infix (53)2 infix] "(53)2 = %d\n" printf [infix 5(32) infix] "5(32) = %d\n" printf</syntaxhighlight> {{out}} <pre> 532 = 15625 (53)2 = 15625 5(3*2) = 1953125 </pre> =={{header\|Fortran}}== <syntaxhighlight lang="fortran">write(, "(a, i0)") "532 = ", 532 write(, "(a, i0)") "(53)2 = ", (53)2 write(, "(a, i0)") "5(32) = ", 5(32)</syntaxhighlight> {{out}} <pre>532 = 1953125 (53)2 = 15625 5(32) = 1953125</pre> =={{header\|FreeBASIC}}== <syntaxhighlight 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</syntaxhighlight> {{out}} <pre> 5^3^2 => 15625 (5^3)^2 => 15625 5^(3^2) => 1953125 </pre> =={{header\|Frink}}== Frink correctly follows standard mathematical notation that exponent towers are performed from "top to bottom" or "right to left." <syntaxhighlight lang="frink">println["5^3^2 = " + 5^3^2] println["(5^3)^2 = " + (5^3)^2] println["5^(3^2) = " + 5^(3^2)] </syntaxhighlight> {{out}} <pre> 5^3^2 = 1953125 (5^3)^2 = 15625 5^(3^2) = 1953125 </pre> =={{header\|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. <syntaxhighlight lang="futurebasic"> 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 </syntaxhighlight> {{output}} <pre> (5^3)^2 = 15625 5^(3^2) = 1953125 fn pow( fn pow(5,3), 2 ) = 15625 fn pow( 5, fn pow(3,2 ) ) = 1953125 </pre> =={{header\|Go}}== <syntaxhighlight 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) }</syntaxhighlight> {{out}} <pre> 5^3^2 = 1953125 (5^3)^2 = 15625 5^(3^2) = 1953125 </pre> =={{header\|Groovy}}== Solution: <syntaxhighlight lang="groovy">println(" 5 3 2 == " + 532) println("(5 3) 2 == " + (53)2) println(" 5 (3 2)== " + 5(32))</syntaxhighlight> Output: <pre> 5 3 2 == 15625 (5 3) 2 == 15625 5 (3 2)== 1953125</pre> =={{header\|Haskell}}== Haskell has three infix exponentiation operators dealing with different domains: <pre>λ> :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 ^^</pre> All of them are right-associative. <pre>λ> 5^3^2 1953125 λ> (5^3)^2 15625 λ> 5^(3^2) 1953125 λ> 532 == 5(32) True</pre> 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: <pre>λ> (5^^3)^^2 15625.0 λ> ((5^^3)^^2)^^4 5.9604644775390624e16</pre> =={{header\|Io}}== <pre>Io> 532 ==> 15625 Io> (53)2 ==> 15625 Io> 5(32) ==> 1953125 Io> 5 pow(3) pow(2) ==> 15625 Io> 5 (3) (2) ==> 15625 Io> Number getSlot("") == Number getSlot("pow") ==> true Io> </pre> Operators in Io are implemented as methods. Here the <code></code> method is the same as the <code>pow</code> method. Syntax sugar converts "normal" mathematical expressions to messages. =={{header\|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. <syntaxhighlight lang="j"> 5^3^2 1.95312e6 (5^3)^2 15625 5^(3^2) 1.95312e6</syntaxhighlight> ---- =={{header\|Java}}== Java has no exponentiation operator, but uses the static method java.lang.Math.pow(double a, double b). There are no associativity issues. =={{header\|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: <syntaxhighlight lang="jq">jq -n 'pow(pow(5;3);2)' 15625</syntaxhighlight> For chaining, one could use `reduce`: <syntaxhighlight lang="jq"> def pow: reduce .[1:] as $i (.[0]; pow(.;$i)) [5,3,2] \| pow</syntaxhighlight> Result: 15625 =={{header\|Julia}}== {{works with\|Julia\|0.6}} <syntaxhighlight 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</syntaxhighlight> {{out}} <pre>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</pre> =={{header\|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. <syntaxhighlight 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("532 = ${5 ipow 3 ipow 2}") println("(53)2 = ${(5 ipow 3) ipow 2}") println("5(32) = ${5 ipow (3 ipow 2)}") }</syntaxhighlight> {{out}} <pre> 532 = 15625 (53)2 = 15625 5(32) = 1953125 </pre> =={{header\|Lambdatalk}}== Because lambdatalk uses prefix notation and {pow a b} accepts only two arguments, it doesn't have an expression for 532. Just showing expressions for the latter two. <syntaxhighlight lang="scheme"> '{pow {pow 5 3} 2} -> {pow {pow 5 3} 2} '{pow 5 {pow 3 2}} -> {pow 5 {pow 3 2}} </syntaxhighlight> =={{header\|langur}}== <syntaxhighlight lang="langur">writeln " 5^3^2: ", 5^3^2 writeln "(5^3)^2: ", (5^3)^2 writeln "5^(3^2): ", 5^(3^2) </syntaxhighlight> {{out}} <pre> 5^3^2: 1953125 (5^3)^2: 15625 5^(3^2): 1953125 </pre> =={{header\|Latitude}}== <syntaxhighlight lang="latitude">5 ^ 3 ^ 2. ;; 1953125 (5 ^ 3) ^ 2. ;; 15625 5 ^ (3 ^ 2). ;; 1953125</syntaxhighlight> =={{header\|Lua}}== <syntaxhighlight lang="lua">print("5^3^2 = " .. 5^3^2) print("(5^3)^2 = " .. (5^3)^2) print("5^(3^2) = " .. 5^(3^2))</syntaxhighlight> {{out}} <pre>5^3^2 = 1953125 (5^3)^2 = 15625 5^(3^2) = 1953125</pre> 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. =={{header\|Maple}}== <syntaxhighlight lang="maple">5^3^2; (5^3)^2; 5^(3^2);</syntaxhighlight> {{Out\|Output}} <pre>Error, ambiguous use of `^`, please use parentheses 15625 1953125</pre> =={{header\|Mathematica}} / {{header\|Wolfram Language}}== <syntaxhighlight 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]]]</syntaxhighlight> {{out}} <pre>5^3^2 = 1953125 (5^3)^2 = 15625 5^(3^2) = 1953125</pre> =={{header\|min}}== As with other postfix languages, there is no ambiguity because all operators have the same precedence. {{works with\|min\|0.19.6}} <syntaxhighlight lang="min">5 3 2 pow pow "5 3 2 ^ ^ " print! puts! 5 3 pow 2 pow "5 3 ^ 2 ^ " print! puts!</syntaxhighlight> {{out}} <pre> 5 3 2 ^ ^ 1953125.0 5 3 ^ 2 ^ 15625.0 </pre> =={{header\|MiniScript}}== REPL output. {{out}} <pre> ]5^3^2 15625 ](5^3)^2 15625 ]5^(3^2) 1953125 </pre> =={{header\|Nanoquery}}== Nanoquery uses the '^' operator, which performs exponentiation in order like multiplication. Parenthesis are often needed to perform operations like 5^3^2 correctly. <syntaxhighlight lang="nanoquery">% println 5^3^2 15625 % println (5^3)^2 15625 % println 5^(3^2) 1953125</syntaxhighlight> =={{header\|Nim}}== <syntaxhighlight 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)</syntaxhighlight> {{out}} <pre>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</pre> =={{header\|OCaml}}== OCaml language has '' as an exponentiation symbol for floating point integers <syntaxhighlight lang="ocaml"> # 5. 3. 2. ;; # 5. ( 3. 2.) ;; #(5. 3. ) 2. ;; </syntaxhighlight> {{out}} <pre> - : float = 1953125. - : float = 1953125. - : float = 15625. </pre> =={{header\|PARI/GP}}== Exponentiation is right-associative in GP. <syntaxhighlight lang="parigp">f(s)=print(s" = "eval(s)); apply(f, ["5^3^2", "(5^3)^2", "5^(3^2)"]);</syntaxhighlight> {{out}} <pre>5^3^2 = 1953125 (5^3)^2 = 15625 5^(3^2) = 1953125</pre> =={{header\|Perl}}== <syntaxhighlight lang="perl">say "$_ = " . eval($_) for qw/532 (53)2 5(32)/;</syntaxhighlight> {{out}} <pre> 532 = 1953125 (53)2 = 15625 5(32) = 1953125 </pre> =={{header\|Phix}}== {{libheader\|Phix/basics}} Phix has a power function rather than an infix power operator, hence there is no possible confusion. <!--<syntaxhighlight lang="phix">--> <span style="color: #0000FF;">?<span style="color: #7060A8;">power<span style="color: #0000FF;">(<span style="color: #7060A8;">power<span style="color: #0000FF;">(<span style="color: #000000;">5<span style="color: #0000FF;">,<span style="color: #000000;">3<span style="color: #0000FF;">)<span style="color: #0000FF;">,<span style="color: #000000;">2<span style="color: #0000FF;">)</span> <span style="color: #0000FF;">?<span style="color: #7060A8;">power<span style="color: #0000FF;">(<span style="color: #000000;">5<span style="color: #0000FF;">,<span style="color: #7060A8;">power<span style="color: #0000FF;">(<span style="color: #000000;">3<span style="color: #0000FF;">,<span style="color: #000000;">2<span style="color: #0000FF;">)<span style="color: #0000FF;">) <!--</syntaxhighlight>--> {{out}} <pre> 15625 1953125 </pre> =={{header\|Picat}}== <syntaxhighlight lang="picat">main => X = 532, Y = (53)2, Z = 5(32), print("532 = "), println(X), print("(53)2 = "), println(Y), print("5(32) = "), print(Z). </syntaxhighlight> {{out}} <pre> 532 = 1953125 (53)2 = 15625 5(32) = 1953125 </pre> =={{header\|PicoLisp}}== The PicoLisp '' exponentiation function takes 2 arguments <syntaxhighlight lang="picolisp">: ( ( 5 3) 2) -> 15625 : ( 5 ( 3 2)) -> 1953125</syntaxhighlight> =={{header\|PL/I}}== <syntaxhighlight lang="pli">exponentiation: procedure options(main); put skip edit('532 = ', 532) (A,F(7)); put skip edit('(53)2 = ', (53)2) (A,F(7)); put skip edit('5(32) = ', 5(32)) (A,F(7)); end exponentiation;</syntaxhighlight> {{out}} <pre>532 = ~~(5³)² ───►~~ 15625 (53)2 = 15625 ~~5³² ───► 15625</pre>~~ 5(32) = 1953125</pre> (Not to mention the fact that the form without parentheses looks like you're trying to raise something to the 32nd power. Nor are you even allowed to parenthesize it the other way: <tt>5(³²)</tt> 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.) =={{header\|Python}}== <~~lang~~syntaxhighlight lang="python">>>> 532 1953125 >>> (53)2 Line 116 ⟶ 1,037: >>> reduce(pow, (5, 3, 2)) 15625 >>> </~~lang~~syntaxhighlight> =={{header\|Quackery}}== Quackery uses Reverse Polish Notation, so there is no ambiguity and no need for parenthesising. As a dialogue in the Quackery Shell… <pre>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.</pre> =={{header\|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: <syntaxhighlight lang="rsplus">print(quote(53)) print(quote(5^3))</syntaxhighlight> 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: <syntaxhighlight lang="rsplus">'^'('^'(5, 3), 2)</syntaxhighlight> is clearly (5^3)^2 i.e. 15625, whereas <syntaxhighlight lang="rsplus">'^'(5, '^'(3, 2))</syntaxhighlight> 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: <syntaxhighlight lang="rsplus">inputs <- alist(5^3^2, (5^3)^2, 5^(3^2), 532, (53)2, 5(32)) invisible(sapply(inputs, function(x) cat(deparse(x), "returns: ", eval(x), "\n")))</syntaxhighlight> Alternatively, we could print out a matrix or data frame: <syntaxhighlight lang="rsplus">print(matrix(sapply(inputs, eval), dimnames = list(inputs, "Outputs"))) print(data.frame(Inputs = sapply(inputs, deparse), Outputs = sapply(inputs, eval))))</syntaxhighlight> {{out}} <pre>> print(quote(53)) 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</pre> =={{header\|Racket}}== <~~lang~~syntaxhighlight lang="racket">#lang racket ;; 532 depends on associativity of : Racket's (scheme's) prefix function ;; calling syntax only allows for pairs of arguments for expt. Line 140 ⟶ 1,127: (require (only-in srfi/1 reduce reduce-right)) (reduce expt 1 '(5 3 2)) (reduce-right expt 1 '(5 3 2))</~~lang~~syntaxhighlight> {{out}} <pre>prefix Line 151 ⟶ 1,138: 14134776518227074636666380005943348126619871175004951664972849610340958208 1953125</pre> =={{header\|Raku}}== (formerly Perl 6) {{Works with\|rakudo\|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. <syntaxhighlight lang="raku" line>use MONKEY-SEE-NO-EVAL; sub demo($x) { say " $x\t───► ", EVAL $x } demo '532'; # show is right associative demo '(53)2'; demo '5(32)'; 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³²'; </syntaxhighlight> {{out}} <pre> 532 ───► 1953125 (53)2 ───► 15625 5(32) ───► 1953125 [] 5,3,2 ───► 1953125 [\] 5,3,2 ───► 2 9 1953125 (5³)² ───► 15625 5³² ───► 23283064365386962890625 </pre> The Unicode exponent form without parentheses ends up raising to the 32nd power. Nor are you even allowed to parenthesize it the other way: <tt>5(³²)</tt> 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. =={{header\|Red}}== In Red, operators simply evaluate left to right. As this differs from mathematical order of operations, Red provides the <code>math</code> function which evaluates a block using math rules instead of Red's default evaluation. One could also use the <code>power</code> function, sidestepping the issue of evaluation order entirely. All three approaches are shown. <syntaxhighlight lang="rebol">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"] ] ]</syntaxhighlight> {{out}} <pre> 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 </pre> =={{header\|REXX}}== <~~lang~~syntaxhighlight lang="rexx">/REXX program demonstrates various ways of multiple exponentiations. / /┌────────────────────────────────────────────────────────────────────┐ │ The REXX language uses * for ~~exponention~~exponentiation. │ │ Also, * * can be used. │ \| and even /power of/ \| └────────────────────────────────────────────────────────────────────┘/ Line 162 ⟶ 1,215: say ' (53)2 ───► ' (53)2 say ' 5(32) ───► ' 5(32) /stick a fork in it, we're done./</~~lang~~syntaxhighlight> '''output''' <pre> Line 168 ⟶ 1,221: (53)2 ───► 15625 5(32) ───► 1953125 </pre> =={{header\|Ring}}== In the Ring it is impossible to show the result of: 5^3^2 <syntaxhighlight lang="ring"> see "(5^3)^2 =>" + pow(pow(5,3),2) + nl see "5^(3^2) =>" + pow(5,pow(3,2)) + nl </syntaxhighlight> Output: <pre> (5^3)^2 =>15625 5^(3^2) =>1953125 </pre> =={{header\|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 {{out}} <pre> 3: 15625 2: 15625 1: 1953125 </pre> =={{header\|Ruby}}== <~~lang~~syntaxhighlight lang="ruby">ar = ["532", "(53)2", "5(32)", "[5,3,2].inject(:)"] ar.each{\|exp\| puts "#{exp}:\t#{eval exp}"} </syntaxhighlight> ~~</lang>~~ {{out}} <pre> Line 180 ⟶ 1,260: 5(32): 1953125 [5,3,2].inject(:): 15625 </pre> =={{header\|Rust}}== <syntaxhighlight lang="rust">fn main() { println!("532 = {:7}", 5u32.pow(3).pow(2)); println!("(53)2 = {:7}", (5u32.pow(3)).pow(2)); println!("5(32) = {:7}", 5u32.pow(3u32.pow(2))); }</syntaxhighlight> {{out}} <pre> 532 = 15625 (53)2 = 15625 5(32) = 1953125 </pre> =={{header\|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. <syntaxhighlight lang = "BASIC"> print "5^3^2 : "; 5 ^ 3 ^ 2 print "(5^3)^2 : "; (5 ^ 3) ^ 2 print "5^(3^2) : "; 5 ^ (3 ^ 2) end </syntaxhighlight> {{out}} <pre> 5^3^2 : 15625 (5^3)^2 : 15625 5^(3^2) : 1.95312E+6 </pre> =={{header\|Scala}}== Scal has no exponentiation operator, but uses the function (scala.)math.pow(x: Double, y: Double): Double function in the Scala runtime library.<br>Integer exponentiation can be done with e.g. BigInt or BigInteger.pow(n: Int) method.<br>There are no associativity issues. =={{header\|Seed7}}== <syntaxhighlight lang="seed7">$ include "seed7_05.s7i"; const proc: main is func begin writeln("532 = " <& 532); writeln("(53)2 = " <& (53)2); writeln("5(32) = " <& 5(32)); end func;</syntaxhighlight> {{out}} <pre> 532 = 1953125 (53)2 = 15625 5(32) = 1953125 </pre> =={{header\|Sidef}}== In Sidef, the whitespace between the operands and the operator controls the precedence of the operation. <syntaxhighlight lang="ruby">var a = [ '532', '(53)2', '5(32)', '5 * 3 2', '5 32', '53 2', '[5,3,2]«»', ] a.each {\|e\| "%-12s == %s\n".printf(e, eval(e)) }</syntaxhighlight> {{out}} <pre> 532 == 1953125 (53)2 == 15625 5(32) == 1953125 5 3 2 == 15625 5 32 == 1953125 53 2 == 15625 [5,3,2]«» == 15625 </pre> =={{header\|Simula}}== <syntaxhighlight lang="simula">OutText("5 3 2: "); OutInt(5 3 2, 0); Outimage; OutText("(53)2: "); OutInt((53)2, 0); Outimage; OutText("5(32): "); OutInt(5(32), 0); Outimage</syntaxhighlight> {{out}} <pre>5 3 2: 15625 (53)2: 15625 5(32): 1953125</pre> =={{header\|Smalltalk}}== Works in Smalltalk/X ¹ <p>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) . <syntaxhighlight lang="smalltalk">Transcript show:'532 => '; showCR: 532. Transcript show:'(53)2 => '; showCR: (53)2. Transcript show:'5(32) => '; showCR: 5(32).</syntaxhighlight> {{out}} <pre> 5(32) => 1953125 532 => 15625 (53)2 => 15625 </pre> Note ¹ other Smalltalk's may define to simply call "raisedTo:", which is standard. =={{header\|Stata}}== <syntaxhighlight lang="stata">. di (5^3^2) 15625 . di ((5^3)^2) 15625 . di (5^(3^2)) 1953125</syntaxhighlight> Likewise in Mata: <syntaxhighlight lang="stata">. mata (5^3^2) 15625 . mata ((5^3)^2) 15625 . mata (5^(3^2)) 1953125</syntaxhighlight> =={{header\|Swift}}== Swift doesn't have an exponentiation operator, however it's possible to define one, including the precedence and associativity. <syntaxhighlight lang="swift">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))</syntaxhighlight> {{out}} <pre>15625 15625 1953125</pre> =={{header\|Tcl}}== <~~lang~~syntaxhighlight lang="tcl">foreach expression {532 (53)2 5(32)} { puts "${expression}:\t[expr $expression]" }</~~lang~~syntaxhighlight> {{out}} <pre> Line 193 ⟶ 1,443: </pre> There's also a binary <code>pow()</code> 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 <code></code> operator, but is retained for backward compatibility with older programs. =={{header\|VBA}}== <syntaxhighlight 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</syntaxhighlight>{{out}} <pre>5^3^2 15625 (5^3)^2 15625 5^(3^2) 1953125 </pre> =={{header\|VBScript}}== <syntaxhighlight 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) </syntaxhighlight> {{Out}} <pre> 5^3^2 => 15625 (5^3)^2 => 15625 5^(3^2) => 1953125 </pre> =={{header\|Verbexx}}== <syntaxhighlight lang="verbexx">// Exponentiation order example: @SAY "532 = " ( 532 ); @SAY "(53)2 = " ( (53)2 ); @SAY "5(32) = " ( 5(32) ); /] Output: 532 = 1953125 (53)2 = 15625 5(32) = 1953125</syntaxhighlight> =={{header\|Wren}}== {{libheader\|Wren-fmt}} Wren doesn't have an exponentiation operator as such but the Num class has a ''pow'' method which does the same thing. <syntaxhighlight lang="wren">import "./fmt" for Fmt var ops = [ "532", "(53)2", "5(32)" ] 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]) }</syntaxhighlight> {{out}} <pre> 532 -> 15625 (53)2 -> 15625 5(32) -> 1953125 </pre> =={{header\|XPL0}}== XPL0 doesn't have an exponentiation operator, but it does have a Pow intrinsic (in the 32-bit versions). <syntaxhighlight lang "XPL0">[Format(1, 0); Text(0, "532 = "); RlOut(0, Pow(5., Pow(3., 2.))); CrLf(0); \right associative Text(0, "(53)2 = "); RlOut(0, Pow(Pow(5., 3.), 2.)); CrLf(0); Text(0, "5(32) = "); RlOut(0, Pow(5., Pow(3., 2.))); CrLf(0); ]</syntaxhighlight> {{out}} <pre> 532 = 1953125 (53)2 = 15625 5(3**2) = 1953125 </pre> =={{header\|zkl}}== {{trans\|C}} zkl does not have an exponentiation operator but floats have a pow method. <syntaxhighlight 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))));</syntaxhighlight> {{out}} <pre> 5 ^ 3 ^ 2 = 1,953,125 (5 ^ 3) ^ 2 = 15,625 5 ^ (3 ^ 2) = 1,953,125 </pre>