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

</pre>

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

with Ada.Float_Text_IO; use Ada.Float_Text_IO;

with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;

end Main;

 

{{output}}

<pre>

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

OD

OD

{{out}}

<pre>

 

=={{header|AWK}}==

# syntax: GAWK -f EXPONENTIATION_WITH_INFIX_OPERATORS_IN_OR_OPERATING_ON_THE_BASE.AWK

# converted from FreeBASIC

exit(0)

}

{{out}}

<pre>

 

=={{header|BASIC}}==

==={{header|BASIC256}}===

print ("-"*15); "+"; ("-"*45)

for x = -5 to 5 step 10

print " "; rjust(x,2); " "; ljust(p,2); " | "; rjust((-x^p),6); " "; rjust((-(x)^p),6); (" "*6); rjust(((-x)^p),6); " "; rjust((-(x^p)),6)

next p

{{out}}

<pre> x p | -x^p -(x)^p (-x)^p -(x^p)

 

==={{header|Gambas}}===

 

Print " x p | -x^p -(x)^p (-x)^p -(x^p)"

Next

 

{{out}}

<pre>Same as FreeBASIC entry.</pre>

{{works with|QuickBasic|4.5}}

{{works with|FreeBASIC}}

PRINT "----------------+---------------------------------------------"

FOR x = -5 TO 5 STEP 10

PRINT USING " ## ## | #### #### #### ####"; x; p; (-x ^ p); (-(x) ^ p); ((-x) ^ p); (-(x ^ p))

NEXT p

{{out}}

<pre>Same as FreeBASIC entry.</pre>

{{works with|QBasic}}

{{works with|True BASIC}}

print "----------------------------+-----------------------------------------------------------------"

for x = -5 to 5 step 10

next p

next x

{{out}}

<pre>Similar to FreeBASIC entry.</pre>

 

==={{header|True BASIC}}===

PRINT "----------------+---------------------------------------------"

FOR x = -5 TO 5 STEP 10

NEXT p

NEXT x

{{out}}

<pre>Same as FreeBASIC entry.</pre>

 

==={{header|PureBasic}}===

PrintN(" x p | -x^p -(x)^p (-x)^p -(x^p)")

PrintN("----------------+---------------------------------------")

Next x

Input()

{{out}}

<pre> x p | -x^p -(x)^p (-x)^p -(x^p)

==={{header|XBasic}}===

{{works with|Windows XBasic}}

 

DECLARE FUNCTION Entry ()

NEXT x

END FUNCTION

{{out}}

<pre>Similar to FreeBASIC entry.</pre>

 

==={{header|Yabasic}}===

print "----------------+---------------------------------------------"

for x = -5 to 5 step 10

print " ", x using "##", " ", p using "##", " | ", (-x^p) using "####", " ", (-(x)^p) using "####", " ", ((-x)^p) using "####", " ", (-(x^p)) using "####"

next p

{{out}}

<pre>Same as FreeBASIC entry.</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>

 

=={{header|FreeBASIC}}==

print "----------------+---------------------------------------------"

for x as integer = -5 to 5 step 10

x;p;(-x^p);(-(x)^p);((-x)^p);(-(x^p))

next p

{{out}}<pre>

x p | -x^p -(x)^p (-x)^p -(x^p)

 

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

</pre>

=={{header|Haskell}}==

main = do

print [-5^2,-(5)^2,(-5)^2,-(5^2)] --Integer

print [-5^3,-(5)^3,(-5)^3,-(5^3)] --Integer

print [-5^^3,-(5)^^3,(-5)^^3,-(5^^3)] --Fractional

{{out}}

<pre>[-25,-25,25,-25]

1

</pre>

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

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

function test(xs, ps)

for _,x in ipairs(xs) do

if math.type then -- if >=5.3

test( {-5,5}, {2,3} ) -- "integer"

{{out}}

<pre> x type(x) p type(p) -x^p -(x)^p (-x)^p -(x^p)

=={{header|Maple}}==

 

[-25, -25, 25, -25]

 

[-5**3,-(5)**3,(-5)**3,-(5**3)];

 

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

{{out}}

<pre>{-25, -25, 25, -25}

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.

 

 

for x in [-5, 5]:

echo &"x is {x:2}, ", &"p is {p:1}, ",

&"-x^p is {-x^p:4}, ", &"-(x)^p is {-(x)^p:4}, ",

 

{{out}}

{{works with|Extended Pascal}}

Apart from the built-in (prefix) functions <tt>sqr</tt> (exponent&nbsp;=&nbsp;2) and <tt>sqrt</tt> (exponent&nbsp;=&nbsp;0.5) already defined in Standard “Unextended” Pascal (ISO standard 7185), ''Extended Pascal'' (ISO standard 10206) defines following additional (infix) operators:

 

const

testRealPower(-5E0, 3);

testRealPower(+5E0, 3)

{{out}}

=====> testIntegerPower <=====

=={{header|Perl}}==

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

use warnings;

use Sub::Infix;

}

print "\n";

{{out}}

<pre>x: -5 p: 2 | 1 + -$x**$p -24 | 1 + (-$x)**$p 26 | 1 + (-($x)**$p) -24 | (1 + -$x)**$p 36 | 1 + -($x**$p) -24 |

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

<span style="color: #008080;">for</span> <span style="color: #000000;">x<span style="color: #0000FF;">=<span style="color: #0000FF;">-<span style="color: #000000;">5</span> <span style="color: #008080;">to</span> <span style="color: #000000;">5</span> <span style="color: #008080;">by</span> <span style="color: #000000;">10</span> <span style="color: #008080;">do</span>

<span style="color: #008080;">for</span> <span style="color: #000000;">p<span style="color: #0000FF;">=<span style="color: #000000;">2</span> <span style="color: #008080;">to</span> <span style="color: #000000;">3</span> <span style="color: #008080;">do</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for

{{out}}

<pre>

 

=={{header|QB64}}==

For p = 2 To 3

Print "x = "; x; " p ="; p; " ";

Print Using ", -(x^p) is ####"; -(x ^ p)

Next

{{out}}

<pre>

</pre>

=={{header|R}}==

x <- c(-5, -5, 5, 5)

p <- c(2, 3, 2, 3)

setNames(lapply(expressions, eval), sapply(expressions, deparse)),

check.names = FALSE)

{{out}}

<pre> x p -x^p -(x)^p (-x)^p -(x^p)

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>

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

</pre>

=={{header|Ruby}}==

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

{{out}}

<pre>x = -5 p = 2 -x**p -25 -(x)**p -25 (-x)**p 25 -(x**p) -25

 

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