Exponentiation order: Difference between revisions

This task will demonstrate the order of [[wp:Exponentiation|exponentiation]] &nbsp; <big>('''x^y''') </big> &nbsp; when there are multiple exponents.

 

 

 

 

 

<br><br>

 

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

{{out}}

<pre>

5**(3**2): +1953125

</pre>

 

=={{header|AWK}}==

# syntax: GAWK -f EXPONENTIATION_ORDER.AWK

BEGIN {

exit(0)

}

<p>output:</p>

<pre>

</pre>

 

 

 

#include<math.h>

 

int main()

{

{{out}}

<pre>

 

(5 ^ 3) ^ 2 = 15625

5 ^ (3 ^ 2) = 1953125

</pre>

 

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

 

;; (5**3)**2

(expt (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)))

 

=={{header|D}}==

import std.stdio, std.math, std.algorithm;

 

writefln("5 ^^ (3 ^^ 2) = %7d", 5 ^^ (3 ^^ 2));

writefln("[5, 3, 2].reduce!pow = %7d", [5, 3, 2].reduce!pow);

{{out}}

<pre>5 ^^ 3 ^^ 2 = 1953125

5 ^^ (3 ^^ 2) = 1953125

[5, 3, 2].reduce!pow = 15625</pre>

 

=={{header|EchoLisp}}==

;; the standard and secure way is to use the (expt a b) function

(expt 5 (expt 3 2)) ;; 5 ** ( 3 ** 2)

(5 ** (3 ** 2))

→ 1953125

 

=={{header|Fortran}}==

write(*, "(a, i0)") "(5**3)**2 = ", (5**3)**2

{{out}}

<pre>5**3**2 = 1953125

 

=={{header|FreeBASIC}}==

 

' The exponentation operator in FB is ^ rather than **.

Print "(5^3)^2 =>"; (5^3)^2

Print "5^(3^2) =>"; 5^(3^2)

 

{{out}}

5^(3^2) => 1953125

</pre>

 

=={{header|Haskell}}==

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.

 

1.95312e6

(5^3)^2

15625

5^(3^2)

 

----

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

 

infix fun Int.ipow(exp: Int): Int = when {

println("(5**3)**2 = ${(5 ipow 3) ipow 2}")

println("5**(3**2) = ${5 ipow (3 ipow 2)}")

 

{{out}}

5**(3**2) = 1953125

</pre>

 

=={{header|Lua}}==

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

{{out}}

<pre>5^3^2 = 1953125

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|Mathematica}} / {{header|Wolfram Language}}==

Print[a <> " = " <> ToString[ToExpression[a]]]

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

Print[b <> " = " <> ToString[ToExpression[b]]]

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

{{out}}

<pre>5^3^2 = 1953125

(5^3)^2 = 15625

5^(3^2) = 1953125</pre>

 

=={{header|PARI/GP}}==

Exponentiation is right-associative in GP.

{{out}}

<pre>5^3^2 = 1953125

 

=={{header|Perl}}==

{{out}}

<pre>

</pre>

 

{{out}}

<pre>

</pre>

 

 

 

{{out}}

<pre>

</pre>

 

=={{header|PicoLisp}}==

The PicoLisp '**' exponentiation function takes 2 arguments

-> 15625

 

: (** 5 (** 3 2))

 

=={{header|Python}}==

1953125

>>> (5**3)**2

>>> reduce(pow, (5, 3, 2))

15625

 

=={{header|Racket}}==

;; 5**3**2 depends on associativity of ** : Racket's (scheme's) prefix function

;; calling syntax only allows for pairs of arguments for expt.

(require (only-in srfi/1 reduce reduce-right))

(reduce expt 1 '(5 3 2))

{{out}}

<pre>prefix

14134776518227074636666380005943348126619871175004951664972849610340958208

1953125</pre>

 

=={{header|REXX}}==

/*┌────────────────────────────────────────────────────────────────────┐

│ Also, * * can be used. │

└────────────────────────────────────────────────────────────────────┘*/

 

say ' (5**3)**2 ───► ' (5**3)**2

say ' 5**(3**2) ───► ' 5**(3**2)

'''output'''

<pre>

(5**3)**2 ───► 15625

5**(3**2) ───► 1953125

</pre>

 

=={{header|Ruby}}==

ar.each{|exp| puts "#{exp}:\t#{eval exp}"}

{{out}}

<pre>

5**(3**2): 1953125

[5,3,2].inject(:**): 15625

</pre>

 

=={{header|Sidef}}==

In Sidef, the whitespace between the operands and the operator controls the precedence of the operation.

'5**3**2',

'(5**3)**2',

a.each {|e|

"%-12s == %s\n".printf(e, eval(e))

{{out}}

<pre>

[5,3,2]«**» == 15625

</pre>

 

=={{header|Tcl}}==

puts "${expression}:\t[expr $expression]"

{{out}}

<pre>

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

 

{{Out}}

(5^3)^2 => 15625

5^(3^2) => 1953125

</pre>

 

{{trans|C}}

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

println("(5 ^ 3) ^ 2 = %,d".fmt((5.0).pow(3).pow(2)));

{{out}}

<pre>