Exponentiation order: Difference between revisions

 

=={{header|11l}}==

print((5 ^ 3) ^ 2)

{{out}}

<pre>

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

{{libheader|Action! Tool Kit}}

 

PROC Main()

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

PrintRE(tmp2)

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Exponentiation_order.png Screenshot from Atari 8-bit computer]

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

 

 

procedure Exponentation_Order is

Put_Line ("(5**3)**2 : " & Natural'((5**3)**2)'Image);

Put_Line ("5**(3**2) : " & Natural'(5**(3**2))'Image);

 

{{out}}

=={{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: +15625

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

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

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

{{out}}

<pre>

AppleScript's compiler inserts its own parentheses with 5 ^ 3 ^ 2.

 

set r2 to (5 ^ 3) ^ 2

set r3 to 5 ^ (3 ^ 2)

return "5 ^ 3 ^ 2 = " & r1 & "

(5 ^ 3) ^ 2 = " & r2 & "

 

{{output}}

=={{header|Arturo}}==

 

print (5^3)^2

 

{{out}}

 

=={{header|AWK}}==

# syntax: GAWK -f EXPONENTIATION_ORDER.AWK

BEGIN {

exit(0)

}

<p>output:</p>

<pre>

 

=={{header|BASIC}}==

{{out}}

 

==={{header|BBC BASIC}}===

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

{{out}}

<pre>5^3^2 = 15625

 

==={{header|IS-BASIC}}===

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

{{out}}

<pre>5^3^2 = 15625

(5^3)^2 = 15625

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

 

=={{header|Bracmat}}==

{{out}}

<pre>5^3^2: 1953125

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

 

return 0;

 

{{out}}

 

=={{header|C++}}==

#include <cmath>

 

return EXIT_SUCCESS;

 

With permissive flag:

#include <cmath>

 

return EXIT_SUCCESS;

 

{{out}}

 

=={{header|C sharp|C#}}==

 

namespace exponents

}

}

{{out}}

<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|CLU}}==

po: stream := stream$primary_output()

stream$putl(po, "(5**3)**2 = " || int$unparse((5**3)**2))

stream$putl(po, "5**(3**2) = " || int$unparse(5**(3**2)))

{{out}}

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

=={{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>5**3**2</code>. Just showing expressions for the latter two.

{{out}}

<pre>15625

 

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

 

5 3 2 ^ ^

 

5 3 ^ 2 ^

{{out}}

<pre>

Factor also has syntax for infix arithmetic via the the <code>infix</code> vocabulary.

 

 

[infix 5**3**2 infix]

 

[infix 5**(3**2) infix]

{{out}}

<pre>

 

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

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

 

{{out}}

(5^3)^2 = 15625

5^(3^2) = 1953125

</pre>

 

=={{header|Go}}==

 

import "fmt"

fmt.Printf("(5^3)^2 = %.0f\n", b)

fmt.Printf("5^(3^2) = %.0f\n", c)

 

{{out}}

 

Solution:

println("(5 ** 3)** 2 == " + (5**3)**2)

 

Output:

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)

 

----

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:

 

 

For chaining, one could use `reduce`:

 

 

 

Result: 15625

{{works with|Julia|0.6}}

 

@show (5 ^ 3) ^ 2

@show 5 ^ (3 ^ 2)

@show reduce(^, [5, 3, 2])

@show foldl(^, [5, 3, 2]) # guarantees left associativity

 

{{out}}

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

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

 

=={{header|Latitude}}==

(5 ^ 3) ^ 2. ;; 15625

 

=={{header|Lua}}==

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

{{out}}

<pre>5^3^2 = 1953125

 

=={{header|Maple}}==

(5^3)^2;

{{Out|Output}}

<pre>Error, ambiguous use of `^`, please use parentheses

 

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

As with other postfix languages, there is no ambiguity because all operators have the same precedence.

{{works with|min|0.19.6}}

"5 3 2 ^ ^ " print! puts!

 

5 3 pow 2 pow

{{out}}

<pre>

5 3 2 ^ ^ 1953125.0

5 3 ^ 2 ^ 15625.0

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

15625

% println (5^3)^2

15625

% println 5^(3^2)

 

=={{header|Nim}}==

 

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)

 

{{out}}

=={{header|OCaml}}==

OCaml language has '**' as an exponentiation symbol for floating point integers

# 5. ** 3. ** 2. ;;

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

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

{{out}}

<pre>

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

Exponentiation is right-associative in GP.

{{out}}

<pre>5^3^2 = 1953125

 

=={{header|Perl}}==

{{out}}

<pre>

{{libheader|Phix/basics}}

Phix has a power function rather than an infix power operator, hence there is no possible confusion.

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

{{out}}

<pre>

15625

1953125

</pre>

 

=={{header|PicoLisp}}==

The PicoLisp '**' exponentiation function takes 2 arguments

-> 15625

 

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

 

=={{header|PL/I}}==

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

{{out}}

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

 

=={{header|Python}}==

1953125

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

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

15625

 

=={{header|Quackery}}==

 

It turns out that the parser is so blind to "**" that we cannot even quote it. The following are identical:

 

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:

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

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:

 

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

{{out}}

<pre>> print(quote(5**3))

 

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

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.

 

sub demo($x) { say " $x\t───► ", EVAL $x }

 

demo '(5³)²';

demo '5³²';

 

{{out}}

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

 

exprs: [

print [mold/only expr "=" math expr "using math"]

]

{{out}}

<pre>

 

=={{header|REXX}}==

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

│ The REXX language uses ** for exponentiation. │

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

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

'''output'''

<pre>

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:

<pre>

(5^3)^2 =>15625

5^(3^2) =>1953125

</pre>

 

=={{header|Ruby}}==

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

{{out}}

<pre>

=={{header|Rust}}==

 

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

{{out}}

<pre>

(5**3)**2 = 15625

5**(3**2) = 1953125

</pre>

 

 

=={{header|Seed7}}==

 

const proc: main is func

writeln("(5**3)**2 = " <& (5**3)**2);

writeln("5**(3**2) = " <& 5**(3**2));

 

{{out}}

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

 

=={{header|Simula}}==

OutText("(5**3)**2: "); OutInt((5**3)**2, 0); Outimage;

{{out}}

<pre>5** 3 **2: 15625

Works in Smalltalk/X &sup1;

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

Transcript show:'(5**3)**2 => '; showCR: (5**3)**2.

{{out}}

<pre>

=={{header|Stata}}==

 

15625

 

 

. di (5^(3^2))

 

Likewise in Mata:

 

15625

 

 

. mata (5^(3^2))

 

 

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

 

associativity: left

higherThan: MultiplicationPrecedence

print(5 ** 3 ** 2)

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

 

{{out}}

 

=={{header|Tcl}}==

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

{{out}}

<pre>

 

=={{header|VBA}}==

Debug.Print "5^3^2", 5 ^ 3 ^ 2

Debug.Print "(5^3)^2", (5 ^ 3) ^ 2

Debug.Print "5^(3^2)", 5 ^ (3 ^ 2)

<pre>5^3^2 15625

(5^3)^2 15625

 

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

 

=={{header|Verbexx}}==

 

@SAY "5**3**2 = " ( 5**3**2 );

5**3**2 = 1953125

(5**3)**2 = 15625

 

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

 

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

 

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