Exponentiation with infix operators in (or operating on) the base: Difference between revisions

 

 

 

 

* [[wp:Order_of_operations#Programming_languages|Wikipedia: Order of operations in Programming languages]]

<br><br>

=={{header|ALGOL 68}}==

In Algol 68, all unary operators have a higher precedence than any binary operator.

<br>Algol 68 also allows UP and ^ for the exponentiation operator.

# show the results of exponentiation and unary minus in various combinations #

FOR x FROM -5 BY 10 TO 5 DO

print( ( " (-x)**p ", whole( (-x)**p, -4 ) ) );

print( ( " -(x**p) ", whole( -(x**p), -4 ) ) );

OD

OD

{{out}}

<pre>

x = 5 p = 3 -x**p -125 -(x)**p -125 (-x)**p -125 -(x**p) -125

</pre>

 

=={{header|F_Sharp|F#}}==

F# does not support the ** operator for integers but for floats:

printfn "-5.0**2.0=%f; -(5.0**2.0)=%f" (-5.0**2.0) (-(5.0**2.0))

{{out}}

<pre>

 

=={{header|Factor}}==

sequences.generalizations sequences.repeating ;

 

5 2 row

5 3 row

{{out}}

<pre>

5 2 -x**p 25 -(x)**p 25 (-x)**p 25 -(x**p) -25

5 3 -x**p -125 -(x)**p -125 (-x)**p -125 -(x**p) -125

</pre>

 

 

Note that we can't call the method ''↑'' (or similar) because identifiers in Go must begin with a Unicode letter and using a non-ASCII symbol would be awkward to type on some keyboards in any case.

 

import (

}

}

 

{{out}}

x = 5 e = 2 | -x.p(e) = -25 | -(x).p(e) = -25 | (-x).p(e) = 25 | -(x.p(e)) = -25

x = 5 e = 3 | -x.p(e) = -125 | -(x).p(e) = -125 | (-x).p(e) = -125 | -(x.p(e)) = -125

</pre>

 

In Julia, the ^ symbol is the power infix operator. The ^ operator has a higher precedence than the - operator,

so -5^2 is -25 and (-5)^2 is 25.

for x in [-5, 5], p in [2, 3]

println("x is", lpad(x, 3), ", p is $p, -x^p is", lpad(-x^p, 4), ", -(x)^p is",

lpad(-(x)^p, 5), ", (-x)^p is", lpad((-x)^p, 5), ", -(x^p) is", lpad(-(x^p), 5))

end

<pre>

x is -5, p is 2, -x^p is -25, -(x)^p is -25, (-x)^p is 25, -(x^p) is -25

x is 5, p is 3, -x^p is-125, -(x)^p is -125, (-x)^p is -125, -(x^p) is -125

</pre>

 

=={{header|Phix}}==

Phix has a power() function instead of an infix operator, hence there are only two possible syntaxes, with the obvious outcomes.<br>

(Like Go, Phix does not support operator overloading or definition at all.)

{{out}}

<pre>

x = 5, p = 3, power(-x,p) = -125, -power(x,p) = -125

</pre>

 

=={{header|Raku}}==

Also add a different grouping: <code>(1 + -x){exponential operator}p</code>

 

 

 

 

for -5, 5 X 2, 3 -> ($x, $p) {

printf "x = %2d p = %d", $x, $p;

}

{{out}}

<pre>Default precedence: infix exponentiation is tighter (higher) precedence than unary negation.

x = 5 p = 3 │ 1 + -$x↑$p = -124 │ 1 + (-$x)↑$p = -124 │ 1 + (-($x)↑$p) = -124 │ (1 + -$x)↑$p = -64 │ 1 + -($x↑$p) = -124

 

 

=={{header|REXX}}==

_= '─'; ! = '║'; mJunct= '─╫─'; bJunct= '─╨─' /*define some special glyphs. */

 

/*──────────────────────────────────────────────────────────────────────────────────────*/

@: parse arg txt, w, fill; if fill=='' then fill= ' '; return center( txt, w, fill)

{{out|output|text=&nbsp; when using the internal default input:}}

<pre>

5 3 ║ -x**p -125 ║ -(x)**p -125 ║ (-x)**p -125 ║ -(x**p) -125

───── ──────╨─────────── ───────╨─────────── ───────╨─────────── ───────╨─────────── ──────

</pre>

 

=={{header|Python}}==

 

xx = '-5 +5'.split()

for x, p in product(xx, pp):

texts2 = [t.replace(X, x).replace(P, p) for t in texts]

 

{{out}}

=={{header|Smalltalk}}==

Smalltalk has no prefix operator for negation. To negate, you have to send the number a "negated" message, which has higher precedence than any binary message. Literal constants may have a sign (which is not an operation, but part of the constant).

b := 3.

Transcript show:'-5**2 => '; showCR: -5**2.

Transcript show:'5**b => '; showCR: 5**b.

" Transcript show:'-(5**b) => '; showCR: -(5**b). -- invalid: syntax error "

Using the "negated" message:

Transcript show:'5 negated**3 => '; showCR: 5 negated**3.

Transcript show:'5**2 negated => '; showCR: 5**2 negated. "negates 2"

Transcript show:'(-5**b) negated => '; showCR: (-5**b) negated.

Transcript show:'-5 negated**2 => '; showCR: -5 negated**2. "negates the negative 5"

{{out}}

<pre>

=={{header|Wren}}==

{{libheader|Wren-fmt}}

 

However, what we can do is to wrap Num objects in a new Num2 class and then add exponentiation and unary minus operators to that.

 

Ideally what we'd like to do is to use a new operator such as '**' for exponentiation (because '^' is the bitwise exclusive or operator) but we can only overload existing operators with their existing precedence and so, for the purposes of this task, '^' is the only realistic choice.

 

class Num2 {

Fmt.print("$s = $4s", ops[3], -(x^p))

}

 

{{out}}