Exponentiation operator: Difference between revisions

 

If the language supports operator (or procedure) overloading, then an overloaded form should be provided for both &nbsp; <big>int^int</big> &nbsp; and &nbsp; <big>float^int</big> &nbsp; variants.

 

=={{header|Ada}}==

 

First we declare the specifications of the two procedures and the two corresponding operators (written as functions with quoted operators as their names):

-- int^int

procedure Exponentiate (Argument : in Integer;

function "**" (Left : Float;

Right : Integer) return Float;

 

Now we can create a test program:

 

with Integer_Exponentiation;

 

Put (I, Width => 7);

New_Line;

 

Finally we can implement the procedures and operations:

 

-- int^int

procedure Exponentiate (Argument : in Integer;

return Result;

end "**";

 

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

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny]}}

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - formatted transput used in the test output}}

INT two=2, thirty=30; # test constants #

PROC VOID undefined;

printf(($" One Gibi-unit is: "g(0,1)"**"g(0,1)"="g(0,1)" - (cost: "

"depends on precision)"l$, 2.0, 30.0, 2.0 ** 30.0))

{{out}}

<pre>One Gibi-unit is: int pow(2,30)=1073741824 - (cost: 29 INT multiplications)

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny]}}

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - formatted transput used in the test output}}

INT two=2, thirty=30; # test constants #

PROC VOID undefined;

printf(($" One Gibi-unit is: "g(0,1)"**"g(0,1)"="g(0,1)" - (cost: "

"depends on precision)"l$, 2.0, 30.0, 2.0 ** 30.0))

{{out}}

<pre>

One Gibi-unit is: 2.0**30.0=1073741824.0 - (cost: depends on precision)

</pre>

 

=={{header|AutoHotkey}}==

MsgBox % Pow(2.5,4)

 

r *= x

return r

 

=={{header|AWK}}==

Traditional awk implementations do not provide an exponent operator, so we define a function to calculate the exponent.

This one-liner reads base and exponent from stdin, one pair per line, and writes the result to stdout:

 

{{out}}

</pre>

 

$ gawk -M '{ printf("%f\n",$1^$2) }'

 

{{out}}

</pre>

 

$ gawk -N '{ printf("%f\n",$1^$2) }'

 

{{out}}

The vast majority of BASIC implementations don't support defining custom operators, or overloading of any kind.

 

DECLARE FUNCTION powS# (x AS SINGLE, y AS INTEGER)

 

END IF

powS# = m

 

{{out}}

9.712946 2 94.34131879665438

</pre>

 

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

PRINT "PI^3 = " ; FNfpow(PI, 3)

END

B% = B% << 1

NEXT

{{out}}

<pre>11^5 = 161051

 

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

110 IF X=0 THEN LET POW=0:EXIT DEF

120 LET POW=EXP(Y*LOG(X))

130 END DEF

140 PRINT POW(PI,3)

 

=={{header|Befunge}}==

Note: Only works for integer bases and powers.

>&:32p&1-\>32g*\1-:|

$

.

 

=={{header|Brat}}==

exp = { base, exp |

1.to(exp).reduce 1, { m, n | m = m * base }

 

p exp 2 5 #Prints 32

 

=={{header|C}}==

Two versions are given - one for integer bases, the other for floating point. The

integer version returns 0 when the abs(base) is != 1 and the exponent is negative.

#include <assert.h>

 

printf("2.71^6 = %lf\n", dpow(2.71,6));

printf("2.71^-6 = %lf\n", dpow(2.71,-6));

 

The C11 standard features type-generic expressions via the _Generic keyword. We can add to the above example to use this feature.

{{works with|Clang|3.0+}}

#define generic_pow(base, exp)\

_Generic((base),\

printf("2.71^-6 = %lf\n", generic_pow(2.71,-6));

}

 

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

--[[User:LordMike|LordMike]] 17:45, 5 May 2010 (UTC)

 

static void Main(string[] args)

{

return Math.Pow(Val, Pow);

}

 

{{out}}

* whether the result of <tt>a%b</tt> is positive or negative if <tt>a</tt> is negative, and in which direction the corresponding division is rounded (however, it ''is'' guaranteed that <tt>(a/b)*b + a%b == a</tt>)

The code below tries to avoid those platform dependencies. Note that bitwise operations wouldn't help here either, because the representation of negative numbers can vary as well.

Number power(Number base, int exponent)

{

}

return result;

 

=={{header|Chef}}==

=={{header|Clojure}}==

Operators in Clojure are functions, so this satisfies both requirements. Also, this is polymorphic- it will work with integers, floats, etc, even ratios. (Since operators are implemented as functions they are used in prefix notation)

Usage:

<pre>(** 2 3) ; 8

=={{header|Common Lisp}}==

Common Lisp has a few forms of iteration. One of the more general is the do loop. Using the do loop, one definition is given below:

(do ((x 1 (* x a))

(y 0 (+ y 1)))

<tt>do</tt> takes three forms. The first is a list of variable initializers and incrementers. In this case, <tt>x</tt>, the eventual return value, is initialized to 1, and every iteration of the <tt>do</tt> loop replaces the value of <tt>x</tt> with ''x * a''. Similarly, <tt>y</tt> is initialized to 0 and is replaced with ''y + 1''. The second is a list of conditions and return values. In this case, when y = b, the loop stops, and the current value of <tt>x</tt> is returned. Common Lisp has no explicit return keyword, so <tt>x</tt> ends up being the return value for the function. The last form is the body of the loop, and usually consists of some action to perform (that has some side-effect). In this case, all the work is being done by the first and second forms, so there are no extra actions.

 

Of course, Lisp programmers often prefer recursive solutions.

(cond

((= b 0) 1)

This solution uses the fact that a^0 = 1 and that a^b = a * a^{b-1}. <tt>cond</tt> is essentially a generalized if-statement. It takes a list of forms of the form (''cond'' ''result''). For instance, in this case, if b = 0, then function returns 1. ''t'' is the truth constant in Common Lisp and is often used as a default condition (similar to the <tt>default</tt> keyword in C/C++/Java or the <tt>else</tt> block in many languages).

 

Common Lisp has much more lenient rules for identifiers. In particular, <tt>^</tt> is a valid CL identifier. Since it is not already defined in the standard library, we can simply use it as a function name, just like any other function.

(do ((x 1 (* x a))

(y 0 (+ y 1)))

 

=={{header|D}}==

 

D has a built-in exponentiation operator: ^^

 

struct Number(T) {

writeln(Int(3) ^^ 3);

writeln(Int(0) ^^ -2); // Division by zero.

{{out}}

(Compiled in debug mode, stack trace removed)

27

opBinary</pre>

 

=={{header|E}}==

Simple, unoptimized implementation which will accept any kind of number for the base. If the base is an <code>int</code>, then the result will be of type <code>float64</code> if the exponent is negative, and <code>int</code> otherwise.

 

var r := base

if (exponent < 0) {

}

return r

 

=={{header|EchoLisp}}==

;; this exponentiation function handles integer, rational or float x.

;; n is a positive or negative integer.

38540524895511613165266748863173814985473295063157418576769816295283207864908351682948692085553606681763707358759878656

 

 

=={{header|Ela}}==

Ela standard prelude already defines an exponentiation operator (**) but we will implement it by ourselves anyway:

 

 

_ ^ 0 = 1

| else = f b (i - 1) (b * y)

 

 

{{out}}

and make it generic:

 

 

//Function quot from number module is defined only for

 

 

 

{{out}}

work with overloading (less preferable in this case because of more redundant code but still possible):

 

 

//A class that defines our overloadable function

| else = f b (i - 1) (b * y)

 

 

{{out}}

 

=={{header|Elixir}}==

def exp(x,y) when is_integer(x) and is_integer(y) and y>=0 do

IO.write("int> ") # debug test

spow = inspect :math.pow(x,y) # For the comparison

:io.fwrite("~10s = ~12s, ~12s~n", [sxy, sexp, spow])

 

{{out}}

 

pow(number, integer) -> number

pow(X, Y) when Y < 0 ->

1/pow(X, -Y);

B2 = if Y rem 2 =:= 0 -> B; true -> X * B end,

pow(X * X, Y div 2, B2).

 

Tail call optimised version which works for both integers and float bases.

handles *integer powers*: for floating point exponent you must use EXP and LOG predefined

functions.

 

PROCEDURE POWER(A,B->POW) ! this routine handles only *INTEGER* powers

POWER(11,-2->POW) PRINT(POW)

POWER(π,3->POW) PRINT(POW)

{{out}}

<pre> 8.264463E-03

 

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

//Integer Exponentiation, more interesting anyway than repeated multiplication. Nigel Galloway, October 12th., 2018

let rec myExp n g=match g with

 

printfn "%d" (myExp 3 15)

{{out}}

<pre>

14348907

</pre>

=={{header|Factor}}==

Simple, unoptimized implementation which accepts a positive or negative exponent:

dup 0 < [ abs pow recip ]

 

Here is a recursive implementation which splits the exponent in two:

{

{ [ dup 0 < ] [ abs pow recip ] }

{ [ dup 0 = ] [ 2drop 1 ] }

[ [ 2 mod 1 = swap 1 ? ] [ [ sq ] [ 2 /i ] bi* pow ] 2bi * ]

 

This implementation recurses only when an odd factor is found:

IN: test

 

{ [ dup 0 = ] [ 2drop 1 ] }

[ (pow) ]

 

A non-recursive version of (pow) can be written as:

[ 1 ] 2dip

[ dup 1 = ] [

dup even? [ [ sq ] [ 2 /i ] bi* ] [ [ [ * ] keep ] dip 1 - ] if

] until

 

=={{header|Forth}}==

 

dup 0= if

drop fdrop 1e

else

2/ fdup f* recurse

 

=={{header|Fortran}}==

{{works with|Fortran|90 and later}}

IMPLICIT NONE

 

USE Exp_Mod

WRITE(*,*) 2.pow.30, 2.0.pow.30

{{out}}

<pre>

 

=={{header|FreeBASIC}}==

 

' Note that 'base' is a keyword in FB, so we use 'base_' instead as a parameter

Print

Print "Press any key to quit"

 

{{out}}

1.78 ^ 3 = 5.639752000000001

</pre>

 

=={{header|GAP}}==

local p;

p := one;

List([0 .. 31], n -> (1 - expon(0, n, 1, \-))/2);

# [ 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,

 

=={{header|Go}}==

Go doesn't support operator defintion. Other notes: While I left the integer algorithm simple, I used the shift and square trick for the float algorithm, just to show an alternative.

 

import (

tf(10, -39)

tf(-10, 39)

{{out}}

<pre>

=={{header|Haskell}}==

Here's the exponentiation operator from the Prelude:

_ ^ 0 = 1

x ^ n | n > 0 = f x (n-1) x where

g b i | even i = g (b*b) (i `quot` 2)

| otherwise = f b (i-1) (b*y)

 

There's no difference in Haskell between a procedure (or function) and an operator, other than the infix notation. This routine is overloaded for any integral exponent (which includes the arbitrarily large ''Integer'' type) and any numeric type for the bases (including, for example, ''Complex''). It uses the fast "binary" exponentiation algorithm. For a negative exponent, the type of the base must support division (and hence reciprocals):

 

 

This rules out e.g. the integer types as base values in this case. Haskell also has a third exponentiation operator,

 

which is used for floating point arithmetic.

 

=={{header|HicEst}}==

WRITE(ClipBoard) pow(5.5, 7) ! 152243.5234

 

pow = pow * x

ENDDO

 

=={{header|Icon}} and {{header|Unicon}}==

The procedure below will take an integer or real base and integer exponent and return base ^ exponent. If exponent is negative, base is coerced to real so as not to return 0. Operator overloading is not supported and this is not an efficient implementation.

bases := [5,5.]

numbers := [0,2,2.,-1,3]

res := op(res,base)

return res

 

=={{header|J}}==

So we have any number of options. Here's the simplest, equivalent to the <code>for each number, product = product * number</code> of other languages. The base may be any number, and the exponent may be any non-negative integer (including zero):

 

10 exp 3

10 exp 0

 

We can make this more general by allowing the exponent to be any integer (including negatives), at the cost of a slight increase in complexity:

 

10 exp _3

 

Or, we can define exponentiation as repeated multiplication (as opposed to multiplying a given number of copies of the base)

 

 

10 exp 3

1000

10 exp _3

 

Here, when we specify a negative number of repetitions, multiplication's inverse is used that many times.

J's calculus of functions permits us to define exponentiation in its full generality, as the '''inverse of log''' (i.e. ''exp = log^-1''):

 

81 exp 0.5

 

Note that the definition above does '''not''' use the primitive exponentiation function <code>^</code> . The carets in it represent different (but related) things . The function is composed of three parts: <code>^. ^: _1</code> . The first part, <code>^.</code>, is the primitive logarithm operator (e.g. <code>3 = 10^.1000</code>) .

Similarly, we can define exponentiation as the reverse of the inverse of root. That is, ''x pow y = y root^-1 x'':

 

81 exp 0.5

 

Compare this with the previous definition: it is the same, except that <code>%:</code> , ''root'', has been substituted for <code>^.</code> , ''logarithm'', and the arguments have been reversed (or ''reflected'') with <code>~</code>.

Let's use Euler's famous formula, ''e^pi*i = -1'' as an example:

 

e =: 2.71828182845904523536

i =: 2 %: _1 NB. Square root of -1

e^(pi*i)

 

And, as stated, our redefinition is equivalent:

 

e exp (pi*i)

 

=={{header|Java}}==

Java does not support operator definition. This example is unoptimized, but will handle negative exponents as well. It is unnecessary to show int^int since an int in Java will be cast as a double.

public static void main(String[] args){

System.out.println(pow(2,30));

return ans;

}

{{out}}

<pre>

 

=={{header|JavaScript}}==

if (exp != Math.floor(exp))

throw "exponent must be an integer";

}

return ans;

 

=={{header|jq}}==

# NOTE: jq converts very large integers to floats.

# This implementation uses reduce to avoid deep recursion

end

else error("This is a toy implementation that requires n be integral")

x | [ power_int(y), (log*y|exp) ] ;

 

[2.4328178969536854e+42, 2.4328178969536693e+42]

[4.1104597317052596e-43, 4.1104597317052874e-43]

 

=={{header|Julia}}==

function pow(base::Number, exp::Integer)

r = one(base)

return r

end

 

{{out}}

=={{header|Kotlin}}==

Kotlin does not have a dedicated exponentiation operator (we would normally use Java's Math.pow method instead) but it's possible to implement integer and floating power exponentiation (with integer exponents) using infix extension functions which look like non-symbolic operators for these actions:

 

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

when {

this == 1 -> 1

exp < 0 -> throw IllegalArgumentException("invalid exponent")

exp == 0 -> 1

var base = this

var e = exp

if (e and 1 == 1) ans *= base

e = e shr 1

base *= base

}

}

}

println("1.5 ^ 0 = ${1.5 dpow 0}")

println("4.5 ^ 2 = ${4.5 dpow 2}")

 

{{out}}

4.5 ^ 2 = 20.25

</pre>

 

=={{header|Liberty BASIC}}==

print " 11^5 = ", floatPow( 11, 5 )

print " (-11)^5 = ", floatPow( -11, 5 )

floatPow =m

end function

 

=={{header|Lingo}}==

Lingo doesn't support user-defined operators.

-- base can be either integer or float; returns float.

on pow (base, exp)

end repeat

return res

 

=={{header|Logo}}==

if equal? 0 :m [output 1]

if equal? 0 modulo :m 2 [output int_power :n*:n :m/2]

output :n * int_power :n :m-1

 

=={{header|Lua}}==

All numbers in Lua are floating point numbers (thus, there are no real integers). Operator overloading is supported for tables only.

 

function number.pow( a, b )

x = number.New( 5 )

print( x^2 ) --> 25

 

=={{header|Lucid}}==

[http://portal.acm.org/citation.cfm?id=947727.947728&coll=GUIDE&dl=GUIDE Some misconceptions about Lucid]

 

k = n fby k div 2;

p = x fby p*p;

y =1 fby if even(k) then y else y*p;

result y asa k eq 0;

 

=={{header|M4}}==

M4 lacks floating point computation and operator definition.

{{out}}

<pre>

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

Define a function and an infix operator \[CirclePlus] with the same definition:

Examples:

exponentiation[4,0]

exponentiation[2.5,-2]

1.23\[CirclePlus]3

4\[CirclePlus]0

gives back:

1

0.16

1.86087

1

Note that \[CirclePlus] shows up as a special character in Mathematica namely a circle divided in 4 pieces. Note also that this function supports negative and positive exponents.

 

=={{header|Maxima}}==

[p: 1],

while n > 0 do (

 

2.5 ^^^ 10;

 

=={{header|МК-61/52}}==

 

=={{header|Modula-2}}==

Whilst some implementations or dialects of Modula-2 may permit definition or overloading of operators, neither is permitted in N.Wirth's classic language definition and the ISO Modula-2 standard. The operations are therefore given as library functions.

(* Library Interface *)

DEFINITION MODULE Exponentiation;

 

END Exponentiation.

 

=={{header|Modula-3}}==

 

IMPORT IO, Fmt;

IO.Put("2 ^ 4 = " & Fmt.Int(IntExpt(2, 4)) & "\n");

IO.Put("2.5 ^ 4 = " & Fmt.Real(RealExpt(2.5, 4)) & "\n");

{{out}}

<pre>

=={{header|Nemerle}}==

Macros can be used to define a new operator:

 

macro @^ (val, pow : int)

{

<[ Math.Pow($val, $pow) ]>

The file with the macro needs to be compiled as a library, and the resulting assembly must be referenced when compiling source files which use the operator.

using System.Console;

using Nemerle.Assertions;

WriteLine($"$eight, $four, $four_d");

}

 

=={{header|Nim}}==

var (base, exp) = (base, exp)

result = 1

echo "2^-6 = ", 2 ^ -6

echo "2.71^6 = ", 2.71^6

 

=={{header|Objeck}}==

function : Main(args : String[]) ~ Nil {

Pow(2,30)->PrintLine();

return ans;

}

 

<pre>1.07374182e+009

used:

 

let rec g p x = function

| 0 -> x

 

See http://en.wikipedia.org/wiki/Thue-Morse_sequence

 

See also [[Matrix-exponentiation operator#OCaml]] for a matrix usage.

This function works either for int or floats :

 

| i |

1 n abs loop: i [ r * ]

2 powint(3) println

1.2 4 powint println

 

{{out}}

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

This version works for integer and floating-point bases (as well as intmod bases, ...).

my(c = 1);

while(b > 1,

);

a * c

 

PARI/GP also has a built-in operator that works for any type of numerical exponent:

 

=={{header|Pascal}}==

 

function intexp (base, exponent: integer): longint;

writeln('2^30: ', intexp(2, 30));

writeln('2.0^30: ', realexp(2.0, 30));

{{out}}

<pre>% ./ExponentiationOperator

 

=={{header|Perl}}==

use strict ;

 

print "5.5 to the power of -3 as a function is " . expon( 5.5 , -3 ) . " !\n" ;

print "5.5 to the power of -3 as a builtin is " . 5.5**-3 . " !\n" ;

{{out}}

<pre>

 

The following version is simpler and much faster for large exponents, since it uses exponentiation by squaring.

my($base,$exp) = @_;

die "Exponent '$exp' must be an integer!" if $exp != int($exp);

}

$base * $c;

 

=={{header|Phix}}==

The builtin power function handles atoms and integers for both arguments, whereas this deliberately restricts the exponent to an integer.<br>

There is no operator overloading in Phix, or for that matter any builtin overriding.

{{out}}

<pre>

=={{header|PicoLisp}}==

This uses Knuth's algorithm (The Art of Computer Programming, Vol. 2, page 442)

(if (ge0 N)

(let Y 1

Y )

(setq X (* X X)) ) )

 

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

(iexp when (fixed, fixed),

fexp when (float, fixed) );

end;

return (exp);

 

=={{header|PowerShell}}==

if ($b -eq -1) { return 1/$a }

if ($b -eq 0) { return 1 }

return $result

}

The function works for both integers and floating-point values as first argument.

 

The negative first argument needs to be put in parentheses because it would otherwise be passed as string.

This can be circumvented by declaring the first argument to the function as <code>double</code>, but then the return type would be always double while currently <code>pow 2 3</code> returns an <code>int</code>.

 

=={{header|Prolog}}==

The predicate <code>is/2</code> supports functional syntax in its second argument: e.g., <code>X is sqrt(2) + 1</code>. New arithmetic functions can be added with the `arithmetic_function/1` directive, wherein the arity attributed to the function is one less than the arity of the predicate which will be called during term expansion and evaluation. The following directives establish <code>^^/2</code> as, first, an arithmetic function, and then as a right-associative binary operator (so that <code>X is 2^^2^^2</code> == ''X = 2^(2^2)</code>):

 

 

When <code>^^/2</code> occurs in an expression in the second argument of <code>is/2</code>, Prolog calls the subsequently defined predicate <code>^^/3</code>, and obtains the operators replacement value from the predicate's third argument.

This solution employs the higher-order predicate <code>foldl/4</code> from the standard SWI-Prolog <code>library(apply)</code>, in conjunction with an auxiliary "folding predicate" (note, the definition uses the <code>^^</code> operator as an arithmetic function):

 

%

% True if Power is Base ^ Exp.

 

exp_folder(Base, Power, Powers, Power) :-

 

'''Example usage:'''

 

X = 8.

 

 

?- X is 2.5 ^^ 3.

 

=== Recursive Predicate ===

An implementation of exponentiation using recursion and no control predicates.

 

NegExp < 0,

Exp is NegExp * -1,

NewAcc is Base * Acc,

NewExp is Exp - 1,

 

=={{header|Python}}==

 

class num(float):

# works with floats as function or operator

print num(2.3).__pow__(8)

 

=={{header|R}}==

pow <- function(x, y)

{

 

pow(3, 4) # 81

 

=={{header|Racket}}==

(define (^ base expt)

(for/fold ((acum 1))

 

(^ 5 2) ; 25

 

=={{header|Retro}}==

From the '''math'''' vocabulary:

 

 

And in use:

 

 

The fast exponentiation algorithm can be coded as follows:

 

1 2rot

[ dup 1 and 0 <>

[ dup * ] dip 1 >> dup 0 <>

] while

 

=={{header|REXX}}==

The &nbsp; '''iPow''' &nbsp; function doesn't care what kind of number is to be raised to a power,

<br>it can be an integer or floating point number.

 

Extra error checking was added to verify that the invocation is syntactically correct.

say center('digits='digits(), 79, "─")

say

 

say

 

say

 

say

 

say

 

say 'iPow(5, 70) is:'

say iPow(5, 70)

exit /*stick a fork in it, we're all done. */

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

errMsg: say; say '***error***'; say; say arg(1); say; say; exit 13

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

<pre>

───────────────────────────────────digits=9────────────────────────────────────

 

 

0.0009765625

 

───────────────────────────────────digits=30───────────────────────────────────

-31.0062766802998201754763126013

 

───────────────────────────────────digits=60───────────────────────────────────

8470329472543003390683225006796419620513916015625

</pre>

 

=={{header|Ring}}==

see "11^5 = " + ipow(11, 5) + nl

see "pi^3 = " + fpow(3.14, 3) + nl

next

return p

Output :

<pre>

11^5 = 161051

pi^3 = 30.96

</pre>

 

We add a <tt>pow</tt> method to <tt>Numeric</tt> objects. To calculate <tt>5.pow 3</tt>, this method fills an array <tt>[5, 5, 5]</tt> and then multiplies together the elements.

 

def pow(m)

raise TypeError, "exponent must be an integer: #{m}" unless m.is_a? Integer

p 5.pow(3)

p 5.5.pow(3)

 

{{out}}

 

To overload the ** exponentiation operator, this might work, but doesn't:

def **(m)

pow(m)

end

It doesn't work because the ** method is defined independently for Numeric subclasses Fixnum, Bignum and Float. One must:

def **(m)

print "Fixnum "

p i=2**64

p i ** 2

{{out}}

<pre>Fixnum pow!!

 

=={{header|Run BASIC}}==

print " (-11)^5 = ";-11^5

print " 11^( -5) = ";11^-5

print " 0^2 = ";0^2

print " 2^0 = ";2^0

{{out}}

<pre> 11^5 = 161051

2^0 = 1

-2^0 = 1</pre>

=={{header|Rust}}==

The <code>num</code> crate is the de-facto Rust library for numerical generics and it provides the <code>One</code> trait which allows for an exponentiation function that is generic over both integral and floating point types. The library provides this generic exponentiation function, the implementation of which is the <code>pow</code> function below.

use num::traits::One;

use std::ops::Mul;

}

acc

 

=={{header|Scala}}==

 

To use it, one has to import the implicit from the appropriate object. ExponentI will work for any integral type (Int, BigInt, etc), ExponentF will work for any fractional type (Double, BigDecimal, etc). Importing both at the same time won't work. In this case, it might be better to define implicits for the actual types being used, such as was done in Exponents.

import scala.annotation.tailrec

implicit def toExponent(n: Double): ExponentF[Double] = new ExponentF(n)

}

exponent match {

case 0 => acc

case _ => powI(n, (exponent - 1), acc*n)

}

 

=={{header|Scheme}}==

This definition of the exponentiation procedure <code>^</code> operates on bases of all numerical types that the multiplication procedure <code>*</code> operates on, i. e. integer, rational, real, and complex. The notion of an operator does not exist in Scheme. Application of a procedure to its arguments is '''always''' expressed with a prefix notation.

(define (*^ exponent acc)

(if (= exponent 0)

(newline)

(display (^ 2+i 3))

{{out}}

<pre>

Instead the exponentiation-by-squaring algorithm is used.

 

result

var integer: result is 0;

end while;

end if;

 

Original source: [http://seed7.sourceforge.net/algorith/math.htm#intPow]

 

result

var float: power is 1.0;

end if;

end if;

 

Original source: [http://seed7.sourceforge.net/algorith/math.htm#fltIPow]

and [http://seed7.sourceforge.net/libraries/float.htm float] bases:

 

 

const func integer: (in var integer: base) ^* (in var integer: exponent) is

 

const func float: (in var float: base) ^* (in var integer: exponent) is

 

=={{header|Sidef}}==

Function definition:

 

func expon(base, exp {.is_neg}) {

 

say expon(3, 10)

 

Operator definition:

method ⊙(exp) {

expon(self, exp)

 

say (3 ⊙ 10)

{{out}}

<pre>

59049

</pre>

 

=={{header|Slate}}==

This code is from the current slate implementation:

[

y isZero ifTrue: [^ x unit].

result]

ifFalse: [(x raisedTo: y negated) reciprocal]

 

For floating numbers:

 

"Implements floating-point exponentiation in terms of the natural logarithm

and exponential primitives - this is generally faster than the naive method."

x isZero \/ [y isUnit] ifTrue: [^ x].

(x ln * y) exp

=={{header|Smalltalk}}==

{{works with|GNU Smalltalk}}

''Extending'' the class Number, we provide the operator for integers, floating points, ''rationals'' numbers (and any other derived class)

** anInt [

| r |

( 2.5 ** 3 ) displayNl.

( 2 ** 10 ) displayNl.

 

{{out}}

=={{header|Standard ML}}==

The following operators only take nonnegative integer exponents.

fun aux (x, i) =

if i = b then x

infix 6 **

val op *** = expt_real

 

val it = 8 : int

- 2.4 *** 3;

 

=={{header|Stata}}==

function pow(a, n) {

x = a

return(p)

}

 

=={{header|Swift}}==

{{trans|Python}}

Defines generic function raise(_:to:) and operator ** that will work with all bases conforming to protocol Numeric, including Float and Int.

precondition(exponent >= 0, "Exponent has to be nonnegative")

return Array(repeating: base, count: exponent).reduce(1, *)

assert(someFloat ** someInt == 1024)

assert(raise(someInt, to: someInt) == 10000000000)

 

=={{header|Tcl}}==

 

This solution does not consider negative exponents.

proc tcl::mathfunc::mypow {a b} {

if { ! [string is int -strict $b]} {error "exponent must be an integer"}

expr {mypow(3, 3)} ;# ==> 27

expr {mypow(3.5, 3)} ;# ==> 42.875

 

=={{header|Ursa}}==

def intpow (int m, int n)

if (< n 1)

end for

return ret

 

=={{header|VBA}}==

Dim result As Variant

If TypeName(base) = "Integer" Or TypeName(base) = "Long" Then

Debug.Print "(-3.0)^(-4)=", exp(-3#, -4)

Debug.Print "0.0^(-4)=", exp(0#, -4)

<pre>Integer exponentiation

10^7= 10000000

(-3.0)^(-4)= 1,23456790123457E-02

0.0^(-4)= Fout 11</pre>

=={{header|VBScript}}==

Function pow(x,y)

pow = 1

WScript.StdOut.Write "-3 ^ 5 = " & pow(-3,5)

WScript.StdOut.WriteLine

 

{{Out}}

4 ^ -6 = 0.000244140625

-3 ^ 5 = -243

</pre>

 

To create an exponent operator you need to modify the compiler code,

which is open source.

 

func real Power(X, Y); \X raised to the Y power; (X > 0.0)

CrLf(0);

];

 

{{out}}

Int and Float have pow methods and zkl doesn't allow you to add operators, classes can implement existing ones.

{{trans|C}}

reg v;

if(n.isType(1)){ // Int

}

v

println("2^-6 = %d".fmt(pow(2,-6)));

println("2.71^6 = %f".fmt(pow(2.71,6)));

{{out}}

<pre>

The function itself makes use of the inbuilt exponentiation operator, which is kind of cheating, but hey this provides a working implementation.

 

20 PRINT e(1.5,2.7): REM 1.5 ^ 2.7

30 STOP