Real constants and functions: Difference between revisions

{{task|Basic language learning}}

[[Category:Arithmetic operations]]

[[Category:Simple]]

;Task:

Show how to use the following math constants and functions in your language   (if not available, note it):

:* &nbsp; <big>''e''</big> &nbsp; (base of the natural logarithm)

:* &nbsp; <big><math>\pi</math></big>

:* &nbsp; square root

:* &nbsp; logarithm &nbsp; (any base allowed)

:* &nbsp; exponential &nbsp; (<big>''e''^''x''</big> )

:* &nbsp; absolute value &nbsp; (a.k.a. "magnitude")

:* &nbsp; floor &nbsp; (largest integer less than or equal to this number--not the same as truncate or int)

:* &nbsp; ceiling &nbsp; (smallest integer not less than this number--not the same as round up)

:* &nbsp; power &nbsp; (<big>''x''^''y''</big> )

;Related task:

* &nbsp; [[Trigonometric Functions]]

<br><br>

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

{{trans|Python}}

<lang 11l>math:e // e

math:pi // pi

sqrt(x) // square root

log(x) // natural logarithm

log10(x) // base 10 logarithm

exp(x) // e raised to the power of x

abs(x) // absolute value

floor(x) // floor

ceil(x) // ceiling

x ^ y // exponentiation</lang>

=={{header|ACL2}}==

Only the last three are available as built in functions.

<lang Lisp>(floor 15 2) ;; This is the floor of 15/2

(ceiling 15 2)

(expt 15 2) ;; 15 squared</lang> =={{header|ACL2}}==

Only the last three are available as built in functions.

loor and ceiling are not provided, one can

define them using integer part:

<lang pop11>define floor(x);

if x < 0 then

-intof(x);

else

intof(x);

endif;

enddefine;

define ceiling(x);

-floor(-x);

enddefine;</lang>

=={{header|ActionScript}}==

Actionscript has all the functions and constants mentioned in the task, available in the Math class.

<lang ActionScript>Math.E; //e

Math.PI; //pi

Math.sqrt(u); //square root of u

Math.log(u); //natural logarithm of u

Math.exp(u); //e to the power of u

Math.abs(u); //absolute value of u

Math.floor(u);//floor of u

Math.ceil(u); //ceiling of u

Math.pow(u,v);//u to the power of v</lang>

The Math class also contains several other constants.

<lang ActionScript>Math.LN10; // natural logarithm of 10

Math.LN2; // natural logarithm of 2

Math.LOG10E; // base-10 logarithm of e

Math.LOG2E; // base-2 logarithm of e

Math.SQRT1_2;// square root of 1/2

Math.SQRT2; //square root of 2</lang>

=={{header|Ada}}==

Most of the constants and functions used in this task are defined in the pre-defined Ada package Ada.Numerics.Elementary_Functions.

<lang ada>Ada.Numerics.e -- Euler's number

Ada.Numerics.pi -- pi

sqrt(x) -- square root

log(x, base) -- logarithm to any specified base

exp(x) -- exponential

abs(x) -- absolute value

S'floor(x) -- Produces the floor of an instance of subtype S

S'ceiling(x) -- Produces the ceiling of an instance of subtype S

x**y -- x raised to the y power</lang>

=={{header|Aime}}==

<lang aime># e

exp(1);

# pi

2 * asin(1);

sqrt(x);

log(x);

exp(x);

fabs(x);

floor(x);

ceil(x);

pow(x, y);</lang>

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

<lang algol68>REAL x:=exp(1), y:=4*atan(1);

printf(($g(-8,5)"; "$,

exp(1), # e #

pi, # pi #

sqrt(x), # square root #

log(x), # logarithm base 10 #

ln(x), # natural logarithm #

exp(x), # exponential #

ABS x, # absolute value #

ENTIER x, # floor #

-ENTIER -x, # ceiling #

x ** y # power #

))</lang>

{{out}}

<pre> 2.71828; 3.14159; 1.64872; 0.43429; 1.00000; 15.15426; 2.71828; 2.00000; 3.00000; 23.14069; </pre>

''ALGOL 68'' also includes assorted long, short and complex versions of the above, eg: ''long exp'', ''long long exp'', ''short exp'', ''complex exp'' etc.

And assorted trig functions: ''sin(x)'', ''arcsin(x)'', ''cos(x)'', ''arccos(x)'', ''tan(x)'', ''arctan(x)'', ''arctan2(x,y)'', ''sinh(x)'', ''arcsinh(x)'', ''cosh(x)'', ''arccosh(x)'', ''tanh(x)'' AND ''arctanh(x)''.

=={{header|ALGOL W}}==

<lang algolw>begin

real t, u;

t := 10;

u := -2.3;

i_w := 4; s_w := 0; r_format := "A"; r_d := 4; r_w := 9; % set output format %

write( " e: ", exp( 1 ) ); % e %

write( " pi: ", pi ); % pi %

write( " root t: ", sqrt( t ) ); % square root %

write( " log t: ", log( t ) ); % log base 10 %

write( " ln t: ", ln( t ) ); % log base e %

write( " exp u: ", exp( u ) ); % exponential %

write( " abs u: ", abs u ); % absolute value %

write( " floor pi: ", entier( pi ) ); % floor %

write( "ceiling pi: ", - entier( - pi ) ); % ceiling %

% the raise-to-the-power operator is "**" - it only allows integers for the power %

write( " pi cubed: ", pi ** 3 ) % use exp( ln( x ) * y ) for general x^y %

end.</lang>

=={{header|ARM Assembly}}==

{{omit from|ARM Assembly}}

<lang>

/* functions not availables */

</lang>

=={{header|AutoHotkey}}==

The following math functions are built into AutoHotkey:

<lang autohotkey>Sqrt(Number) ; square root

Log(Number) ; logarithm (base 10)

Ln(Number) ; natural logarithm (base e)

Exp(N) ; e to the power N

Abs(Number) ; absolute value

Floor(Number) ; floor

Ceil(Number) ; ceiling

x**y ; x to the power y</lang>

No mathematical constants are built-in, but they can all be calculated:

<lang autohotkey>e:=exp(1)

pi:=2*asin(1)</lang>

The following are additional trigonometric functions that are built into the AutoHotkey language:

<lang autohotkey>Sin(Number) ; sine

Cos(Number) ; cosine

Tan(Number) ; tangent

ASin(Number) ; arcsine

ACos(Number) ; arccosine

ATan(Number) ; arctangent</lang>

=={{header|AWK}}==

Awk has square root, logarithm, exponential and power.

<lang awk>BEGIN {

print sqrt(2) # square root

print log(2) # logarithm base e

print exp(2) # exponential

print 2 ^ -3.4 # power

}

# outputs 1.41421, 0.693147, 7.38906, 0.0947323</lang>

<blockquote style="font-size: smaller;">'''Power's note:'''

With [[nawk]] or [[gawk]], <code>2 ** -3.4</code> acts like <code>2 ^ -3.4</code>.

With [[mawk]], <code>2 ** -3.4</code> is a syntax error.

Nawk allows <code>**</code>, but its manual page only has <code>^</code>.

Gawk's manual warns, ''"The POSIX standard only specifies the use of `^' for exponentiation.

For maximum portability, do not use the `**' operator."''</blockquote>

Awk misses e, pi, absolute value, floor and ceiling; but these are all easy to implement:

<lang awk>BEGIN {

E = exp(1)

PI = atan2(0, -1)

}

function abs(x) {

return x < 0 ? -x : x

}

function floor(x) {

y = int(x)

return y > x ? y - 1 : y

}

function ceil(x) {

y = int(x)

return y < x ? y + 1 : y

}

BEGIN {

print E

print PI

print abs(-3.4) # absolute value

print floor(-3.4) # floor

print ceil(-3.4) # ceiling

}

# outputs 2.71828, 3.14159, 3.4, -4, -3</lang>

=={{header|Axe}}==

In general, Axe does not support many operations on real numbers.

However, there are a few special cases that it does support.

To take the square root of an integer X:

<lang axe>√(X)</lang>

To take the square root of an 8.8 fixed-point number Y:

<lang axe>√(Y)ʳ</lang>

To take the base-2 logarithm of an integer X:

<lang axe>ln(X)</lang>

To take 2 raised to an integer X: (Note that the base is not Euler's number)

<lang axe>e^(X)</lang>

To take the absolute value of a signed integer X:

<lang axe>abs(X)</lang>

=={{header|BASIC}}==

{{works with|QuickBasic|4.5}}

<lang qbasic>abs(x) 'absolute value

sqr(x) 'square root

exp(x) 'exponential

log(x) 'natural logarithm

x ^ y 'power

'floor, ceiling, e, and pi not available</lang>

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

<lang IS-BASIC>100 LET X=2:LET Y=5

110 PRINT EXP(1) ! value of e

120 PRINT PI ! value of Pi

130 PRINT ROUND(PI,3) ! rounds Pi to 3 decimal places

140 PRINT TRUNCATE(PI,3) ! cuts 3 decimal places from Pi

150 PRINT SQR(X) ! square root of x

160 PRINT LOG(X) ! the natural logarithm of number x

170 PRINT LOG2(X) ! logarithm of x to base 2

180 PRINT LOG10(X) ! logarithm of x to base 10

190 PRINT EXP(X) ! exponential

200 PRINT ABS(X) ! the absolute value of a number

210 PRINT INT(X) ! the largest whole number not bigger than x

220 PRINT IP(X) ! the integer part of x

230 PRINT FP(X) ! stands for fractorial part

240 PRINT CEIL(X) ! ceiling: gives the smallest whole number not less than x

250 PRINT X^Y ! power

260 PRINT MIN(X,Y) ! the smaller number of x and y

270 PRINT MAX(X,Y) ! the bigger number of x and y

280 PRINT EPS(X) ! the smallest quantity that can be added to or subtracted from x to make the interpreter register a change in the value of x

290 PRINT INF ! The largest positive number the tinterpreter can handle. This number is 9.999999999*10^62</lang>

==={{header|Sinclair ZX81 BASIC}}===

Arguments to built-in functions may be placed in parentheses, but are not required to be.

Base of the natural logarithm:

<lang basic>EXP 1</lang>

<math>\pi</math>:

<lang basic>PI</lang>

Square root:

<lang basic>SQR X</lang>

Natural logarithm:

<lang basic>LN X</lang>

Exponential:

<lang basic>EXP X</lang>

Absolute value:

<lang basic>ABS X</lang>

Floor:

<lang basic>INT X</lang>

(NB. Although this function is called <code>INT</code>, it corresponds to <code>floor</code>: e.g. <code>INT -3.1</code> returns -4 not -3.)

Ceiling:<br>

not provided as a built-in function.

Power:

<lang basic>X**Y</lang>

NB. Both <math>x</math> and <math>y</math> can be real numbers.

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

<lang bbcbasic> e = EXP(1)

Pi = PI

Sqr2 = SQR(2)

Ln2 = LN(2)

Log2 = LOG(2) : REM Base 10

Exp2 = EXP(2)

Abs2 = ABS(-2)

Floor = INT(1.234)

Ceil = FNceil(1.234)

Power = 1.23^4

END

DEF FNceil(n) = INT(n) - (INT(n) <> n)

</lang>

=={{header|bc}}==

The language has square root and power, but power only works if the exponent is an integer.

<lang bc>scale = 6

sqrt(2) /* 1.414213 square root */

4.3 ^ -2 /* .054083 power (integer exponent) */</lang>

The standard library has natural logarithm and exponential functions. It can calculate e and pi: e comes from the exponential function, while pi is four times the arctangent of one. The usual formulas can calculate the powers with fractional exponents, and the logarithms with any base.

{{libheader|bc -l}}

<lang bc>scale = 6

l(2) /* .693147 natural logarithm */

e(2) /* 7.389056 exponential */

p = 4 * a(1)

e = e(1)

p /* 3.141592 pi to 6 fractional digits */

e /* 2.178281 e to 6 fractional digits */

e(l(2) * -3.4) /* .094734 2 to the power of -3.4 */

l(1024) / l(2) /* 10.000001 logarithm base 2 of 1024 */</lang>

The missing functions are absolute value, floor and ceiling. You can implement these functions, if you know what to do.

{{trans|AWK}}

<lang bc>/* absolute value */

define v(x) {

if (x < 0) return (-x)

return (x)

}

/* floor */

define f(x) {

auto s, y

s = scale

scale = 0

y = x / 1

scale = s

if (y > x) return (y - 1)

return (y)

}

/* ceiling */

define g(x) {

auto s, y

s = scale

scale = 0

y = x / 1

scale = s

if (y < x) return (y + 1)

return (y)

}

v(-3.4) /* 3.4 absolute value */

f(-3.4) /* -4 floor */

g(-3.4) /* -3 ceiling */</lang>

=={{header|blz}}==

The constant e

<lang blz>{e}</lang>

The constant pi

<lang blz>{pi}</lang>

Square root

<lang blz>x ** 0.5</lang>

Logarithm (base n)

<lang blz>x __ n</lang>

Exponential

<lang blz>{e} ** x</lang>

Absolute Value

<lang blz>abs(x)</lang>

Floor

<lang blz>floor(x)</lang>

Ceiling

<lang blz>ceil(x)</lang>

Power x to the y

<lang blz>x ** y</lang>

=={{header|Bracmat}}==

Bracmat has no real number type, but the constants <code>e</code> and <code>pi</code>, together with <code>i</code> can be used as symbols with the intended mathematical meaning in exponential functions.

For example, differentiation <code>10^x</code> to <code>x</code>

<lang bracmat>x \D (10^x) { \D is the differentiation operator }</lang>

has the result

<lang bracmat>10^x*e\L10 { \L is the logarithm operator }</lang>

Likewise <code>e^(i*pi)</code> evaluates to <code>-1</code> and <code>e^(1/2*i*pi)</code> evaluates to <code>i</code>.

When taking the square root of a (rational) number, and nominator and denominator are not too big (convertible to 32 or 64 bit integers, depending on platform), Bracmat resolves the number in prime factors and halves the exponents of each of the prime factors.

Bracmat handles logarithms in any base, except real numbers that are not rational. Example: <code>24/7 \L 119/9</code> evaluates to <code>2+24/7\L5831/5184</code>.

Bracmat does not attempt to compute the numerical value of the exponential function, except for a the special case where the result is a rational number.

Thus <code>e^0</code> evaluates to <code>1</code>.

Bracmat has no built-in functions for computing the absolute value,

floor or ceiling. For real numbers that are rational such functions can be written.

If the result of taking the power of a rational number to another rational number is rational, Bracmat can in many compute it, if needed using prime factorization. See root above. Example:

<code> 243/1024^2/5</code> evaluates to <code>9/16</code>.

=={{header|C}}==

Most of the following functions take a double.

<lang c>#include <math.h>

M_E; /* e - not standard but offered by most implementations */

M_PI; /* pi - not standard but offered by most implementations */

sqrt(x); /* square root--cube root also available in C99 (cbrt) */

log(x); /* natural logarithm--log base 10 also available (log10) */

exp(x); /* exponential */

abs(x); /* absolute value (for integers) */

fabs(x); /* absolute value (for doubles) */

floor(x); /* floor */

ceil(x); /* ceiling */

pow(x,y); /* power */</lang>

To access the M_PI, etc. constants in Visual Studio, you may need to add the line <code>#define _USE_MATH_DEFINES</code> before the <code>#include <math.h></code>.

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

<lang csharp>using System;

class Program {

static void Main(string[] args) {

Console.WriteLine(Math.E); //E

Console.WriteLine(Math.PI); //PI

Console.WriteLine(Math.Sqrt(10)); //Square Root

Console.WriteLine(Math.Log(10)); // Logarithm

Console.WriteLine(Math.Log10(10)); // Base 10 Logarithm

Console.WriteLine(Math.Exp(10)); // Exponential

Console.WriteLine(Math.Abs(10)); //Absolute value

Console.WriteLine(Math.Floor(10.0)); //Floor

Console.WriteLine(Math.Ceiling(10.0)); //Ceiling

Console.WriteLine(Math.Pow(2, 5)); // Exponentiation

}

}</lang>

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

=== using Math macros ===

<lang cpp>#include <iostream>

#include <cmath>

#ifdef M_E

static double euler_e = M_E;

#else

static double euler_e = std::exp(1); // standard fallback

#endif

#ifdef M_PI

static double pi = M_PI;

#else

static double pi = std::acos(-1);

#endif

int main()

{

std::cout << "e = " << euler_e

<< "\npi = " << pi

<< "\nsqrt(2) = " << std::sqrt(2.0)

<< "\nln(e) = " << std::log(euler_e)

<< "\nlg(100) = " << std::log10(100.0)

<< "\nexp(3) = " << std::exp(3.0)

<< "\n|-4.5| = " << std::abs(-4.5) // or std::fabs(-4.5); both work in C++

<< "\nfloor(4.5) = " << std::floor(4.5)

<< "\nceiling(4.5) = " << std::ceil(4.5)

<< "\npi^2 = " << std::pow(pi,2.0) << std::endl;

}</lang>

=== using Boost ===

{{libheader|Boost}}

<lang cpp>#include <iostream>

#include <iomanip>

#include <cmath>

#include <boost/math/constants/constants.hpp>

int main()

{

using namespace boost::math::double_constants;

std::cout << "e = " << std::setprecision(18) << e

<< "\ne³ = " << std::exp(3.0)

<< "\nπ = " << pi

<< "\nπ² = " << pi_sqr

<< "\n√2 = " << root_two

<< "\nln(e) = " << std::log(e)

<< "\nlg(100) = " << std::log10(100.0)

<< "\n|-4.5| = " << std::abs(-4.5)

<< "\nfloor(4.5) = " << std::floor(4.5)

<< "\nceiling(4.5) = " << std::ceil(4.5) << std::endl;

}</lang>

{{out}}

<pre>e = 2.71828182845904509

e³ = 20.0855369231876679

π = 3.14159265358979312

π² = 9.86960440108935799

√2 = 1.41421356237309515

ln(e) = 1

lg(100) = 2

|-4.5| = 4.5

floor(4.5) = 4

ceiling(4.5) = 5</pre>

=={{header|Chef}}==

See [[Basic integer arithmetic#Chef]] for powers.

=={{header|Clojure}}==

{{trans|Java}} which is directly available.

<lang lisp>(Math/E); //e

(Math/PI); //pi

(Math/sqrt x); //square root--cube root also available (cbrt)

(Math/log x); //natural logarithm--log base 10 also available (log10)

(Math/exp x); //exponential

(Math/abs x); //absolute value

(Math/floor x); //floor

(Math/ceil x); //ceiling

(Math/pow x y); //power</lang>

Clojure does provide arbitrary precision versions as well:

<lang lisp>(ns user (:require [clojure.contrib.math :as math]))

(math/sqrt x)

(math/abs x)

(math/floor x)

(math/ceil x)

(math/expt x y) </lang>

.. and as multimethods that can be defined for any type (e.g. complex numbers).

<lang lisp>(ns user (:require [clojure.contrib.generic.math-functions :as generic]))

(generic/sqrt x)

(generic/log x)

(generic/exp x)

(generic/abs x)

(generic/floor x)

(generic/ceil x)

(generic/pow x y)</lang>

=={{header|COBOL}}==

Everything that follows can take any number (except for <code>SQRT</code> which expects a non-negative number).

The task constants and (intrinsic) functions:

<lang cobol>E *> e

PI *> Pi

SQRT(n) *> Sqaure root

LOG(n) *> Natural logarithm

LOG10(n) *> Logarithm (base 10)

EXP(n) *> e to the nth power

ABS(n) *> Absolute value

INTEGER(n) *> While not a proper floor function, it is implemented in the same way.

*> There is no ceiling function. However, it could be implemented like so:

ADD 1 TO N

MOVE INTEGER(N) TO Result

*> There is no pow function, although the COMPUTE verb does have an exponention operator.

COMPUTE Result = N ** 2 </lang>

COBOL also has the following extra mathematical functions:

<lang cobol>FACTORIAL(n) *> Factorial

EXP10(n) *> 10 to the nth power

*> Trigonometric functions, including inverse ones, named as would be expected.</lang>

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

In Lisp we should really be talking about numbers rather than the type <code>real</code>. The types <code>real</code> and <code>complex</code> are subtypes of <code>number</code>. Math operations that accept or produce complex numbers generally do.

<lang lisp>

(exp 1) ; e (Euler's number)

pi ; pi constant

(sqrt x) ; square root: works for negative reals and complex

(log x) ; natural logarithm: works for negative reals and complex

(log x 10) ; logarithm base 10

(exp x) ; exponential

(abs x) ; absolute value: result exact if input exact: (abs -1/3) -> 1/3.

(floor x) ; floor: restricted to real, two valued (second value gives residue)

(ceiling x) ; ceiling: restricted to real, two valued (second value gives residue)

(expt x y) ; power

</lang>

=={{header|Crystal}}==

<lang ruby>x = 3.25

y = 4

puts x.abs # absolute value

puts x.floor # floor

puts x.ceil # ceiling

puts x ** y # power

puts

include Math # without including

puts E # puts Math::E -- exponential constant

puts PI # puts Math::PI -- Archimedes circle constant

puts TAU # puts Math::TAU -- the correct circle constant, >= version 0.36

puts sqrt(x) # puts Math.sqrt(x) -- real square root

puts log(x) # puts Math.log(x) -- natural logarithm

puts log10(x) # puts Math.log10(x) -- base 10 logarithm

puts log(x, y) # puts Math.log(x, y) -- logarithm x base y

puts exp(x) # puts Math.exp(x) -- exponential

puts E**x # puts Math::E**x -- same

</lang>

{{0ut}}<pre>

3.25

3.0

4.0

111.56640625

2.718281828459045

3.141592653589793

6.283185307179586

1.8027756377319946

1.1786549963416462

0.5118833609788744

0.8502198590705461

25.790339917193062

25.79033991719306

</pre>

=={{header|D}}==

<lang d>import std.math ; // need to import this module

E // Euler's number

PI // pi constant

sqrt(x) // square root

log(x) // natural logarithm

log10(x) // logarithm base 10

log2(x) // logarithm base 2

exp(x) // exponential

abs(x) // absolute value (= magnitude for complex)

floor(x) // floor

ceil(x) // ceiling

pow(x,y) // power</lang>

=={{header|Delphi}}==

Log, Floor, Ceil and Power functions defined in Math.pas.

<lang Delphi>Exp(1); // e (Euler's number)

Pi; // π (Pi)

Sqrt(x); // square root

LogN(BASE, x) // log of x for a specified base

Log2(x) // log of x for base 2

Log10(x) // log of x for base 10

Ln(x); // natural logarithm (for good measure)

Exp(x); // exponential

Abs(x); // absolute value (a.k.a. "magnitude")

Floor(x); // floor

Ceil(x); // ceiling

Power(x, y); // power</lang>

=={{header|DWScript}}==

See [[Real_constants_and_functions#Delphi|Delphi]].

=={{header|E}}==

<lang e>? 1.0.exp()

# value: 2.7182818284590455

? 0.0.acos() * 2

# value: 3.141592653589793

? 2.0.sqrt()

# value: 1.4142135623730951

? 2.0.log()

# value: 0.6931471805599453

? 5.0.exp()

# value: 148.4131591025766

? (-5).abs()

# value: 5

? 1.2.floor()

# value: 1

? 1.2.ceil()

# value: 2

? 10 ** 6

# value: 1000000</lang>

=={{header|Elena}}==

ELENA 4.x :

<lang elena>import system'math;

import extensions;

public program()

{

console.printLine(E_value); //E

console.printLine(Pi_value); //PI

console.printLine(10.sqrt()); //Square Root

console.printLine(10.ln()); //Logarithm

console.printLine(10.log10()); // Base 10 Logarithm

console.printLine(10.exp()); //Exponential

console.printLine(10.Absolute); //Absolute value

console.printLine(10.0r.floor()); //Floor

console.printLine(10.0r.ceil()); //Ceiling

console.printLine(2.power(5)); //Exponentiation

}</lang>

=={{header|Elixir}}==

<lang elixir>defmodule Real_constants_and_functions do

def main do

IO.puts :math.exp(1) # e

IO.puts :math.pi # pi

IO.puts :math.sqrt(16) # square root

IO.puts :math.log(10) # natural logarithm

IO.puts :math.log10(10) # base 10 logarithm

IO.puts :math.exp(2) # e raised to the power of x

IO.puts abs(-2.24) # absolute value

IO.puts Float.floor(3.1423) # floor

IO.puts Float.ceil(20.125) # ceiling

IO.puts :math.pow(3,2) # exponentiation

end

end

Real_constants_and_functions.main</lang>

=={{header|Elm}}==

The following are all in the Basics module, which is imported by default:

<lang elm>e -- e

pi -- pi

sqrt x -- square root

logBase 3 9 -- logarithm (any base)

e^x -- exponential

abs x -- absolute value

floor x -- floor

ceiling x -- ceiling

2 ^ 3 -- power</lang>

=={{header|Erlang}}==

<lang erlang>% Implemented by Arjun Sunel

-module(math_constants).

-export([main/0]).

main() ->

io:format("~p~n", [math:exp(1)] ), % e

io:format("~p~n", [math:pi()] ), % pi

io:format("~p~n", [math:sqrt(16)] ), % square root

io:format("~p~n", [math:log(10)] ), % natural logarithm

io:format("~p~n", [math:log10(10)] ), % base 10 logarithm

io:format("~p~n", [math:exp(2)] ), % e raised to the power of x

io:format("~p~n", [abs(-2.24)] ), % absolute value

io:format("~p~n", [floor(3.1423)] ), % floor

io:format("~p~n", [ceil(20.125)] ), % ceiling

io:format("~p~n", [math:pow(3,2)] ). % exponentiation

floor(X) when X < 0 ->

T = trunc(X),

case X - T == 0 of

true -> T;

false -> T - 1

end;

floor(X) ->

trunc(X).

ceil(X) when X < 0 ->

trunc(X);

ceil(X) ->

T = trunc(X),

case X - T == 0 of

true -> T;

false -> T + 1

end.

</lang>

{{out}}

<pre>2.718281828459045

3.141592653589793

4.0

2.302585092994046

1.0

7.38905609893065

2.24

3

21

9.0

ok

</pre>

=={{header|ERRE}}==

<lang ERRE>PROGRAM R_C_F

FUNCTION CEILING(X)

CEILING=INT(X)-(X-INT(X)>0)

END FUNCTION

FUNCTION FLOOR(X)

FLOOR=INT(X)

END FUNCTION

BEGIN

PRINT(EXP(1)) ! e not available

PRINT(π) ! pi is available or ....

PRINT(4*ATN(1)) ! .... equal to

X=12.345

Y=1.23

PRINT(SQR(X),X^0.5) ! square root

PRINT(LOG(X)) ! natural logarithm base e

PRINT(LOG(X)/LOG(10)) ! base 10 logarithm

PRINT(LOG(X)/LOG(Y)) ! arbitrary base logarithm (y>0)

PRINT(EXP(X)) ! exponential

PRINT(ABS(X)) ! absolute value

PRINT(FLOOR(X)) ! floor

PRINT(CEILING(X)) ! ceiling

PRINT(X^Y) ! power

END PROGRAM</lang>

{{out}}

<pre> 2.718282

3.141592653589793

3.141593

3.513545 3.513545

2.513251

1.091491

12.14048

229808.1

12.345

12

13

22.00564</pre>

=={{header|F Sharp|F#}}==

{{trans|C#|C sharp}}

<lang fsharp>open System

let main _ =

Console.WriteLine(Math.E); // e

Console.WriteLine(Math.PI); // Pi

Console.WriteLine(Math.Sqrt(10.0)); // Square Root

Console.WriteLine(Math.Log(10.0)); // Logarithm

Console.WriteLine(Math.Log10(10.0)); // Base 10 Logarithm

Console.WriteLine(Math.Exp(10.0)); // Exponential

Console.WriteLine(Math.Abs(10)); // Absolute value

Console.WriteLine(Math.Floor(10.0)); // Floor

Console.WriteLine(Math.Ceiling(10.0)); // Ceiling

Console.WriteLine(Math.Pow(2.0, 5.0)); // Exponentiation

0</lang>

=={{header|Factor}}==

<lang factor>e ! e

pi ! π

sqrt ! square root

log ! natural logarithm

exp ! exponentiation

abs ! absolute value

floor ! greatest whole number smaller than or equal

ceiling ! smallest whole number greater than or equal

truncate ! remove the fractional part (i.e. round towards 0)

round ! round to next whole number

^ ! power</lang>

=={{header|Fantom}}==

The <code>Float</code> class holds 64-bit floating point numbers, and contains most of the useful mathematical functions. A floating point number must be specified when entered with the suffix 'f', e.g. <code>9f</code>

<lang fantom>

Float.e

Float.pi

9f.sqrt

9f.log // natural logarithm

9f.log10 // logarithm to base 10

9f.exp // exponentiation

(-3f).abs // absolute value, note bracket

3.2f.floor // nearest Int smaller than this number

3.2f.ceil // nearest Int bigger than this number

3.2f.round // nearest Int

3f.pow(2f) // power

</lang>

Note, . binds more tightly than -, so use brackets around negative numbers:

<pre>

> -3f.pow(2f)

-9

> (-3f).pow(2f)

9

</pre>

=={{header|Forth}}==

<lang forth>1e fexp fconstant e

0e facos 2e f* fconstant pi \ predefined in gforth

fsqrt ( f -- f )

fln ( f -- f ) \ flog for base 10

fexp ( f -- f )

fabs ( f -- f )

floor ( f -- f ) \ round towards -inf

: ceil ( f -- f ) fnegate floor fnegate ; \ not standard, though fround is available

f** ( f e -- f^e )</lang>

=={{header|Fortran}}==

<lang fortran> e ! Not available. Can be calculated EXP(1.0)

pi ! Not available. Can be calculated 4.0*ATAN(1.0)

SQRT(x) ! square root

LOG(x) ! natural logarithm

LOG10(x) ! logarithm to base 10

EXP(x) ! exponential

ABS(x) ! absolute value

FLOOR(x) ! floor - Fortran 90 or later only

CEILING(x) ! ceiling - Fortran 90 or later only

x**y ! x raised to the y power</lang>

4*ATAN(1.0) will be calculated in single precision, likewise EXP(1.0) (not EXP(1), because 1 is an integer) and although double precision functions can be named explicitly, 4*DATAN(1.0) will be rejected because 1.0 is in single precision and DATAN expects double. Thus, 4*DATAN(1.0D0) or 4*DATAN(1D0) will do, as the D in the exponent form specifies double precision. Whereupon, the generic names can be returned to: 4*ATAN(1D0). Some systems go further and offer quadruple precision. Others allow that all constants will be deemed double precision as a compiler option.

The 4 need not be named as 4.0, or 4D0, as 4 the integer will be converted by the compiler to double precision, because it is to meet a known double precision value in simple multiplication and so will be promoted. Hopefully, at compile time.

=={{header|FreeBASIC}}==

<lang freebasic>' FB 1.05.0 Win64

#Include "crt/math.bi"

Print M_E '' constant "e" from C runtime library

Print M_PI '' constant "pi" from C runtime library

Print Sqr(2) '' square root function built into FB

Print Log(M_E) '' log to base "e" built into FB

Print log10(10) '' log to base 10 from C runtime library

Print Exp(1) '' exponential function built into FB

Print Abs(-1) '' absolute value function (integers or floats) built into FB

Print Int(-2.5) '' floor function built into FB

Print ceil(-2.5) '' ceiling function from C runtime library

Print 2.5 ^ 3.5 '' exponentiation operator built into FB

Sleep </lang>

{{out}}

<pre>

2.718281828459045

3.141592653589793

1.414213562373095

1

1

2.718281828459045

1

-3

-2

24.70529422006547

</pre>

=={{header|Frink}}==

All of the following operations work for any numerical type, including rational numbers, complex numbers and intervals of real numbers.

<lang frink>

e

pi, π // Unicode can also be written in ASCII programs as \u03C0

sqrt[x]

ln[x] // Natural log

log[x] // Log to base 10

exp[x], e^x

abs[x]

floor[x] // Except for complex numbers where there's no good interpretation.

ceil[x] // Except for complex numbers where there's no good interpretation.

x^y

</lang>

=={{header|FutureBasic}}==

<lang futurebasic>

include "ConsoleWindow"

// Set width of tab

def tab 8

print "exp:", exp(1)

print "pi:", pi

print "sqr:", sqr(2)

print "log:", log(2)

print "log2:", log2(2)

print "log10", log10(2)

print "abs:", abs(-2)

print "floor:", int(1.534)

print "ceil:", val( using"###"; 1.534 )

print "power:", 1.23 ^ 4

</lang>

Output:

<pre>

exp: 2.7182818285

pi: 3.1415926536

sqr: 1.4142135624

log: 0.6931471806

log2: 1

log10 0.3010299957

abs: 2

floor: 2

ceil: 2

power: 2.28886641

</pre>

=={{header|Go}}==

<lang go>package main

import (

"fmt"

"math"

"math/big"

)

func main() {

// e and pi defined as constants.

// In Go, that means they are not of a specific data type and can be used

// as float32 or float64. Println takes the float64 values.

fmt.Println("float64 values:")

fmt.Println("e:", math.E)

fmt.Println("π:", math.Pi)

// The following functions all take and return the float64 data type.

// square root. cube root also available (math.Cbrt)

fmt.Println("square root(1.44):", math.Sqrt(1.44))

// natural logarithm--log base 10, 2 also available (math.Log10, math.Log2)

// also available is log1p, the log of 1+x. (using log1p can be more

// accurate when x is near zero.)

fmt.Println("ln(e):", math.Log(math.E))

// exponential. also available are exp base 10, 2 (math.Pow10, math.Exp2)

fmt.Println("exponential(1):", math.Exp(1))

fmt.Println("absolute value(-1.2):", math.Abs(-1.2))

fmt.Println("floor(-1.2):", math.Floor(-1.2))

fmt.Println("ceiling(-1.2):", math.Ceil(-1.2))

fmt.Println("power(1.44, .5):", math.Pow(1.44, .5))

// Equivalent functions for the float32 type are not in the standard

// library. Here are the constants e and π as float32s however.

fmt.Println("\nfloat32 values:")

fmt.Println("e:", float32(math.E))

fmt.Println("π:", float32(math.Pi))

// The standard library has an arbitrary precision floating point type but

// provides only the most basic methods. Also while the constants math.E

// and math.Pi are provided to over 80 decimal places, there is no

// convenient way of loading these numbers (with their full precision)

// into a big.Float. A hack is cutting and pasting into a string, but

// of course if you're going to do that you are free to cut and paste from

// any other source. (The documentation cites OEIS as its source.)

pi := "3.141592653589793238462643383279502884197169399375105820974944"

π, _, _ := big.ParseFloat(pi, 10, 200, 0)

fmt.Println("\nbig.Float values:")

fmt.Println("π:", π)

// Of functions requested by the task, only absolute value is provided.

x := new(big.Float).Neg(π)

y := new(big.Float)

fmt.Println("x:", x)

fmt.Println("abs(x):", y.Abs(x))

}</lang>

{{out}}

<pre>

float64 values:

e: 2.718281828459045

π: 3.141592653589793

square root(1.44): 1.2

ln(e): 1

exponential(1): 2.718281828459045

absolute value(-1.2): 1.2

floor(-1.2): -2

ceiling(-1.2): -1

power(1.44, .5): 1.2

float32 values:

e: 2.7182817

π: 3.1415927

big.Float values:

π: 3.141592653589793238462643383279502884197169399375105820974944

x: -3.141592653589793238462643383279502884197169399375105820974944

abs(x): 3.141592653589793238462643383279502884197169399375105820974944

</pre>

=={{header|Groovy}}==

Math constants and functions are as outlined in the [[#Java|Java]] example, except as follows:

'''Absolute Value'''

In addition to the java.lang.Math.abs() method, each numeric type has an abs() method, which can be invoked directly on the number:

<lang groovy>println ((-22).abs())</lang>

{{out}}

<pre>22</pre>

'''Power'''

In addition to the java.lang.Math.pow() method, each numeric type works with the power operator (**), which can be invoked as an in-fix operator between two numbers:

<lang groovy>println 22**3.5</lang>

{{out}}

<pre>49943.547010599876</pre>

Power results are not defined for all possible pairs of operands.

Any power operation that does not have a result returns a 64-bit IEEE NaN (Not a Number) value.

<lang groovy>println ((-22)**3.5)</lang>

{{out}}

<pre>NaN</pre>

Also note that at the moment (07:00, 19 March 2011 (UTC)) Groovy (1.7.7) gives a mathematically incorrect result for "0**0".

The correct result should be "NaN", but the Groovy operation result is "1".

=={{header|Haskell}}==

The operations are defined for the various numeric typeclasses, as defined in their type signature.

<lang haskell>exp 1 -- Euler number

pi -- pi

sqrt x -- square root

log x -- natural logarithm

exp x -- exponential

abs x -- absolute value

floor x -- floor

ceiling x -- ceiling

x ** y -- power (e.g. floating-point exponentiation)

x ^ y -- power (e.g. integer exponentiation, nonnegative y only)

x ^^ y -- power (e.g. integer exponentiation of rationals, also negative y)</lang>

=={{header|HicEst}}==

Except for x^y, this is identical to Fortran:

<lang HicEst>e ! Not available. Can be calculated EXP(1)

pi ! Not available. Can be calculated 4.0*ATAN(1.0)

x^0.5 ! square root

LOG(x) ! natural logarithm

LOG(x, 10) ! logarithm to base 10

EXP(x) ! exponential

ABS(x) ! absolute value

FLOOR(x) ! floor

CEILING(x) ! ceiling

x**y ! x raised to the y power

x^y ! same as x**y</lang>

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

<lang Icon>link numbers # for floor and ceil

procedure main()

write("e=",&e)

write("pi=",&pi)

write("phi=",&phi)

write("sqrt(2)=",sqrt(2.0))

write("log(e)=",log(&e))

write("log(100.,10)=",log(100,10))

write("exp(1)=",exp(1.0))

write("abs(-2)=",abs(-2))

write("floor(-2.2)=",floor(-2.2))

write("ceil(-2.2)=",ceil(-2.2))

write("power: 3^3=",3^3)

end</lang>

{{libheader|Icon Programming Library}}

[http://www.cs.arizona.edu/icon/library/src/procs/numbers.icn numbers provides floor and ceiling]

{{out}}

<pre>e=2.718281828459045

pi=3.141592653589793

phi=1.618033988749895

sqrt(2)=1.414213562373095

log(e)=1.0

log(100.,10)=2.0

exp(1)=2.718281828459045

abs(-2)=2

floor(-2.2)=-2

ceil(-2.2)=-3</pre>

=={{header|J}}==

The examples below require arguments (x and y) to be numeric nouns.

<lang j>e =. 1x1 NB. Euler's number, specified as a numeric literal.

e =. ^ 1 NB. Euler's number, computed by exponentiation.

pi=. 1p1 NB. pi, specified as a numeric literal.

pi=. o.1 NB. pi, computed trigonometrically.

magnitude_of_x =. |x

floor_of_x =. <.x

ceiling_of_x =. >.x

natural_log_of_x =. ^.x

base_x_log_of_y =. x^.y

x_squared =. *:x NB. special form

x_squared =. x^2 NB. exponential form

square_root_of_x =. %:x NB. special form

square_root_of_x =. x^0.5 NB. exponential form

x_to_the_y_power =. x^y</lang>

=={{header|Java}}==

All of these functions are in Java's <tt>Math</tt> class which, does not require any imports:

<lang java>Math.E; //e

Math.PI; //pi

Math.sqrt(x); //square root--cube root also available (cbrt)

Math.log(x); //natural logarithm--log base 10 also available (log10)

Math.exp(x); //exponential

Math.abs(x); //absolute value

Math.floor(x); //floor

Math.ceil(x); //ceiling

Math.pow(x,y); //power</lang>

=={{header|JavaScript}}==

<lang javascript>Math.E

Math.PI

Math.sqrt(x)

Math.log(x)

Math.exp(x)

Math.abs(x)

Math.floor(x)

Math.ceil(x)

Math.pow(x,y)</lang>

=={{header|jq}}==

The mathematical functions available in jq are defined as 0-arity filters, so to evaluate the sqrt of 4, one writes <tt>4|sqrt</tt>.

In jq, "." refers to the output coming from the left in the pipeline.

In the following, comments appear after the "#":<lang jq>

1 | exp # i.e. e

1 | atan * 4 # i.e. π

sqrt

log # Naperian log

exp

if . < 0 then -. else . end # absolute value

floor

# jq does not currently have a ceiling function

# jq does not currently have a function to compute x^y</lang>

=={{header|Jsish}}==

<lang javascript>/* real constants and functions, in JSI */

var x, y;

;Math.E;

;Math.PI;

;x = 100.0;

;Math.sqrt(x);

;Math.log(x);

;x = 2.0;

;Math.exp(x);

;x = -x;

;Math.abs(x);

;x = 42.42;

;Math.floor(x);

;Math.ceil(x);

;x = 10.0;

;y = 5;

;Math.pow(x,y);

/*

=!EXPECTSTART!=

Math.E ==> 2.718281828459045

Math.PI ==> 3.141592653589793

x = 100.0 ==> 100

Math.sqrt(x) ==> 10

Math.log(x) ==> 4.605170185988092

x = 2.0 ==> 2

Math.exp(x) ==> 7.38905609893065

x = -x ==> -2

Math.abs(x) ==> 2

x = 42.42 ==> 42.42

Math.floor(x) ==> 42

Math.ceil(x) ==> 43

x = 10.0 ==> 10

y = 5 ==> 5

Math.pow(x,y) ==> 100000

=!EXPECTEND!=

*/</lang>

{{out}}

<pre>prompt$ jsish --U real-constants.jsi

Math.E ==> 2.718281828459045

Math.PI ==> 3.141592653589793

x = 100.0 ==> 100

Math.sqrt(x) ==> 10

Math.log(x) ==> 4.605170185988092

x = 2.0 ==> 2

Math.exp(x) ==> 7.38905609893065

x = -x ==> -2

Math.abs(x) ==> 2

x = 42.42 ==> 42.42

Math.floor(x) ==> 42

Math.ceil(x) ==> 43

x = 10.0 ==> 10

y = 5 ==> 5

Math.pow(x,y) ==> 100000

# Run the unit tests

prompt$ jsish -u real-constants.jsi

[PASS] real-constants.jsi</pre>

=={{header|Julia}}==

<lang julia>e

π, pi

sqrt(x)

log(x)

exp(x)

abs(x)

floor(x)

ceil(x)

x^y</lang>

Note that Julia supports Unicode identifiers, and allows either <code>π</code> or <code>pi</code> for that constant.

Also, mathematical constants like <i>e</i> and π in Julia are of a special type that is automatically converted to the correct precision when used in aritmetic operations. So, for example, <code>BigFloat(2) * π</code> computes 2π in arbitrary precision arithmetic.

=={{header|Kotlin}}==

<lang scala>// version 1.0.6

fun main(args: Array<String>) {

println(Math.E) // e

println(Math.PI) // pi

println(Math.sqrt(2.0)) // square root

println(Math.log(Math.E)) // log to base e

println(Math.log10(10.0)) // log to base 10

println(Math.exp(1.0)) // exponential

println(Math.abs(-1)) // absolute value

println(Math.floor(-2.5)) // floor

println(Math.ceil(-2.5)) // ceiling

println(Math.pow(2.5, 3.5)) // power

}</lang>

{{out}}

<pre>

2.718281828459045

3.141592653589793

1.4142135623730951

1.0

1.0

2.718281828459045

1

-3.0

-2.0

24.705294220065465

</pre>

=={{header|Lambdatalk}}==

<lang scheme>

{E} -> 2.718281828459045

{PI} -> 3.141592653589793

{sqrt 2} -> 1.4142135623730951

{log {E}} -> 1

{exp 1} -> 2.718281828459045

{abs -1} -> 1

{floor -2.5} -> -3

{ceil -2.5} -> -2

{pow 2.5 3.5} -> 24.705294220065465

</lang>

=={{header|Lasso}}==

<lang Lasso>//e

define e => 2.7182818284590452

//π

define pi => 3.141592653589793

e

pi

9.0->sqrt

1.64->log

1.64->log10

1.64->exp

1.64->abs

1.64->floor

1.64->ceil

1.64->pow(10.0)</lang>

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

Ceiling and floor easily implemented as functions.

<br>

sqr( is the LB function for square root.

<br>

e & pi not available- calculate as shown.

<lang lb>

print exp( 1) ' e not available

print 4 *atn( 1) ' pi not available

x =12.345: y =1.23

print sqr( x), x^0.5 ' square root- NB the unusual name

print log( x) ' natural logarithm base e

print log( x) /2.303 ' base 10 logarithm

print log( x) /log( y) ' arbitrary base logarithm

print exp( x) ' exponential

print abs( x) ' absolute value

print floor( x) ' floor

print ceiling( x) ' ceiling

print x^y ' power

end

function floor( x)

if x >0 then

floor =int( x)

else

if x <>int( x) then floor =int( x) -1 else floor =int( x)

end if

end function

function ceiling( x)

if x <0 then

ceiling =int( x)

else

ceiling =int( x) +1

end if

end function

</lang>

=={{header|Lingo}}==

<lang lingo>the floatPrecision = 8

-- e (base of the natural logarithm)

put exp(1)

-- 2.71828183

-- pi

put PI

-- 3.14159265

-- square root

put sqrt(2.0)

-- 1.41421356

-- logarithm (any base allowed)

x = 100

put log(x) -- calculate log for base e

-- 4.60517019

put log(x)/log(10) -- calculate log for base 10

-- 2.00000000

-- exponential (ex)

put exp(3)

-- 20.08553692

-- absolute value (a.k.a. "magnitude")

put abs(-1)

-- 1

-- floor (largest integer less than or equal to this number--not the same as truncate or int)

n = 23.536

put bitOr(n, 0) -- calculates floor

-- 23

-- ceiling (smallest integer not less than this number--not the same as round up)

n = 23.536

-- calculates ceil

floor = bitOr(n, 0)

if (floor >= n) then put floor

else put floor+1

-- 24

-- power

put power(2, 8)

-- 256.00000000</lang>

=={{header|LiveCode}}==

LC 7.1+, prior to this floor & ceil were not built-in.

<lang LiveCode>e‬: exp(1)

pi: pi

square root: sqrt(x)

logarithm: log(x)

exponential (‪ex‬): exp(x)

absolute value: abs(x)

floor: floor(x)

ceiling: ceil(x)

power: x^y</lang>

=={{header|Logo}}==

{{works with|UCB Logo}}

<lang logo>make "e exp 1

make "pi 2*(RADARCTAN 0 1)

sqrt :x

ln :x

exp :x

; there is no standard abs, floor, or ceiling; only INT and ROUND.

power :x :y</lang>

=={{header|Logtalk}}==

<lang logtalk>

:- object(constants_and_functions).

:- public(show/0).

show :-

write('e = '), E is e, write(E), nl,

write('pi = '), PI is pi, write(PI), nl,

write('sqrt(2) = '), SQRT is sqrt(2), write(SQRT), nl,

% only base e logorithm is avaialable as a standard built-in function

write('log(2) = '), LOG is log(2), write(LOG), nl,

write('exp(2) = '), EXP is exp(2), write(EXP), nl,

write('abs(-1) = '), ABS is abs(-1), write(ABS), nl,

write('floor(-3.4) = '), FLOOR is floor(-3.4), write(FLOOR), nl,

write('ceiling(-3.4) = '), CEILING is ceiling(-3.4), write(CEILING), nl,

write('2 ** -3.4 = '), POWER is 2 ** -3.4, write(POWER), nl.

:- end_object.

</lang>

{{out}}

<pre>

| ?- constants_and_functions::show.

e = 2.718281828459045

pi = 3.141592653589793

sqrt(2) = 1.4142135623730951

log(2) = 0.6931471805599453

exp(2) = 7.38905609893065

abs(-1) = 1

floor(-3.4) = -4

ceiling(-3.4) = -3

2 ** -3.4 = 0.09473228540689989

yes

</pre>

=={{header|Lua}}==

<lang lua>math.exp(1)

math.pi

math.sqrt(x)

math.log(x)

math.log10(x)

math.exp(x)

math.abs(x)

math.floor(x)

math.ceil(x)

x^y</lang>

=={{header|M2000 Interpreter}}==

<lang M2000 Interpreter>

Module Checkit {

Def exp(x)= 2.71828182845905^x

Print Ln(exp(1))==1

Print Log(10^5)==5

Print Sgn(-5)=-1

Print Abs(-2.10#)=2.1#

Def exptype$(x)=type$(x)

Print exptype$(Abs(-2.1#))="Currency"

Print exptype$(Abs(-2.1~))="Single"

Print exptype$(Abs(-2.1@))="Decimal"

Print exptype$(Abs(-2&))="Long"

Print exptype$(Abs(-2%))="Integer"

Print exptype$(Abs(-2.212e34))="Double"

Print exptype$(Sgn(-2.1#))="Integer"

\\ Sgn return integer type

Print exptype$(Sgn(-2.212e34))="Integer"

\\ Log, Len return double

Print exptype$(Log(1000))="Double"

Print exptype$(exp(1%))="Double"

Print exptype$(Ln(1212%))="Double"

\\ power return type Double

Print exptype$(2&^2&)="Double"

Print exptype$(2&**2&)="Double"

Print exptype$(2&*2&)="Long"

Print 2**2=4, 2^2=4, 2^2^2=16, 2**2**2=16

\\ floor() and Int() is the same

Print Int(-2.7)=-3, Int(2.7)=2

Print Floor(-2.7)=-3, Floor(2.7)=2

Print Ceil(-2.7)=-2, Ceil(2.7)=3

Print round(-2.7, 0)=-3, round(2.7, 0)=3

Print round(-2.2, 0)=-2, round(2.2, 0)=2

Print Sqrt(4)=2

}

Checkit

</lang>

=={{header|Maple}}==

<lang Maple>> abs(ceil(floor(ln(exp(1)^sqrt(exp(Pi*I)+1)))));

0</lang>

=={{header|Mathematica}}==

<lang Mathematica>E

Pi

Sqrt[x]

Log[x]

Log[b,x]

Exp[x]

Abs[x]