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

 

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

Debug #PI

Debug Sqr(f)

Debug Log10(f)

Debug Abs(f)

 

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

print "PI:";chr$(9); 22/7

print "Sqr2:";chr$(9); SQR(2)

print "Floor:";chr$(9); INT(1.534)

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

<pre>exp: 2.71828183

PI: 3.14285707

 

=={{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|TI-89 BASIC}}==

 

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

IF x > 0 THEN

LET floor = INT(x)

PRINT "ceil = "; CEIL(x) ! ceiling

PRINT "power = "; x ^ y ! power

 

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

 

=={{header|Wren}}==

 

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

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

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

 

{{out}}

 

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

 

=={{header|Yabasic}}==

print "pi = ", pi

print "ceil = ", ceil(-euler) // ceiling

print "power = ", x ^ y, " ", x ** y // power

{{out}}

<pre>e = 2.71828

 

=={{header|Zig}}==

 

pub fn main() void {

std.debug.print("ceil(x) = {d}\n", .{std.math.ceil(x)});

std.debug.print("pow(f64, -x, x) = {d}\n", .{std.math.pow(f64, -x, x)});

 

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