I'm working on modernizing Rosetta Code's infrastructure. Starting with communications. Please accept this time-limited open invite to RC's Slack.. --Michael Mol (talk) 20:59, 30 May 2020 (UTC)

# Exponentiation with infix operators in (or operating on) the base

Exponentiation with infix operators in (or operating on) the base
You are encouraged to solve this task according to the task description, using any language you may know.

(Many programming languages,   especially those with extended─precision integer arithmetic,   usually support one of `**`, `^`, `↑` or some such for exponentiation.)

Some languages treat/honor infix operators when performing exponentiation   (raising numbers to some power by the language's exponentiation operator,   if the computer programming language has one).

Other programming languages may make use of the   POW   or some other BIF   (Built─In Ffunction),   or some other library service.

If your language's exponentiation operator is not one of the usual ones, please comment on how to recognize it.

This task will deal with the case where there is some form of an   infix operator   operating in   (or operating on)   the base.

Example

A negative five raised to the 3rd power could be specified as:

```   -5  ** 3          or as
-(5) ** 3          or as
(-5) ** 3          or as something else
```

(Not all computer programming languages have an exponential operator and/or support these syntax expression(s).

•   compute and display exponentiation with a possible infix operator, whether specified and/or implied/inferred.
•   Raise the following numbers   (integer or real):
•   -5     and
•   +5
•   to the following powers:
•   2nd     and
•   3rd
•   using the following expressions   (if applicable in your language):
•   -x**p
•   -(x)**p
•   (-x)**p
•   -(x**p)
•   Show here (on this page) the four (or more) types of symbolic expressions for each number and power.

Try to present the results in the same format/manner as the other programming entries to make any differences apparent.

The variables may be of any type(s) that is/are applicable in your language.

References

## Contents

The order of precedence for Ada operators is:

```logical_operator            ::=   and | or  | xor
relational_operator         ::=   =   | /=  | <   | <= | > | >=
binary_adding_operator      ::=   +   | –   | &
multiplying_operator        ::=   *   | /   | mod | rem
highest_precedence_operator ::=   **  | abs | not
```

Ada provides an exponentiation operator for integer types and floating point types.

`with Ada.Text_IO; use Ada.Text_IO;with Ada.Float_Text_IO; use Ada.Float_Text_IO;with Ada.Integer_Text_IO; use Ada.Integer_Text_IO; procedure Main is   ivalue : Integer := -5;   fvalue : float   := -5.0;begin   Put_Line("Integer exponentiation:");   for i in 1..2 loop      for power in 2..3 loop          Put("x =" & ivalue'image & " p =" & power'image);         Put("   -x ** p ");         Put(item => -ivalue ** power, width => 4);         Put("   -(x) ** p ");         Put(item => -(ivalue) ** power, width => 4);         Put("   (-x) ** p ");         Put(Item => (- ivalue) ** power, Width => 4);         Put("   -(x ** p) ");         Put(Item => -(ivalue ** power), Width => 4);         New_line;      end loop;      ivalue := 5;      fvalue := 5.0;   end loop;   Put_Line("floating point exponentiation:");   ivalue := -5;   fvalue := -5.0;    for i in 1..2 loop      for power in 2..3 loop         Put("x =" & fvalue'image & " p =" & power'image);         Put("   -x ** p ");         Put(item => -fvalue ** power, fore => 4, Aft => 1, Exp => 0);         Put("   -(x) ** p ");         Put(item => -(fvalue) ** power, fore => 4, Aft => 1, Exp => 0);         Put("   (-x) ** p ");         Put(Item => (- fvalue) ** power, fore => 4, Aft => 1, Exp => 0);         Put("   -(x ** p) ");         Put(Item => -(fvalue ** power), fore => 4, Aft => 1, Exp => 0);         New_line;      end loop;      ivalue := 5;      fvalue := 5.0;   end loop;end Main;  `
Output:
```Integer exponentiation:
x =-5 p = 2   -x ** p  -25   -(x) ** p  -25   (-x) ** p   25   -(x ** p)  -25
x =-5 p = 3   -x ** p  125   -(x) ** p  125   (-x) ** p  125   -(x ** p)  125
x = 5 p = 2   -x ** p  -25   -(x) ** p  -25   (-x) ** p   25   -(x ** p)  -25
x = 5 p = 3   -x ** p -125   -(x) ** p -125   (-x) ** p -125   -(x ** p) -125
floating point exponentiation:
x =-5.00000E+00 p = 2   -x ** p  -25.0   -(x) ** p  -25.0   (-x) ** p   25.0   -(x ** p)  -25.0
x =-5.00000E+00 p = 3   -x ** p  125.0   -(x) ** p  125.0   (-x) ** p  125.0   -(x ** p)  125.0
x = 5.00000E+00 p = 2   -x ** p  -25.0   -(x) ** p  -25.0   (-x) ** p   25.0   -(x ** p)  -25.0
x = 5.00000E+00 p = 3   -x ** p -125.0   -(x) ** p -125.0   (-x) ** p -125.0   -(x ** p) -125.0
```

## ALGOL 68

In Algol 68, all unary operators have a higher precedence than any binary operator.
Algol 68 also allows UP and ^ for the exponentiation operator.

`BEGIN    # show the results of exponentiation and unary minus in various combinations #    FOR x FROM -5 BY 10 TO 5 DO        FOR p FROM 2 TO 3 DO            print( ( "x = ", whole( x, -2 ), " p = ", whole( p, 0 ) ) );            print( ( "     -x**p  ", whole(   -x**p,  -4 ) ) );            print( ( "   -(x)**p  ", whole( -(x)**p,  -4 ) ) );            print( ( "   (-x)**p  ", whole( (-x)**p,  -4 ) ) );            print( ( "    -(x**p) ", whole(  -(x**p), -4 ) ) );            print( ( newline ) )        OD    ODEND`
Output:
```x = -5 p = 2     -x**p    25   -(x)**p    25   (-x)**p    25    -(x**p)  -25
x = -5 p = 3     -x**p   125   -(x)**p   125   (-x)**p   125    -(x**p)  125
x =  5 p = 2     -x**p    25   -(x)**p    25   (-x)**p    25    -(x**p)  -25
x =  5 p = 3     -x**p  -125   -(x)**p  -125   (-x)**p  -125    -(x**p) -125
```

## AWK

` # syntax: GAWK -f EXPONENTIATION_WITH_INFIX_OPERATORS_IN_OR_OPERATING_ON_THE_BASE.AWK# converted from FreeBASICBEGIN {    print("  x   p |     -x^p   -(x)^p   (-x)^p   -(x^p)")    print("--------+------------------------------------")    for (x=-5; x<=5; x+=10) {      for (p=2; p<=3; p++) {        printf("%3d %3d | %8d %8d %8d %8d\n",x,p,(-x^p),(-(x)^p),((-x)^p),(-(x^p)))      }    }    exit(0)} `
Output:
```  x   p |     -x^p   -(x)^p   (-x)^p   -(x^p)
--------+------------------------------------
-5   2 |      -25      -25       25      -25
-5   3 |      125      125      125      125
5   2 |      -25      -25       25      -25
5   3 |     -125     -125     -125     -125
```

## 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)) `
Output:
```-5.0**2.0=25.000000; -(5.0**2.0)=-25.000000
```

## Factor

`USING: infix locals prettyprint sequencessequences.generalizations sequences.repeating ; :: row ( x p -- seq )    x p "-x**p" [infix -x**p infix]    "-(x)**p" [infix -(x)**p infix]    "(-x)**p" [infix (-x)**p infix]    "-(x**p)" [infix -(x**p) infix] 10 narray ; { "x value" "p value" } { "expression" "result" } 8 cycle append-5 2 row-5 3 row5 2 row5 3 row5 narray simple-table.`
Output:
```x value p value expression result expression result expression result expression result
-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
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
```

## FreeBASIC

`print "     x     p    |     -x^p      -(x)^p      (-x)^p    -(x^p)"print "----------------+---------------------------------------------"for x as integer = -5 to 5 step 10     for p as integer = 2 to 3          print using "    ##    ##    |    ####       ####       ####       ####";_               x;p;(-x^p);(-(x)^p);((-x)^p);(-(x^p))     next pnext x`
Output:
```
x     p    |     -x^p      -(x)^p      (-x)^p    -(x^p)

----------------+---------------------------------------------

-5     2    |     -25        -25         25        -25
-5     3    |     125        125        125        125
5     2    |     -25        -25         25        -25
5     3    |    -125       -125       -125       -125

```

## Go

Go uses the math.Pow function for exponentiation and doesn't support operator overloading at all. Consequently, it is not possible to conjure up an infix operator to do the same job.

Perhaps the closest we can get is to define a derived type (float say) based on float64 and then give it a method with a short name (p say) to provide exponentiation.

This looks odd but is perfectly workable as the following example shows. However, as a method call, x.p is always going to take precedence over the unary minus operator and will always require the exponent to be enclosed in parentheses.

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.

`package main import (    "fmt"    "math") type float float64 func (f float) p(e float) float { return float(math.Pow(float64(f), float64(e))) } func main() {    ops := []string{"-x.p(e)", "-(x).p(e)", "(-x).p(e)", "-(x.p(e))"}    for _, x := range []float{float(-5), float(5)} {        for _, e := range []float{float(2), float(3)} {            fmt.Printf("x = %2.0f e = %0.0f | ", x, e)            fmt.Printf("%s = %4.0f | ", ops[0], -x.p(e))            fmt.Printf("%s = %4.0f | ", ops[1], -(x).p(e))            fmt.Printf("%s = %4.0f | ", ops[2], (-x).p(e))            fmt.Printf("%s = %4.0f\n", ops[3], -(x.p(e)))        }    }}`
Output:
```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
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
```

`--https://wiki.haskell.org/Power_functionmain = do    print [-5^2,-(5)^2,(-5)^2,-(5^2)] --Integer    print [-5^^2,-(5)^^2,(-5)^^2,-(5^^2)] --Fractional     print [-5**2,-(5)**2,(-5)**2,-(5**2)] --Real    print [-5^3,-(5)^3,(-5)^3,-(5^3)] --Integer    print [-5^^3,-(5)^^3,(-5)^^3,-(5^^3)] --Fractional    print [-5**3,-(5)**3,(-5)**3,-(5**3)] --Real`
Output:
```[-25,-25,25,-25]
[-25.0,-25.0,25.0,-25.0]
[-25.0,-25.0,25.0,-25.0]
[-125,-125,-125,-125]
[-125.0,-125.0,-125.0,-125.0]
[-125.0,-125.0,-125.0,-125.0]```

## J

APLs use a negative sign distinguished from minus as a different character. Underscore followed by a number specifies a negative number. APLs also process the operations from right to left, evaluating parenthesized expressions when the interpreter comes to them. In J, unary plus returns complex conjugate, which won't affect the outcome of this experiment.

```   format=: ''&\$: :([: ; (a: , [: ":&.> [) ,. '{}' ([ (E. <@}.;._1 ]) ,) ])
S=: 'x = {} p = {}     -x^p    {}   -(x)^p    {}   (-x)^p    {}    -(x^p)  {}'

explicit=: dyad def 'S format~ 2 2 4 4 4 4 ":&> x,y,(-x^y),(-(x)^y),((-x)^y),(-(x^y))'
tacit=:              S format~ 2 2 4 4 4 4 ":&> [`]`([:-^)`([:-^)`((^~-)~)`([:-^)`:0

_2 explicit/\_5 2 _5 3 5 2 5 3
x = _5   p =  2       -x^p     _25   -(x)^p     _25   (-x)^p      25    -(x^p)   _25
x = _5   p =  3       -x^p     125   -(x)^p     125   (-x)^p     125    -(x^p)   125
x =  5   p =  2       -x^p     _25   -(x)^p     _25   (-x)^p      25    -(x^p)   _25
x =  5   p =  3       -x^p    _125   -(x)^p    _125   (-x)^p    _125    -(x^p)  _125

-:/ 1 0 2 |: _2(tacit ,: explicit)/\_5 2 _5 3 5 2 5 3  NB. the verbs produce matching results
1
```

## Julia

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 `
Output:
```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
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
```

## Lua

Lua < 5.3 has a single double-precision numeric type. Lua >= 5.3 adds an integer numeric type. "^" is supported as an infix exponentiation operator for both types.

`mathtype = math.type or type -- polyfill <5.3function test(xs, ps)  for _,x in ipairs(xs) do    for _,p in ipairs(ps) do      print(string.format("%2.f  %7s  %2.f  %7s    %4.f    %4.f    %4.f    %4.f", x, mathtype(x), p, mathtype(p), -x^p, -(x)^p, (-x)^p, -(x^p)))    end  endendprint(" x  type(x)   p  type(p)    -x^p  -(x)^p  (-x)^p  -(x^p)")print("--  -------  --  -------  ------  ------  ------  ------")test( {-5.,5.}, {2.,3.} ) -- "float" (or "number" if <5.3)if math.type then -- if >=5.3  test( {-5,5}, {2,3} ) -- "integer"end`
Output:
``` x  type(x)   p  type(p)    -x^p  -(x)^p  (-x)^p  -(x^p)
--  -------  --  -------  ------  ------  ------  ------
-5    float   2    float     -25     -25      25     -25
-5    float   3    float     125     125     125     125
5    float   2    float     -25     -25      25     -25
5    float   3    float    -125    -125    -125    -125
-5  integer   2  integer     -25     -25      25     -25
-5  integer   3  integer     125     125     125     125
5  integer   2  integer     -25     -25      25     -25
5  integer   3  integer    -125    -125    -125    -125```

## Maple

`[-5**2,-(5)**2,(-5)**2,-(5**2)];                      [-25, -25, 25, -25] [-5**3,-(5)**3,(-5)**3,-(5**3)];                    [-125, -125, -125, -125]`

## Mathematica / Wolfram Language

`{-5^2, -(5)^2, (-5)^2, -(5^2)}{-5^3, -(5)^3, (-5)^3, -(5^3)}`
Output:
```{-25, -25, 25, -25}
{-125, -125, -125, -125}```

## Nim

The infix exponentiation operator is defined in standard module “math”. Its precedence is less than that of unary “-” operator, so -5^2 is 25 and -(5^2) is -25.

`import math, strformat for x in [-5, 5]:  for p in [2, 3]:    echo &"x is {x:2}, ", &"p is {p:1}, ",         &"-x^p is {-x^p:4}, ", &"-(x)^p is {-(x)^p:4}, ",         &"(-x)^p is {(-x)^p:4}, ", &"-(x^p) is {-(x^p):4}"`
Output:
```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
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```

## Perl

Use the module Sub::Infix to define a custom operator. Note that the bracketing punctuation controls the precedence level. Results structured same as in Raku example.

`use strict;use warnings;use Sub::Infix; BEGIN { *e = infix { \$_[0] ** \$_[1] } }; # operator needs to be defined at compile time my @eqns = ('1 + -\$xOP\$p', '1 + (-\$x)OP\$p', '1 + (-(\$x)OP\$p)', '(1 + -\$x)OP\$p', '1 + -(\$xOP\$p)'); for my \$op ('**', '/e/', '|e|') {    for ( [-5, 2], [-5, 3], [5, 2], [5, 3] ) {        my( \$x, \$p, \$eqn ) = @\$_;        printf 'x: %2d p: %2d |', \$x, \$p;        \$eqn = s/OP/\$op/gr and printf '%17s %4d |', \$eqn, eval \$eqn for @eqns;        print "\n";    }    print "\n";}`
Output:
```x: -5 p:  2 |      1 + -\$x**\$p  -24 |    1 + (-\$x)**\$p   26 |  1 + (-(\$x)**\$p)  -24 |    (1 + -\$x)**\$p   36 |    1 + -(\$x**\$p)  -24 |
x: -5 p:  3 |      1 + -\$x**\$p  126 |    1 + (-\$x)**\$p  126 |  1 + (-(\$x)**\$p)  126 |    (1 + -\$x)**\$p  216 |    1 + -(\$x**\$p)  126 |
x:  5 p:  2 |      1 + -\$x**\$p  -24 |    1 + (-\$x)**\$p   26 |  1 + (-(\$x)**\$p)  -24 |    (1 + -\$x)**\$p   16 |    1 + -(\$x**\$p)  -24 |
x:  5 p:  3 |      1 + -\$x**\$p -124 |    1 + (-\$x)**\$p -124 |  1 + (-(\$x)**\$p) -124 |    (1 + -\$x)**\$p  -64 |    1 + -(\$x**\$p) -124 |

x: -5 p:  2 |     1 + -\$x/e/\$p   26 |   1 + (-\$x)/e/\$p   26 | 1 + (-(\$x)/e/\$p)   26 |   (1 + -\$x)/e/\$p   36 |   1 + -(\$x/e/\$p)  -24 |
x: -5 p:  3 |     1 + -\$x/e/\$p  126 |   1 + (-\$x)/e/\$p  126 | 1 + (-(\$x)/e/\$p)  126 |   (1 + -\$x)/e/\$p  216 |   1 + -(\$x/e/\$p)  126 |
x:  5 p:  2 |     1 + -\$x/e/\$p   26 |   1 + (-\$x)/e/\$p   26 | 1 + (-(\$x)/e/\$p)   26 |   (1 + -\$x)/e/\$p   16 |   1 + -(\$x/e/\$p)  -24 |
x:  5 p:  3 |     1 + -\$x/e/\$p -124 |   1 + (-\$x)/e/\$p -124 | 1 + (-(\$x)/e/\$p) -124 |   (1 + -\$x)/e/\$p  -64 |   1 + -(\$x/e/\$p) -124 |

x: -5 p:  2 |     1 + -\$x|e|\$p   36 |   1 + (-\$x)|e|\$p   36 | 1 + (-(\$x)|e|\$p)   26 |   (1 + -\$x)|e|\$p   36 |   1 + -(\$x|e|\$p)  -24 |
x: -5 p:  3 |     1 + -\$x|e|\$p  216 |   1 + (-\$x)|e|\$p  216 | 1 + (-(\$x)|e|\$p)  126 |   (1 + -\$x)|e|\$p  216 |   1 + -(\$x|e|\$p)  126 |
x:  5 p:  2 |     1 + -\$x|e|\$p   16 |   1 + (-\$x)|e|\$p   16 | 1 + (-(\$x)|e|\$p)   26 |   (1 + -\$x)|e|\$p   16 |   1 + -(\$x|e|\$p)  -24 |
x:  5 p:  3 |     1 + -\$x|e|\$p  -64 |   1 + (-\$x)|e|\$p  -64 | 1 + (-(\$x)|e|\$p) -124 |   (1 + -\$x)|e|\$p  -64 |   1 + -(\$x|e|\$p) -124 |```

## Phix

Library: Phix/basics

Phix has a power() function instead of an infix operator, hence there are only two possible syntaxes, with the obvious outcomes.
(Like Go, Phix does not support operator overloading or definition at all.)

```for x=-5 to 5 by 10 do
for p=2 to 3 do
printf(1,"x = %2d, p = %d, power(-x,p) = %4d, -power(x,p) = %4d\n",{x,p,power(-x,p),-power(x,p)})
end for
end for
```
Output:
```x = -5, p = 2, power(-x,p) =   25, -power(x,p) =  -25
x = -5, p = 3, power(-x,p) =  125, -power(x,p) =  125
x =  5, p = 2, power(-x,p) =   25, -power(x,p) =  -25
x =  5, p = 3, power(-x,p) = -125, -power(x,p) = -125
```

## QB64

`For x = -5 To 5 Step 10    For p = 2 To 3        Print "x = "; x; " p ="; p; "   ";        Print Using "-x^p is ####"; -x ^ p;        Print Using ", -(x)^p is ####"; -(x) ^ p;        Print Using ", (-x)^p is ####"; (-x) ^ p;        Print Using ", -(x^p) is ####"; -(x ^ p)    NextNext`
Output:
```x = -5  p = 2    -x^p is  -25, -(x)^p is  -25, (-x)^p is   25, -(x^p) is  -25
x = -5  p = 3    -x^p is  125, -(x)^p is  125, (-x)^p is  125, -(x^p) is  125
x =  5  p = 2    -x^p is  -25, -(x)^p is  -25, (-x)^p is   25, -(x^p) is  -25
x =  5  p = 3    -x^p is -125, -(x)^p is -125, (-x)^p is -125, -(x^p) is -125
```

## R

`expressions <- alist(-x ^ p, -(x) ^ p, (-x) ^ p, -(x ^ p))x <- c(-5, -5, 5, 5)p <- c(2, 3, 2, 3)output <- data.frame(x,                     p,                     setNames(lapply(expressions, eval), sapply(expressions, deparse)),                     check.names = FALSE)print(output, row.names = FALSE)`
Output:
```  x p -x^p -(x)^p (-x)^p -(x^p)
-5 2  -25    -25     25    -25
-5 3  125    125    125    125
5 2  -25    -25     25    -25
5 3 -125   -125   -125   -125```

## Raku

In Raku by default, infix exponentiation binds tighter than unary negation. It is trivial however to define your own infix operators with whatever precedence level meets the needs of your program.

A slight departure from the task specs. Use `1 + {expression}` rather than just `{expression}` to better demonstrate the relative precedence levels. Where `{expression}` is one of:

• `-x{exponential operator}p`
• `-(x){exponential operator}p`
• `((-x){exponential operator}p)`
• `-(x{exponential operator}p)`

Also add a different grouping: `(1 + -x){exponential operator}p`

`sub infix:<↑> is looser(&prefix:<->) { \$^a ** \$^b }sub infix:<^> is looser(&infix:<->)  { \$^a ** \$^b } use MONKEY; for 'Default precedence: infix exponentiation is tighter (higher) precedence than unary negation.',    ('1 + -\$x**\$p', '1 + (-\$x)**\$p', '1 + (-(\$x)**\$p)', '(1 + -\$x)**\$p', '1 + -(\$x**\$p)'),     "\nEasily modified: custom loose infix exponentiation is looser (lower) precedence than unary negation.",    ('1 + -\$x↑\$p ', '1 + (-\$x)↑\$p ', '1 + (-(\$x)↑\$p) ', '(1 + -\$x)↑\$p ', '1 + -(\$x↑\$p) '),     "\nEven moreso: custom looser infix exponentiation is looser (lower) precedence than infix subtraction.",    ('1 + -\$x^\$p ', '1 + (-\$x)^\$p ', '1 + (-(\$x)^\$p) ', '(1 + -\$x)^\$p ', '1 + -(\$x^\$p) ')    -> \$message, \$ops {    say \$message;    for -5, 5 X 2, 3 -> (\$x, \$p) {        printf "x = %2d  p = %d", \$x, \$p;        -> \$op { printf " │ %s = %4d", \$op, EVAL \$op } for |\$ops;        print "\n";    }}`
Output:
```Default precedence: infix exponentiation is tighter (higher) precedence than unary negation.
x = -5  p = 2 │ 1 + -\$x**\$p =  -24 │ 1 + (-\$x)**\$p =   26 │ 1 + (-(\$x)**\$p) =  -24 │ (1 + -\$x)**\$p =   36 │ 1 + -(\$x**\$p) =  -24
x = -5  p = 3 │ 1 + -\$x**\$p =  126 │ 1 + (-\$x)**\$p =  126 │ 1 + (-(\$x)**\$p) =  126 │ (1 + -\$x)**\$p =  216 │ 1 + -(\$x**\$p) =  126
x =  5  p = 2 │ 1 + -\$x**\$p =  -24 │ 1 + (-\$x)**\$p =   26 │ 1 + (-(\$x)**\$p) =  -24 │ (1 + -\$x)**\$p =   16 │ 1 + -(\$x**\$p) =  -24
x =  5  p = 3 │ 1 + -\$x**\$p = -124 │ 1 + (-\$x)**\$p = -124 │ 1 + (-(\$x)**\$p) = -124 │ (1 + -\$x)**\$p =  -64 │ 1 + -(\$x**\$p) = -124

Easily modified: custom loose infix exponentiation is looser (lower) precedence than unary negation.
x = -5  p = 2 │ 1 + -\$x↑\$p  =   26 │ 1 + (-\$x)↑\$p  =   26 │ 1 + (-(\$x)↑\$p)  =   26 │ (1 + -\$x)↑\$p  =   36 │ 1 + -(\$x↑\$p)  =  -24
x = -5  p = 3 │ 1 + -\$x↑\$p  =  126 │ 1 + (-\$x)↑\$p  =  126 │ 1 + (-(\$x)↑\$p)  =  126 │ (1 + -\$x)↑\$p  =  216 │ 1 + -(\$x↑\$p)  =  126
x =  5  p = 2 │ 1 + -\$x↑\$p  =   26 │ 1 + (-\$x)↑\$p  =   26 │ 1 + (-(\$x)↑\$p)  =   26 │ (1 + -\$x)↑\$p  =   16 │ 1 + -(\$x↑\$p)  =  -24
x =  5  p = 3 │ 1 + -\$x↑\$p  = -124 │ 1 + (-\$x)↑\$p  = -124 │ 1 + (-(\$x)↑\$p)  = -124 │ (1 + -\$x)↑\$p  =  -64 │ 1 + -(\$x↑\$p)  = -124

Even moreso: custom looser infix exponentiation is looser (lower) precedence than infix subtraction.
x = -5  p = 2 │ 1 + -\$x^\$p  =   36 │ 1 + (-\$x)^\$p  =   36 │ 1 + (-(\$x)^\$p)  =   26 │ (1 + -\$x)^\$p  =   36 │ 1 + -(\$x^\$p)  =  -24
x = -5  p = 3 │ 1 + -\$x^\$p  =  216 │ 1 + (-\$x)^\$p  =  216 │ 1 + (-(\$x)^\$p)  =  126 │ (1 + -\$x)^\$p  =  216 │ 1 + -(\$x^\$p)  =  126
x =  5  p = 2 │ 1 + -\$x^\$p  =   16 │ 1 + (-\$x)^\$p  =   16 │ 1 + (-(\$x)^\$p)  =   26 │ (1 + -\$x)^\$p  =   16 │ 1 + -(\$x^\$p)  =  -24
x =  5  p = 3 │ 1 + -\$x^\$p  =  -64 │ 1 + (-\$x)^\$p  =  -64 │ 1 + (-(\$x)^\$p)  = -124 │ (1 + -\$x)^\$p  =  -64 │ 1 + -(\$x^\$p)  = -124```

## REXX

`/*REXX program shows exponentition with an  infix operator  (implied and/or specified).*/_= '─';   ! = '║';   mJunct= '─╫─';   bJunct= '─╨─'       /*define some special glyphs. */ say @('  x  ', 5)  @("  p  ", 5)        !say @('value', 5)  @("value", 5) copies(!        @('expression',10)  @("result",6)" ",  4)say @(''  , 5, _)  @("",   5, _)copies(mJunct || @('',       10, _)  @("",   6, _)   ,  4)    do    x=-5  to 5  by 10                       /*assign   -5    and    5    to    X.  */      do p= 2  to 3                              /*assign    2    and    3    to    P.  */                            a =  -x**p ;   b =  -(x)**p ;   c =  (-x)**p ;   d =  -(x**p)                           ae= '-x**p';   be= "-(x)**p";   ce= '(-x)**p';   de= "-(x**p)"      say @(x,5)  @(p,5) ! @(ae, 10)    right(a, 5)" " ,                         ! @(be, 10)    right(b, 5)" " ,                         ! @(ce, 10)    right(c, 5)" " ,                         ! @(de, 10)    right(d, 5)      end   /*p*/   end      /*x*/ say @(''  , 5, _)  @('',   5, _)copies(bJunct || @('',       10, _)  @('',   6, _)   ,  4)exit 0                                           /*stick a fork in it,  we're all done. *//*──────────────────────────────────────────────────────────────────────────────────────*/@:    parse arg txt, w, fill;  if fill==''  then fill= ' ';   return center( txt, w, fill) `
output   when using the internal default input:
```  x     p   ║
value value ║ expression result ║ expression result ║ expression result ║ expression result
───── ──────╫─────────── ───────╫─────────── ───────╫─────────── ───────╫─────────── ──────
-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
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
───── ──────╨─────────── ───────╨─────────── ───────╨─────────── ───────╨─────────── ──────
```

## Ruby

`nums = [-5, 5]pows = [2, 3]nums.product(pows) do |x, p|  puts "x = #{x} p = #{p}\t-x**p #{-x**p}\t-(x)**p  #{-(x)**p}\t(-x)**p #{ (-x)**p}\t-(x**p)  #{-(x**p)}"end `
Output:
```x = -5 p = 2	-x**p -25	-(x)**p  -25	(-x)**p 25	-(x**p)  -25
x = -5 p = 3	-x**p 125	-(x)**p  125	(-x)**p 125	-(x**p)  125
x = 5 p = 2	-x**p -25	-(x)**p  -25	(-x)**p 25	-(x**p)  -25
x = 5 p = 3	-x**p -125	-(x)**p  -125	(-x)**p -125	-(x**p)  -125
```

## Python

`from itertools import product xx = '-5 +5'.split()pp = '2 3'.split()texts = '-x**p -(x)**p (-x)**p -(x**p)'.split() print('Integer variable exponentiation')for x, p in product(xx, pp):    print(f'  x,p = {x:2},{p}; ', end=' ')    x, p = int(x), int(p)    print('; '.join(f"{t} =={eval(t):4}" for t in texts)) print('\nBonus integer literal exponentiation')X, P = 'xp'xx.insert(0, ' 5')texts.insert(0, 'x**p')for x, p in product(xx, pp):    texts2 = [t.replace(X, x).replace(P, p) for t in texts]    print(' ', '; '.join(f"{t2} =={eval(t2):4}" for t2 in texts2))`
Output:
```Integer variable exponentiation
x,p = -5,2;  -x**p == -25; -(x)**p == -25; (-x)**p ==  25; -(x**p) == -25
x,p = -5,3;  -x**p == 125; -(x)**p == 125; (-x)**p == 125; -(x**p) == 125
x,p = +5,2;  -x**p == -25; -(x)**p == -25; (-x)**p ==  25; -(x**p) == -25
x,p = +5,3;  -x**p ==-125; -(x)**p ==-125; (-x)**p ==-125; -(x**p) ==-125

Bonus integer literal exponentiation
5**2 ==  25; - 5**2 == -25; -( 5)**2 == -25; (- 5)**2 ==  25; -( 5**2) == -25
5**3 == 125; - 5**3 ==-125; -( 5)**3 ==-125; (- 5)**3 ==-125; -( 5**3) ==-125
-5**2 == -25; --5**2 ==  25; -(-5)**2 == -25; (--5)**2 ==  25; -(-5**2) ==  25
-5**3 ==-125; --5**3 == 125; -(-5)**3 == 125; (--5)**3 == 125; -(-5**3) == 125
+5**2 ==  25; -+5**2 == -25; -(+5)**2 == -25; (-+5)**2 ==  25; -(+5**2) == -25
+5**3 == 125; -+5**3 ==-125; -(+5)**3 ==-125; (-+5)**3 ==-125; -(+5**3) ==-125```

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

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

Using the "negated" message:

`Transcript show:'5 negated**2 => '; showCR: 5 negated**2. "negates 5"Transcript show:'5 negated**3 => '; showCR: 5 negated**3.Transcript show:'5**2 negated => '; showCR: 5**2 negated. "negates 2"Transcript show:'5**3 negated => '; showCR: 5**3 negated. "negates 3"Transcript show:'5 negated**a => '; showCR: 5 negated**a. Transcript show:'5 negated**b => '; showCR: 5 negated**b.Transcript show:'5**a negated => '; showCR: 5**a negated. Transcript show:'5**b negated => '; showCR: 5**b negated. Transcript show:'(5**a) negated => '; showCR: (5**a) negated. Transcript show:'(5**b) negated => '; showCR: (5**b) negated. Transcript show:'(-5**a) negated => '; showCR: (-5**a) negated. Transcript show:'(-5**b) negated => '; showCR: (-5**b) negated. Transcript show:'-5 negated**2 => '; showCR: -5 negated**2. "negates the negative 5"Transcript show:'-5 negated**3 => '; showCR: -5 negated**3.`
Output:
```-5**2 => 25
-5**a => 25
-5**b => -125
5**2 => 25
5**a => 25
5**b => 125
5 negated**2 => 25
5 negated**3 => -125
5**2 negated => (1/25)
5**3 negated => (1/125)
5 negated**a => 25
5 negated**b => -125
5**a negated => (1/25)
5**b negated => (1/125)
(5**a) negated => -25
(5**b) negated => -125
(-5**a) negated => -25
(-5**b) negated => 125
-5 negated**2 => 25
-5 negated**3 => 125
```

## Wren

Library: Wren-fmt

Wren uses the pow() method for exponentiation of numbers and, whilst it supports operator overloading, there is no way of adding a suitable infix operator to the existing Num class.

Also inheriting from the Num class is not recommended and will probably be banned altogether from the next version.

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.

`import "/fmt" for Fmt class Num2 {    construct new(n) { _n = n }     n { _n}     ^(exp) {        if (exp is Num2) exp = exp.n        return Num2.new(_n.pow(exp))    }     - { Num2.new(-_n) }     toString { _n.toString }} var ops = ["-x^p", "-(x)^p", "(-x)^p", "-(x^p)"]  for (x in [Num2.new(-5), Num2.new(5)]) {    for (p in [Num2.new(2), Num2.new(3)]) {        Fmt.write("x = \$2s p = \$s | ", x, p)        Fmt.write("\$s = \$4s | ", ops[0], -x^p)        Fmt.write("\$s = \$4s | ", ops[1], -(x)^p)        Fmt.write("\$s = \$4s | ", ops[2], (-x)^p)        Fmt.print("\$s = \$4s",    ops[3], -(x^p))    }}`
Output:
```x = -5 p = 2 | -x^p =   25 | -(x)^p =   25 | (-x)^p =   25 | -(x^p) =  -25
x = -5 p = 3 | -x^p =  125 | -(x)^p =  125 | (-x)^p =  125 | -(x^p) =  125
x =  5 p = 2 | -x^p =   25 | -(x)^p =   25 | (-x)^p =   25 | -(x^p) =  -25
x =  5 p = 3 | -x^p = -125 | -(x)^p = -125 | (-x)^p = -125 | -(x^p) = -125
```