Real constants and functions: Difference between revisions

{{trans|Python}}

math:pi // pi

sqrt(x) // square root

floor(x) // floor

ceil(x) // ceiling

=={{header|6502 Assembly}}==

Absolute value can be handled like so:

eor #$ff

clc

adc #1

Only the last three are available as built in functions.

(ceiling 15 2)

Only the last three are available as built in functions.

define them using integer part:

if x < 0 then

-intof(x);

define ceiling(x);

-floor(-x);

=={{header|Action!}}==

{{libheader|Action! Tool Kit}}

{{libheader|Action! Real Math}}

PROC Euler(REAL POINTER e)

PutE()

PrintE("There is no support in Action! for pi.")

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Real_constants_and_functions.png Screenshot from Atari 8-bit computer]

=={{header|ActionScript}}==

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

Math.PI; //pi

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

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

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

The Math class also contains several other constants.

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

=={{header|Ada}}==

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

Ada.Numerics.pi -- pi

sqrt(x) -- square root

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

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

=={{header|Aime}}==

exp(1);

# pi

floor(x);

ceil(x);

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

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

exp(1), # e #

-ENTIER -x, # ceiling #

x ** y # power #

{{out}}

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

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

real t, u;

t := 10;

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

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

{{omit from|ARM Assembly}}

/* functions not availables */

=={{header|Arturo}}==

print ["Pi:" pi]

print ["floor 23.536:" floor 23.536]

print ["ceil 23.536:" ceil 23.536]

{{out}}

=={{header|Asymptote}}==

write("e = ", e);

write("pi = ", pi);

write("ceil = ", ceil(-e)); // ceiling

write("power = ", x ^ y); // power

{{out}}

<pre>e = 2.71828182845905

=={{header|AutoHotkey}}==

The following math functions are built into AutoHotkey:

Log(Number) ; logarithm (base 10)

Ln(Number) ; natural logarithm (base e)

Floor(Number) ; floor

Ceil(Number) ; ceiling

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

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

Cos(Number) ; cosine

Tan(Number) ; tangent

ASin(Number) ; arcsine

ACos(Number) ; arccosine

=={{header|AWK}}==

Awk has square root, logarithm, exponential and power.

print sqrt(2) # square root

print log(2) # logarithm base e

print 2 ^ -3.4 # power

}

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

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

E = exp(1)

PI = atan2(0, -1)

print ceil(-3.4) # ceiling

}

=={{header|Axe}}==

To take the square root of an integer X:

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

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

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

To take the absolute value of a signed integer X:

=={{header|BASIC}}==

{{works with|QuickBasic|4.5}}

sqr(x) 'square root

exp(x) 'exponential

log(x) 'natural logarithm

x ^ y 'power

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

110 PRINT EXP(1) ! value of e

120 PRINT PI ! value of Pi

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

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

Base of the natural logarithm:

<math>\pi</math>:

Square root:

Natural logarithm:

Exponential:

Absolute value:

Floor:

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

Power:

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

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

Pi = PI

Sqr2 = SQR(2)

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

=={{header|BASIC256}}==

print "e = "; e

print "PI = "; PI

print "floor = "; floor(-e) # floor

print "ceil = "; ceil(-e) # ceiling

{{out}}

<pre>e = 2.71828182846

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

sqrt(2) /* 1.414213 square root */

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

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

e(2) /* 7.389056 exponential */

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

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

{{trans|AWK}}

define v(x) {

if (x < 0) return (-x)

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

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

=={{header|blz}}==

The constant e

The constant pi

Square root

Logarithm (base n)

Exponential

Absolute Value

Floor

Ceiling

Power x to the y

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

has the result

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

=={{header|C}}==

Most of the following functions take a double.

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

floor(x); /* floor */

ceil(x); /* ceiling */

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

class Program {

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

}

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

=== using Math macros ===

#include <cmath>

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

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

=== using Boost ===

{{libheader|Boost}}

#include <iomanip>

#include <cmath>

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

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

{{out}}

<pre>e = 2.71828182845904509

=={{header|Clojure}}==

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

(Math/PI); //pi

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

(Math/floor x); //floor

(Math/ceil x); //ceiling

Clojure does provide arbitrary precision versions as well:

(math/sqrt x)

(math/abs x)

(math/floor x)

(math/ceil x)

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

(generic/sqrt x)

(generic/log x)

(generic/floor x)

(generic/ceil x)

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

PI *> Pi

SQRT(n) *> Sqaure root

MOVE INTEGER(N) TO Result

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

COBOL also has the following extra mathematical functions:

EXP10(n) *> 10 to the nth power

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

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

pi ; pi constant

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

(expt x y) ; power

=={{header|Crystal}}==

y = 4

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

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

{{0ut}}<pre>

=={{header|D}}==

E // Euler's number

PI // pi constant

floor(x) // floor

ceil(x) // ceiling

=={{header|Delphi}}==

Delphi supports all basic Standard Pascal (ISO 7185) functions shown in [[#Pascal|§&nbsp;Pascal]].

Furthermore, the following is possible, too:

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

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

Floor(x); // floor

Ceil(x); // ceiling

Note, <tt>Log</tt>, <tt>Floor</tt>, <tt>Ceil</tt> and <tt>Power</tt> are from the <tt>Math</tt> unit, which needs to be listed in the <tt>uses</tt>-clauses.

=={{header|E}}==

# value: 2.7182818284590455

? 10 ** 6

=={{header|Elena}}==

ELENA 4.x :

import extensions;

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

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

=={{header|Elixir}}==

def main do

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

end

=={{header|Elm}}==

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

pi -- pi

sqrt x -- square root

floor x -- floor

ceiling x -- ceiling

=={{header|Erlang}}==

-module(math_constants).

-export([main/0]).

false -> T + 1

end.

{{out}}

<pre>2.718281828459045

=={{header|ERRE}}==

FUNCTION CEILING(X)

PRINT(CEILING(X)) ! ceiling

PRINT(X^Y) ! power

{{out}}

<pre> 2.718282

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

{{trans|C#|C sharp}}

let main _ =

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

=={{header|Factor}}==

pi ! π

sqrt ! square root

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

round ! round to next whole number

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

Float.e

Float.pi

3.2f.round // nearest Int

3f.pow(2f) // power

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

=={{header|Forth}}==

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

fsqrt ( f -- f )

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

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

=={{header|Fortran}}==

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

SQRT(x) ! square root

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

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

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.

=={{header|FreeBASIC}}==

#Include "crt/math.bi"

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

Print 2.5 ^ 3.5 '' exponentiation operator built into FB

{{out}}

=={{header|Frink}}==

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

e

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

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

x^y

=={{header|FutureBasic}}==

text ,,,,, 60// set tab width

print @"power:", 1.23 ^ 4

Output:

<pre>

=={{header|Go}}==

import (

fmt.Println("x:", x)

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

{{out}}

<pre>

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

{{out}}

<pre>22</pre>

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:

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

{{out}}

<pre>NaN</pre>

=={{header|Haskell}}==

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

pi -- pi

sqrt x -- square root

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

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

=={{header|HicEst}}==

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

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

x^0.5 ! square root

CEILING(x) ! ceiling

x**y ! x raised to the y power

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

procedure main()

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

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

{{libheader|Icon Programming Library}}

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

=={{header|J}}==

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

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

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

square_root_of_x =. %:x NB. special form

square_root_of_x =. x^0.5 NB. exponential form

=={{header|Java}}==

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

Math.PI; //pi

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

Math.floor(x); //floor

Math.ceil(x); //ceiling

=={{header|JavaScript}}==

Math.PI

Math.sqrt(x)

Math.floor(x)

Math.ceil(x)

=={{header|jq}}==

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

1 | exp # i.e. e

1 | atan * 4 # i.e. π

floor

ceil # requires jq >= 1.5

=={{header|Jsish}}==

var x, y;

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

=!EXPECTEND!=

{{out}}

=={{header|Julia}}==

π, pi

sqrt(x)

floor(x)

ceil(x)

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

=={{header|Kotlin}}==

fun main(args: Array<String>) {

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

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

{{out}}

=={{header|Lambdatalk}}==

{E} -> 2.718281828459045

{PI} -> 3.141592653589793

{ceil -2.5} -> -2

{pow 2.5 3.5} -> 24.705294220065465

=={{header|Lasso}}==

define e => 2.7182818284590452

1.64->floor

1.64->ceil

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

<br>

e & pi not available- calculate as shown.

print exp( 1) ' e not available

print 4 *atn( 1) ' pi not available

end if

end function

=={{header|Lingo}}==

-- e (base of the natural logarithm)

-- power

put power(2, 8)

=={{header|LiveCode}}==

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

pi: pi

square root: sqrt(x)

floor: floor(x)

ceiling: ceil(x)

=={{header|Logo}}==

{{works with|UCB Logo}}

make "pi 2*(RADARCTAN 0 1)

sqrt :x

exp :x

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

=={{header|Logtalk}}==

:- object(constants_and_functions).

:- end_object.

{{out}}

<pre>

=={{header|Lua}}==

math.pi

math.sqrt(x)

math.floor(x)

math.ceil(x)

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

Module Checkit {

Def exp(x)= 2.71828182845905^x

}

Checkit

=={{header|Maple}}==

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

Pi

Sqrt[x]

Floor[x]

Ceiling[x]

Where x is the number, and b the base.

Exp[x] can also be inputted as E^x or E^x and Power[x,y] can be also inputted as x^y or x^y. All functions work with symbols, integers, floats and can be complex. Abs giving the modulus (|x|) if the argument is a complex number. Constant like E and Pi are kep unevaluated until someone explicitly tells it to give a numerical approximation: N[Pi,n] gives Pi to n-digit precision. Functions given an exact argument will be kept unevaluated if the answer can't be written more compact, approximate arguments will always be evaluated:

Log[10] => Log[10]

Log[10,100] => 2

Sqrt[-4] => 2I

Exp[2] => E^2

=={{header|MATLAB}} / {{header|Octave}}==

pi % pi

sqrt(x) % square root

floor(x) % floor

ceil(x) % ceiling

=={{header|MAXScript}}==

pi -- pi

log x -- natural logarithm

floor x -- floor

ceil x -- ceiling

=={{header|Mercury}}==

math.pi % Pi.

math.e % Euler's number.

math.floor(X) % Floor of X.

math.ceiling(X) % Ceiling of X.

=={{header|Metafont}}==

show 3.14159; % no pi constant built in; of course we can define it

% in several ways... even computing

show ceiling(x); % ceiling

show x**y; % ** is not a built in: it is defined in the basic macros

=={{header|min}}==

{{works with|min|0.19.3}}

pi ; π

sqrt ; square root

trunc ; remove the fractional part (i.e. round towards 0)

round ; round number to nth decimal place

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

пи С/П

x<0 14 ИП1 С/П ИП1 1 + С/П

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

Note that all of these procedures (except the built ins) take <tt>LONGREAL</tt>s as their argument, and return <tt>LONGREAL</tt>s.

Math.Pi;

Math.sqrt(x);

FLOOR(x); (* Built in function. *)

CEILING(x); (* Built in function. *)

=={{header|Neko}}==

Real constants and functions, in Neko

Tectonics:

$print("Floor(-2.2): ", math_floor(-2.2), "\n")

$print("Ceil(-2.2) : ", math_ceil(-2.2), "\n")

{{out}}

=={{header|NetRexx}}==

All the required constants and functions (and more) are in [[Java|Java's]] <tt>Math</tt> class. NetRexx also provides a limited set of built in numeric manipulation functions for it's Rexx object.

options replace format comments java crossref symbols nobinary utf8

say Rexx(' Truncate' x 'by' y':').left(pad) x.trunc(y)

say Rexx(' Format (with rounding)' x 'by' y':').left(pad) x.format(y, 0)

{{out}}

=={{header|Nim}}==

var x, y = 12.5

echo floor(x)

echo ceil(x)

=={{header|Objeck}}==

Float->E();

4.0->SquareRoot();

3.99->Floor();

3.99->Ceiling();

=={{header|OCaml}}==

Unless otherwise noted, the following functions are for floats only:

sqrt x (* square root *)

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

ceil x (* ceiling *)

x ** y (* power *)

=={{header|Octave}}==

pi % pi

sqrt(pi) % square root

floor(pi) % floor

ceil(pi) % ceiling

=={{header|Oforth}}==

: testReal

-2.4 ceil println

-3.9 ceil println

=={{header|ooRexx}}==

{{trans|NetRexx}}

{{uses from|OoRexx|RxMath}}

-- MathLoadFuncs & MathDropFuncs are no longer needed and are effectively NOPs

return arg(1)~trunc() + (arg(1) > 0) * (arg(1) \= arg(1)~trunc())

{{out}}

<pre>

=={{header|Oz}}==

[

{Exp 1.} %% 2.7183 Euler's number: not predefined

{Pow 2 3} %% 8 power; both arguments must be of the same type

]

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

=={{header|Pascal}}==

''See also [[#Delphi|Delphi]] and [[#Free Pascal|Free Pascal]]''<br/>

Following functions are defined by ISO standard 7185, Standard “Unextended” Pascal, and supported by any processor:

exp(1)

{ principal square root of `x` }

exp(x)

{ absolute value }

{{works with|Extended Pascal}}

Additionally, in Extended Pascal (ISO standard 10206) following operators and expressions can be used:

2 * arg(cmplx(0.0, maxReal))

{ power, yields same data type as `base`, `exponent` has to be an `integer` }

{ `exponent` are automatically promoted to an approximate `real` value, result }

{ is `complex` if `base` is `complex`, otherwise a `real` value }

<tt>Exp</tt>, <tt>sqrt</tt>, <tt>ln</tt>, and <tt>exp</tt> return <tt>real</tt> values, but a <tt>complex</tt> value if supplied with a <tt>complex</tt> value.

<tt>Abs</tt> returns an <tt>integer</tt> value if supplied with an <tt>integer</tt>, otherwise a <tt>real</tt> value.

=={{header|Perl}}==

exp(1); # e

use Math::Complex;

=={{header|Phix}}==

<span style="color: #0000FF;">?</span><span style="color: #004600;">E</span> <span style="color: #000080;font-style:italic;">-- Euler number</span>

<span style="color: #0000FF;">?</span><span style="color: #004600;">PI</span> <span style="color: #000080;font-style:italic;">-- pi</span>

<span style="color: #0000FF;">?</span><span style="color: #004600;">INVLN10</span> <span style="color: #000080;font-style:italic;">-- displays 0.434..</span>

<span style="color: #0000FF;">?</span><span style="color: #7060A8;">exp</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">/</span><span style="color: #004600;">INVLN10</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- displays 10.0</span>

=={{header|PHP}}==

M_PI; //pi

sqrt(x); //square root

floor(x); //floor

ceil(x); //ceiling

=={{header|Picat}}==

println(math.e),

println(math.pi),

println(math.pi**math.e), % power

println(pow(math.pi,math.e)), % power

{{out}}

(about 16 digits). The default precision is six, and can be changed with

'[http://software-lab.de/doc/refS.html#scl scl]':

(load "@lib/math.l")

(prinl (abs -123))