Real constants and functions: Difference between revisions

{{trans|Python}}

 

math:pi // pi

sqrt(x) // square root

floor(x) // floor

ceil(x) // ceiling

 

=={{header|ACL2}}==

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

 

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

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

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

Floor(x); // floor

Ceil(x); // ceiling

 

=={{header|DWScript}}==

 

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

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

log # Naperian log

exp

floor

 

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

 

 

{{out}}

1.0

1.0

2.718281828459045

1

 

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

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

Print exptype$(Ln(1212%))="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

}

Checkit

 

=={{header|Maple}}==

 

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 E

echo sqrt(x)

echo ln(x)

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

 

=={{header|Perl}}==

 

exp(1); # e

 

use Math::Complex;

 

=={{header|Phix}}==

 

=={{header|PHP}}==

M_PI; //pi

sqrt(x); //square root

floor(x); //floor

ceil(x); //ceiling

 

=={{header|PicoLisp}}==

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

 

{{out}}

<pre>2.718281828459

 

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

/* pi not available other than by using a trig function such as: pi=4*atan(1) */

y = sqrt(x);

y = erfc(x); /* the error function complemented. */

y = gamma (x);

 

=={{header|Pop11}}==

sqrt(x) ;;; Square root

log(x) ;;; Natural logarithm

exp(x) ;;; Exponential function

abs(x) ;;; Absolute value

 

The number e is not provided directly, one has to compute 'exp(1)'

=={{header|PowerShell}}==

Since PowerShell has access to .NET all this can be achieved using the .NET Base Class Library:

Write-Host ([Math]::Pi)

Write-Host ([Math]::Sqrt(2))

Write-Host ([Math]::Floor(3.14))

Write-Host ([Math]::Ceiling(3.14))

 

=={{header|Python}}==

 

math.e # e

 

# The math module constants and functions can, of course, be imported directly by:

 

=={{header|R}}==

pi # pi

sqrt(x) # square root

floor(x) # floor

ceiling(x) # ceiling

 

=={{header|Racket}}==

pi ; pi

(sqrt x) ; square root

(floor x) ; floor

(ceiling x) ; ceiling

 

=={{header|Raku}}==

(formerly Perl 6)

say π; # or pi # pi

say τ; # or tau # tau

say pi.ceiling; # Ceiling

 

 

=={{header|REXX}}==

REXX doesn't have any built-in (math) constants.

===abs===

===exponentiation (**)===

/*Y may be negative, zero, positive.*/

 

===ceiling===

A ceiling function for REXX:

ceiling: procedure; parse arg x; t=trunc(x); return t+(x>0)*(x\=t)

 

===floor===

A floor function for REXX:

floor: procedure; parse arg x; t=trunc(x); return t-(x<0)-(x\=t)

 

===sqrt (optimized)===

A [principal] square root (SQRT) function for REXX &nbsp; (with arbitrary precision):

sqrt: procedure; parse arg x; if x=0 then return 0 /*handle 0 case.*/

if \datatype(x,'N') then return '[n/a]' /*Not Applicable ───if not numeric.*/

/* [↓] normalize √ ──► original digits*/

numeric digits d /* [↓] make answer complex if X < 0. */

╔═╝ __ ╚═╗

║ √ ║

║ __ ║

╚═╗ √ ╔═╝

 

===sqrt (simple)===

sqrt: procedure; arg x /*a simplistic SQRT subroutine.*/

if x=0 then return 0 /*handle special case of zero. */

end /*forever*/ /* [↑] ···'til we run out of digs*/

numeric digits d /*restore the original precision.*/

 

===other===

Other mathematical-type functions supported are:

numeric fuzz fff /*arithmetic comparisons with FFF fuzzy*/

numeric form kkk /*exponential: scientific | engineering*/

bb=x2b(hhh) /*converts hexadecimal to binary (bits)*/

cc=x2c(hhh) /*converts hexadecimal to character. */

 

=={{header|Ring}}==

See "Mathematical Functions" + nl

See "Sin(0) = " + sin(0) + nl

 

see "sqrt(16) = " + sqrt(16) + nl

 

=={{header|RLaB}}==

 

RLaB has a number of mathematical constants built-in within the list ''const''. These facilities are provided through the Gnu Science Library [[http://www.gnu.org/software/gsl]].

e euler ln10 ln2 lnpi

log10e log2e pi pihalf piquarter

rpi sqrt2 sqrt2r sqrt3 sqrtpi

 

=== Physical Constants ===

Another list of physical constants and unit conversion factors exists and is called ''mks''.

Here the conversion goes between that particular unit and the equivalent unit in, one and only, metric system.

F G J L N

Na R0 Ry Tsp V0

therm tntton ton torr toz

tsp uam ukgal ukton uston

 

=== Elementary Functions ===

>> sqrt(x)

2.23606798

5

>> x .^ 2

 

=={{header|Ruby}}==

x.magnitude #absolute value

x.floor #floor

log10(x) #base 10 logarithm

exp(x) #exponential

 

=={{header|Rust}}==

 

fn main() {

 

assert_eq!(x, 4.0);

 

=={{header|Scala}}==

println(math.E) // e

println(math.Pi) // pi

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

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

 

=={{header|Scheme}}==

(log x) ;natural logarithm

(exp x) ;exponential

(floor x) ;floor

(ceiling x) ;ceiling

 

=={{header|Seed7}}==

 

=={{header|Sidef}}==

Num.pi # pi

x.sqrt # square root

x.floor # floor

x.ceil # ceiling

 

=={{header|Slate}}==

numerics Pi.

n sqrt.

n floor.

n ceiling.

 

=={{header|Smalltalk}}==

Float pi.

aNumber sqrt.

aNumber floor.

aNumber ceiling.

 

=={{header|Sparkling}}==

print(M_E);

 

 

// power

 

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

Math.pi; (* pi *)

Math.sqrt x; (* square root *)

ceil x; (* ceiling *)

Math.pow (x, y); (* power *)

 

=={{header|Stata}}==

scalar y=3

di exp(1)

di floor(x)

di ceil(x)

 

=={{header|Swift}}==

 

M_E // e

floor(x) // floor

ceil(x) // ceiling

 

=={{header|Tcl}}==

expr {4 * atan(1)} ;# pi -- also, simpler: expr acos(-1)

expr {sqrt($x)} ;# square root

expr {floor($x)} ;# floor

expr {ceil($x)} ;# ceiling

The constants <math>e</math> and <math>\pi</math> are also available with high precision in a support library.

{{tcllib|math::constants}}

math::constants::constants e pi

 

=={{header|UNIX Shell}}==

{{works with|ksh93}}

ksh93 exposes math functions from the C math library

echo $(( acos(-1) )) # PI

x=5

echo $(( ceil(x) )) # ceiling

x=10 y=3

 

{{out}}

-5

1000</pre>

 

=={{header|Wren}}==

 

System.print("e = %(e)")

System.print("sqrt(2) = %(2.sqrt)")

System.print("ln(3) = %(3.log)") // log base e

System.print("floor(e) = %(e.floor)")

System.print("ceil(e) = %(e.ceil)")

 

{{out}}

sqrt(2) = 1.4142135623731

ln(3) = 1.0986122886681

abs(-e) = 2.718281828459

floor(e) = 2

 

=={{header|XPL0}}==

 

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

RlOut(0, float(fix(1.001+0.5))); CrLf(0); \ceiling rounds toward +infinity

RlOut(0, Power(sqrt(2.0), 4.0)); CrLf(0); \sqrt is an inline function and

 

{{out}}

4.0000000000000000

</pre>

 

=={{header|zkl}}==

(0.0).e.pi // pi, yep, all floats

(2.0).sqrt() // square root

x.pow(y) // x raised to the y power

x.ceil() // ceiling

 

{{omit from|GUISS}}