Real constants and functions: Difference between revisions
No edit summary |
Added DWScript |
||
Line 339: | Line 339: | ||
Ceil(x); // ceiling |
Ceil(x); // ceiling |
||
Power(x, y); // power</lang> |
Power(x, y); // power</lang> |
||
=={{header|DWScript}}== |
|||
See [[Real_constants_and_functions#Delphi|Delphi]]. |
|||
=={{header|E}}== |
=={{header|E}}== |
Revision as of 14:38, 19 August 2011
![Task](http://static.miraheze.org/rosettacodewiki/thumb/b/ba/Rcode-button-task-crushed.png/64px-Rcode-button-task-crushed.png)
You are encouraged to solve this task according to the task description, using any language you may know.
Show how to use the following math constants and functions in your language (if not available, note it):
- e (Euler's number)
- square root
- logarithm (any base allowed)
- exponential ()
- absolute value (a.k.a. "magnitude")
- floor (largest integer less than or equal to this number--not the same as truncate or int)
- ceiling (smallest integer not less than this number--not the same as round up)
- power ()
See also Trigonometric Functions
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>
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>
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> Output:
2.71828; 3.14159; 1.64872; 0.43429; 1.00000; 15.15426; 2.71828; 2.00000; 3.00000; 23.14069;
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).
AutoHotkey
The following math functions are built into AutoHotkey: <lang autohotkey>Sqrt(Number) ; square root Log(Number) ; returns logarithm (base 10) Ln(Number) ; returns natural logarithm (base e) Exp(N) ; returns e to the N power Abs(Number) ; absolute value Floor(Number) ; floor value Ceil(Number) ; ceiling value</lang> The following math operations are not built-in functions but can be performed using Autohotkey: <lang autohotkey>x**y ; x to the y power pi() { ; will return pi when custom function is called return 22/7 }</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>
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>
Power's note: With nawk or gawk,
2 ** -3.4
acts like2 ^ -3.4
. With mawk,2 ** -3.4
is a syntax error. Nawk allows**
, but its manual page only has^
. Gawk's manual warns, "The POSIX standard only specifies the use of `^' for exponentiation. For maximum portability, do not use the `**' operator."
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>
BASIC
<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>
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.
<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.
<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>
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 #define _USE_MATH_DEFINES
before the #include <math.h>
.
C++
<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(e) << "\nlg(100) = " << std::log10(100.0) << "\nexp(3) = " << std::exp(3.0) << "\n|-4.5| = " << std::abs(-4.5) // or std::fabs(4.0); 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>
C#
<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>
Chef
See Basic integer arithmetic#Chef for powers.
Clojure
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>
Common Lisp
<lang lisp>pi ;pi constant (sqrt x) ;square root (log x) ;natural logarithm (log x 10) ;logarithm base 10 (exp x) ;exponential (abs x) ;absolute value (floor x) ;floor (ceiling x) ;ceiling (expt x y) ;power</lang>
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>
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>
DWScript
See Delphi.
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>
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>
Fantom
The Float
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. 9f
<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:
> -3f.pow(2f) -9 > (-3f).pow(2f) 9
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>
Fortran
<lang fortran>e ! Not available. Can be calculated EXP(1) 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>
Go
<lang go>import "math"
// 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. math.E math.Pi
// The following functions all take and return the float64 data type.
math.Sqrt(x) // square root--cube root also available (math.Cbrt) // natural logarithm--log base 10, 2 also available (math.Log10, math.Log2) // also available is log1p, the log of 1+x. It is more accurate when x is near zero. math.Log(x) math.Exp(x) // exponential--exp base 10, 2 also available (math.Pow10, math.Exp2) math.Fabs(x) // absolute value math.Floor(x) // floor math.Ceil(x) // ceiling math.Pow(x,y) // power</lang>
Groovy
Math constants and functions are as outlined in the 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> Output:
22
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> Output:
49943.547010599876
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> Output:
NaN
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".
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>
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>
Icon and 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>
numbers provides floor and ceiling
Sample output:
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
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>
Java
All of these functions are in Java's Math 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>
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>
Liberty BASIC
Ceiling and floor easily implemented as functions.
sqr( is the LB function for square root.
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>
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>
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>
Mathematica
<lang Mathematica>E Pi Sqrt[x] Log[x] Log[b,x] Exp[x] Abs[x] Floor[x] Ceiling[x] Power[x, y]</lang> Where x is the number, and b the base. Exp[x] can also be inputted as E^x or Ex and Power[x,y] can be also inputted as x^y or xy. 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: <lang Mathematica>Log[1.23] => 0.207014 Log[10] => Log[10] Log[10,100] => 2 Log[E^4] => 4 Log[1 + I] => Log[1+I] Log[1. + I] => 0.346574 + 0.785398 I Ceiling[Pi] => 4 Floor[Pi] => 3 Sqrt[2] => Sqrt[2] Sqrt[4] => 2 Sqrt[9/2] => 3/Sqrt[2] Sqrt[3.5] => 1.87083 Sqrt[-5 + 12 I] => 2 + 3 I Sqrt[-4] => 2I Exp[2] => E^2 Exp[Log[4]] => 4</lang>
MAXScript
<lang maxscript>e -- Euler's number pi -- pi log x -- natural logarithm log10 x -- log base 10 exp x -- exponantial abs x -- absolute value floor x -- floor ceil x -- ceiling pow x y -- power</lang>
Metafont
<lang metafont>show mexp(256); % outputs e; since MF uses mexp(x) = exp(x/256) show 3.14159; % no pi constant built in; of course we can define it
% in several ways... even computing % C/2r (which would be funny since MF handles paths, % and a circle is a path...)
show sqrt2; % 1.41422, or in general sqrt(a) show mexp(256*x); % see e. show abs(x); % returns |x| (the absolute value of the number x, or
% the length of the vector x); it is the same as % length(x); plain Metafont in fact says: % let abs = length;
show floor(x); % floor show ceiling(x); % ceiling show x**y; % ** is not a built in: it is defined in the basic macros
% set for Metafont (plain Metafont) as a primarydef</lang>
Modula-3
Modula-3 uses a module that is a wrapper around C's math.h.
Note that all of these procedures (except the built ins) take LONGREALs as their argument, and return LONGREALs. <lang modula3>Math.E; Math.Pi; Math.sqrt(x); Math.log(x); Math.exp(x); ABS(x); (* Built in function. *) FLOOR(x); (* Built in function. *) CEILING(x); (* Built in function. *) Math.pow(x, y);</lang>
Objeck
<lang objeck>Float->Pi(); Float->E(); 4.0->SquareRoot(); 1.5->Log();
- exponential is not supported
3.99->Abs(); 3.99->Floor(); 3.99->Ceiling(); 4.5->Ceiling(2.0);</lang>
OCaml
Unless otherwise noted, the following functions are for floats only: <lang ocaml>sqrt x (* square root *) log x (* natural logarithm--log base 10 also available (log10) *) exp x (* exponential *) abs_float x (* absolute value *) abs x (* absolute value (for integers) *) floor x (* floor *) ceil x (* ceiling *) x ** y (* power *) -. x (* negation for floats *)</lang>
Octave
<lang octave>e % e pi % pi sqrt(pi) % square root log(e) % natural logarithm exp(pi) % exponential abs(-e) % absolute value floor(pi) % floor ceil(pi) % ceiling e**pi % power</lang>
Oz
<lang oz>{ForAll
[ {Exp 1.} %% 2.7183 Euler's number: not predefined 4. * {Atan2 1. 1.} %% 3.1416 pi: not predefined {Sqrt 81.} %% 9.0 square root; expects a float {Log 2.7183} %% 1.0 natural logarithm {Abs ~1} %% 1 absolute value; expects a float or an integer {Floor 1.999} %% 1.0 floor; expects and returns a float {Ceil 1.999} %% 2.0 ceiling; expects and returns a float {Pow 2 3} %% 8 power; both arguments must be of the same type ] Show}</lang>
PARI/GP
<lang parigp>[exp(1), Pi, sqrt(2), log(2), abs(2), floor(2), ceil(2), 2^3]</lang>
Perl
<lang perl>use POSIX; # for floor() and ceil()
exp(1); # e 4 * atan2(1, 1); # pi sqrt($x); # square root log($x); # natural logarithm; log10() available in POSIX module exp($x); # exponential abs($x); # absolute value floor($x); # floor ceil($x); # ceiling $x ** $y; # power</lang>
Perl 6
<lang perl6>say e; # e say pi; # pi say sqrt 2; # Square root say log 2; # Natural logarithm say exp 42; # Exponentiation base e say abs -2; # Absolute value say floor pi; # Floor say ceiling pi; # Ceiling say 4**7; # Exponentiation</lang>
PHP
<lang php>M_E; //e M_PI; //pi sqrt(x); //square root log(x); //natural logarithm--log base 10 also available (log10) exp(x); //exponential abs(x); //absolute value floor(x); //floor ceil(x); //ceiling pow(x,y); //power</lang>
PL/I
<lang PL/I>/* e not available other than by using exp(1q0).*/ /* pi not available other than by using a trig function such as atan */ y = sqrt(x); y = log(x); y = log2(x); y = log10(x); y = exp(x); y = abs(x); y = floor(x); y = ceil(x); a = x**y; /* power */ /* extra functions: */ y = erf(x); /* the error function. */ y = erfc(x); /* the error function complemented. */ y = gamma (x); y = loggamma (x);</lang>
PicoLisp
PicoLisp has only limited floating point support (scaled bignum arithmetics). It can handle real numbers with as many positions after the decimal point as desired, but is practically limited by the precision of the C-library functions (about 16 digits). The default precision is six, and can be changed with 'scl': <lang PicoLisp>(scl 12) # 12 places after decimal point (load "@lib/math.l")
(prinl (format (exp 1.0) *Scl)) # e, exp (prinl (format pi *Scl)) # pi
(prinl (format (pow 2.0 0.5) *Scl)) # sqare root (prinl (format (sqrt (* 2.0 1.0)) *Scl))
(prinl (format (log 2.0) *Scl)) # logarithm (prinl (format (exp 4.0) *Scl)) # exponential
(prinl (format (abs -7.2) *Scl)) # absolute value (prinl (abs -123))
(prinl (format (pow 3.0 4.0) *Scl)) # power</lang> Output:
2.718281828459 3.141592653590 1.414213562373 1.414213562373 0.693147180560 54.598150033144 7.200000000000 123 81.000000000000
Pop11
<lang pop11>pi ;;; Number Pi sqrt(x) ;;; Square root log(x) ;;; Natural logarithm exp(x) ;;; Exponential function abs(x) ;;; Absolute value x ** y ;;; x to the power y</lang>
The number e is not provided directly, one has to compute 'exp(1)' instead. Also, floor 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>
PowerShell
Since PowerShell has access to .NET all this can be achieved using the .NET Base Class Library: <lang powershell>Write-Host ([Math]::E) Write-Host ([Math]::Pi) Write-Host ([Math]::Sqrt(2)) Write-Host ([Math]::Log(2)) Write-Host ([Math]::Exp(2)) Write-Host ([Math]::Abs(-2)) Write-Host ([Math]::Floor(3.14)) Write-Host ([Math]::Ceiling(3.14)) Write-Host ([Math]::Pow(2, 3))</lang>
PureBasic
<lang PureBasic>Debug #E Debug #PI Debug Sqr(f) Debug Log(f) Debug Exp(f) Debug Log10(f) Debug Abs(f) Debug Pow(f,f)</lang>
Python
<lang python>import math
math.e # e math.pi # pi math.sqrt(x) # square root (Also commonly seen as x ** 0.5 to obviate importing the math module) math.log(x) # natural logarithm math.log10(x) # base 10 logarithm math.exp(x) # exponential abs(x) # absolute value math.floor(x) # floor math.ceil(x) # ceiling x ** y # exponentiation pow(x,y,n) # exponentiation modulo n (useful in certain encryption/decryption algorithms)</lang>
R
<lang R>exp(1) # e pi # pi sqrt(x) # square root log(x) # natural logarithm log10(x) # base 10 logarithm log(x, y) # arbitrary base logarithm exp(x) # exponential abs(x) # absolute value floor(x) # floor ceiling(x) # ceiling x^y # power</lang>
REXX
REXX has no built-in functions for trig functions, square root, pi, exponential (e raised to a power), logrithms and other similar functions.
REXX doesn't have any built-in (math) constants. <lang rexx>a=abs(y) /*takes the absolute value of y.*/
r=x**y /*only supports integer powers. */</lang>
CEILING
A ceiling function for REXX: <lang rexx> ceiling: procedure; parse arg x; t=trunc(x); return t+(x>0)*(x\=t) </lang>
FLOOR
A floor function for REXX: <lang rexx> floor: procedure; parse arg x; t=trunc(x); return t-(x<0)-(x\=t) </lang>
SQRT (square root)
A [principal] square root (SQRT) function for REXX (arbitrary precision): <lang rexx>/*─────────────────────────────────────SQRT subroutine──────────────────*/ sqrt: procedure /*square root subroutine. */
/*returns the principal SQRT. */
r= /*list of square roots calculated*/
do j=1 for arg() /*process each argument specified*/ a=arg(j) /*extract the argument specified*/ do k=1 for words(a) /*process each number specified. */ r=r sqrt_(word(a,k)) /*calculate sqrt, add to results.*/ end end
return space(r) /*return list of SQRTs calculated*/
/*─────────────────────────────────────SQRT_ subroutine─────────────────*/
sqrt_: procedure; parse arg x 1 ox
if x=0 then return 0 /*handle special case of zero. */
if x= then return /*if null, then return null. */
if pos(',',x)\==0 then do;x=space(translate(x,,","),0);ox=x;end /*del ,*/
if \datatype(x,'N') then return '[n/a]' /*not numberic? not applicable*/
x=abs(x) /*just use positive value of X. */
d=digits() /*get the current precision. */
numeric digits 11 /*use "small" precision at first.*/
g=sqrt_guess() /*try get a good 1st guesstimate.*/
m.=11 /*technique uses just enough digs*/
p=d+d%4+2 /*# of iterations (calculations).*/
/*Note: to insure enough accuracy*/ /*for the result, the precsion */ /*during the SQRT calcuations is */ /*increased by two extra digits. */ do j=0 while p>9 m.j=p p=p%2+1 end
do k=j+5 to 0 by -1 if m.k>11 then numeric digits m.k /*each iteration, increase digits*/ g=.5*(g+x/g) /*do the nitty-gritty calculation*/ end /* .5* is faster than /2 */
numeric digits d /*restore the original precision.*/ return (g/1)left('i',ox<0) /*normalize to old digs, complex?*/
sqrt_guess: numeric form scientific /*force scientific form of number*/
parse value format(x,2,1,,0) 'E0' with g 'E' _ . /*get X's exponent.*/
return g*.5'E'_%2 /*1st guesstimate. */
/*┌────────────────────────────────────────────────────────────────────┐
┌─┘ √ └─┐
│ While the above REXX code seems like it's doing a lot of extra work, │
│ it saves a substanial amount of processing time when the precision │
│ (DIGITs) is a lot greater than the default (9 digits). │
│ │
│ Indeed, when computing square roots in the hundreds (even thousands) │
│ of digits, this technique reduces the amount of CPU processing time │
│ by keeping the length of the computations to a minimim (due to a large │
│ precision) while the accuracy (at the beginning) isn't important for │
│ caculating the guesstimate (the running square root guess). │
└─┐ √ ┌─┘
└────────────────────────────────────────────────────────────────────┘*/</lang>
SQRT (simple version)
<lang rexx>/*─────────────────────────────────────SQRT subroutine──────────────────*/ sqrt: procedure; parse arg x /*a simple SQRT subroutine. */ if x=0 then return 0 /*handle special case of zero. */ d=digits() /*get the current precision. */ numeric digits digits()+2 /*ensure extra precision. */ g=x/4 /*try get a so-so 1st guesstimate*/ old=0 /*set OLD guess to zero. */
do forever g=.5*(g+x/g) /*do the nitty-gritty calculation*/ if g=old then leave /*if G is the same as old, quit. */ old=g /*save OLD for next iteration. */ end /* .5* is faster than /2 */
numeric digits d /*restore the original precision.*/ return g/1 /*normalize to old precision. */</lang>
other
Other mathetical-type functions supported are: <lang rexx>numeric digits ddd /*sets the current precision to DDD */ numeric fuzz fff /*arithmetic comparisons with FFF fuzzy*/ numeric form kkk /*exponential: scientific | engineering*/
low=min(a,b,c,d,e,f,g, ...) /*finds the min of specified arguments.*/ big=min(a,b,c,d,e,f,g, ...) /*finds the max of specified arguments.*/
rrr=random(low,high) /*gets a random integer from LOW-->HIGH*/ arr=random(low,high,seed) /* ... with a seed (to make repeatable)*/
mzp=sign(x) /*finds the sign of x (-1, 0, +1). */
fs=format(x) /*formats X with the current DIGITS() */ fb=format(x,bbb) /* BBB digs before decimal*/ fa=format(x,bbb,aaa) /* AAA digs after decimal*/ fa=format(x,,0) /* rounds X to an integer.*/ fe=format(x,,eee) /* exponent has eee places. */ ft=format(x,,eee,ttt) /*if x exceeds TTT digits, force exp. */
hh=b2x(bbb) /*converts binary/bits to hexadecimal. */ dd=c2d(ccc) /*converts character to decimal. */ hh=c2x(ccc) /*converts character to hexadecimal. */ cc=d2c(ddd) /*converts decimal to character. */ hh=d2x(ddd) /*converts decimal to hexadecimal. */ bb=x2b(hhh) /*converts hexadecimal to binary (bits)*/ cc=x2c(hhh) /*converts hexadecimal to character. */ dd=x2d(hhh) /*converts hexadecimal to decimal. */</lang>
RLaB
Mathematical Constants
RLaB has a number of mathematical constants built-in within the list const. These facilities are provided through the Gnu Science Library [[1]]. <lang RLaB>>> const
e euler ln10 ln2 lnpi log10e log2e pi pihalf piquarter rpi sqrt2 sqrt2r sqrt3 sqrtpi tworpi</lang>
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. <lang RLaB>>> mks
F G J L N Na R0 Ry Tsp V0 a a0 acre alpha atm au bar barn btu c cal cgal cm cm2 cm3 ct cup curie day dm dm2 dm3 dyne e eV eps0 erg fathom floz ft ftcan ftlam g gal gauss gf h ha hbar hour hp in inH2O inHg kSB kb kcal km km2 km3 kmh knot kpf lam lb lumen lux ly mHg mSun me micron mil mile min mm mm2 mm3 mmu mn mp mph mu0 mub mue mun mup nmi oz pal parsec pf phot poise psi rad roe stilb stokes tcs therm tntton ton torr toz tsp uam ukgal ukton uston week yd</lang>
Elementary Functions
<lang RLaB>>> x = rand() >> sqrt(x)
2.23606798
>> log(x)
1.60943791
>> log10(x)
0.698970004
>> exp(x)
148.413159
>> abs(x)
5
>> floor(x)
5
>> ceil(x)
5
>> x .^ 2
25</lang>
Ruby
<lang ruby>Math::E #e Math::PI #pi Math.sqrt(x) #square root Math.log(x) #natural logarithm Math.log10(x) #base 10 logarithm Math.exp(x) #exponential x.abs #absolute value x.floor #floor x.ceil #ceiling x ** y #power</lang>
Scheme
<lang scheme>(sqrt x) ;square root (log x) ;natural logarithm (exp x) ;exponential (abs x) ;absolute value (floor x) ;floor (ceiling x) ;ceiling (expt x y) ;power</lang>
Slate
<lang slate>numerics E. numerics Pi. n sqrt. n log10. "base 10 logarithm" n ln. "natural logarithm" n log: m. "arbitrary base logarithm" n exp. "exponential" n abs. "absolute value" n floor. n ceiling. n raisedTo: anotherNumber</lang>
Smalltalk
<lang smalltalk>Float e. Float pi. aNumber sqrt. aNumber log. "base 10 logarithm" aNumber ln. "natural logarithm" aNumber exp. "exponential" aNumber abs. "absolute value" aNumber floor. aNumber ceiling. aNumber raisedTo: anotherNumber</lang>
Standard ML
<lang sml>Math.e; (* e *) Math.pi; (* pi *) Math.sqrt x; (* square root *) Math.ln x; (* natural logarithm--log base 10 also available (Math.log10) *) Math.exp x; (* exponential *) abs x; (* absolute value *) floor x; (* floor *) ceil x; (* ceiling *) Math.pow (x, y); (* power *) ~ x; (* negation *)</lang>
Tcl
<lang tcl>expr {exp(1)} ;# e expr {4 * atan(1)} ;# pi -- also, simpler: expr acos(-1) expr {sqrt($x)} ;# square root expr {log($x)} ;# natural logarithm, also log10 expr {exp($x)} ;# exponential expr {abs($x)} ;# absolute value expr {floor($x)} ;# floor expr {ceil($x)} ;# ceiling expr {$x**$y} ;# power, also pow($x,$y)</lang> The constants and are also available with high precision in a support library.
<lang tcl>package require math::constants math::constants::constants e pi puts "e = $e, pi = $pi"</lang>
TI-89 BASIC
Mathematical | TI-89 | Notes |
---|---|---|
ℯ |
(U+212F SCRIPT SMALL E) | |
π |
(U+03C0 GREEK SMALL LETTER PI) | |
√(x) |
(U+221A SQUARE ROOT) | |
ln(x)
| ||
log(x)
| ||
log(b, x) |
The optional base argument comes first | |
floor(x)
| ||
ceiling(x)
| ||
x^y
|
- Programming Tasks
- Basic language learning
- Arithmetic operations
- ActionScript
- Ada
- ALGOL 68
- AutoHotkey
- AWK
- BASIC
- Bc
- Bc -l
- C
- C++
- C sharp
- Chef
- Clojure
- Common Lisp
- D
- Delphi
- DWScript
- E
- Factor
- Fantom
- Forth
- Fortran
- Go
- Groovy
- Haskell
- HicEst
- Icon
- Unicon
- Icon Programming Library
- J
- Java
- JavaScript
- Liberty BASIC
- Logo
- Lua
- Mathematica
- MAXScript
- Metafont
- Modula-3
- Objeck
- OCaml
- Octave
- Oz
- PARI/GP
- Perl
- Perl 6
- PHP
- PL/I
- PicoLisp
- Pop11
- PowerShell
- PureBasic
- Python
- R
- REXX
- RLaB
- Ruby
- Scheme
- Slate
- Smalltalk
- Standard ML
- Tcl
- Tcllib
- TI-89 BASIC
- GUISS/Omit
- M4/Omit
- ML/I/Omit
- UNIX Shell/Omit