Mathematics

Mathematical Operators

`Base.:-`Method

-(x)

Unary minus operator.

source

`Base.:+`Function

+(x, y...)

Addition operator. x+y+z+... calls this function with all arguments, i.e. +(x, y, z, ...).

source

`Base.:-`Method

-(x, y)

Subtraction operator.

source

`Base.:*`Method

*(x, y...)

Multiplication operator. x*y*z*... calls this function with all arguments, i.e. *(x, y, z, ...).

source

`Base.:/`Function

/(x, y)

Right division operator: multiplication of x by the inverse of y on the right. Gives floating-point results for integer arguments.

source

`Base.:\`Method

\(x, y)

Left division operator: multiplication of y by the inverse of x on the left. Gives floating-point results for integer arguments.

julia> 3 \ 6
2.0

julia> inv(3) * 6
2.0

julia> A = [1 2; 3 4]; x = [5, 6];

julia> A \ x
2-element Array{Float64,1}:
 -4.0
  4.5

julia> inv(A) * x
2-element Array{Float64,1}:
 -4.0
  4.5

source

`Base.:^`Method

^(x, y)

Exponentiation operator. If x is a matrix, computes matrix exponentiation.

If y is an Int literal (e.g. 2 in x^2 or -3 in x^-3), the Julia code x^y is transformed by the compiler to Base.literal_pow(^, x, Val{y}), to enable compile-time specialization on the value of the exponent. (As a default fallback we have Base.literal_pow(^, x, Val{y}) = ^(x,y), where usually ^ == Base.^ unless ^ has been defined in the calling namespace.)

julia> 3^5
243

julia> A = [1 2; 3 4]
2×2 Array{Int64,2}:
 1  2
 3  4

julia> A^3
2×2 Array{Int64,2}:
 37   54
 81  118

source

`Base.fma`Function

fma(x, y, z)

Computes x*y+z without rounding the intermediate result x*y. On some systems this is significantly more expensive than x*y+z. fma is used to improve accuracy in certain algorithms. See muladd.

source

`Base.muladd`Function

muladd(x, y, z)

Combined multiply-add, computes x*y+z in an efficient manner. This may on some systems be equivalent to x*y+z, or to fma(x,y,z). muladd is used to improve performance. See fma.

Example

julia> muladd(3, 2, 1)
7

julia> 3 * 2 + 1
7

source

`Base.div`Function

div(x, y)
÷(x, y)

The quotient from Euclidean division. Computes x/y, truncated to an integer.

julia> 9 ÷ 4
2

julia> -5 ÷ 3
-1

source

`Base.fld`Function

fld(x, y)

Largest integer less than or equal to x/y.

julia> fld(7.3,5.5)
1.0

source

`Base.cld`Function

cld(x, y)

Smallest integer larger than or equal to x/y.

julia> cld(5.5,2.2)
3.0

source

`Base.mod`Function

mod(x, y)
rem(x, y, RoundDown)

The reduction of x modulo y, or equivalently, the remainder of x after floored division by y, i.e.

x - y*fld(x,y)

if computed without intermediate rounding.

The result will have the same sign as y, and magnitude less than abs(y) (with some exceptions, see note below).

Note

When used with floating point values, the exact result may not be representable by the type, and so rounding error may occur. In particular, if the exact result is very close to y, then it may be rounded to y.

julia> mod(8, 3)
2

julia> mod(9, 3)
0

julia> mod(8.9, 3)
2.9000000000000004

julia> mod(eps(), 3)
2.220446049250313e-16

julia> mod(-eps(), 3)
3.0

source

rem(x::Integer, T::Type{<:Integer}) -> T
mod(x::Integer, T::Type{<:Integer}) -> T
%(x::Integer, T::Type{<:Integer}) -> T

Find y::T such that x ≡ y (mod n), where n is the number of integers representable in T, and y is an integer in [typemin(T),typemax(T)]. If T can represent any integer (e.g. T == BigInt), then this operation corresponds to a conversion to T.

julia> 129 % Int8
-127

source

`Base.rem`Function

rem(x, y)
%(x, y)

Remainder from Euclidean division, returning a value of the same sign as x, and smaller in magnitude than y. This value is always exact.

julia> x = 15; y = 4;

julia> x % y
3

julia> x == div(x, y) * y + rem(x, y)
true

source

`Base.Math.rem2pi`Function

rem2pi(x, r::RoundingMode)

Compute the remainder of x after integer division by 2π, with the quotient rounded according to the rounding mode r. In other words, the quantity

x - 2π*round(x/(2π),r)

without any intermediate rounding. This internally uses a high precision approximation of 2π, and so will give a more accurate result than rem(x,2π,r)

if r == RoundNearest, then the result is in the interval $[-π, π]$. This will generally be the most accurate result.
if r == RoundToZero, then the result is in the interval $[0, 2π]$ if x is positive,. or $[-2π, 0]$ otherwise.
if r == RoundDown, then the result is in the interval $[0, 2π]$.
if r == RoundUp, then the result is in the interval $[-2π, 0]$.

Example

julia> rem2pi(7pi/4, RoundNearest)
-0.7853981633974485

julia> rem2pi(7pi/4, RoundDown)
5.497787143782138

source

`Base.Math.mod2pi`Function

mod2pi(x)

Modulus after division by 2π, returning in the range $[0,2π)$.

This function computes a floating point representation of the modulus after division by numerically exact 2π, and is therefore not exactly the same as mod(x,2π), which would compute the modulus of x relative to division by the floating-point number 2π.

Example

julia> mod2pi(9*pi/4)
0.7853981633974481

source

`Base.divrem`Function

divrem(x, y)

The quotient and remainder from Euclidean division. Equivalent to (div(x,y), rem(x,y)) or (x÷y, x%y).

julia> divrem(3,7)
(0, 3)

julia> divrem(7,3)
(2, 1)

source

`Base.fldmod`Function

fldmod(x, y)

The floored quotient and modulus after division. Equivalent to (fld(x,y), mod(x,y)).

source

`Base.fld1`Function

fld1(x, y)

Flooring division, returning a value consistent with mod1(x,y)

`Base.mod1`Function

mod1(x, y)

Modulus after flooring division, returning a value r such that mod(r, y) == mod(x, y) in the range $(0, y]$ for positive y and in the range $[y,0)$ for negative y.

julia> mod1(4, 2)
2

julia> mod1(4, 3)
1

source

`Base.fldmod1`Function

fldmod1(x, y)

Return (fld1(x,y), mod1(x,y)).

`Base.://`Function

//(num, den)

Divide two integers or rational numbers, giving a Rational result.

julia> 3 // 5
3//5

julia> (3 // 5) // (2 // 1)
3//10

source

`Base.rationalize`Function

rationalize([T<:Integer=Int,] x; tol::Real=eps(x))

Approximate floating point number x as a Rational number with components of the given integer type. The result will differ from x by no more than tol. If T is not provided, it defaults to Int.

julia> rationalize(5.6)
28//5

julia> a = rationalize(BigInt, 10.3)
103//10

julia> typeof(numerator(a))
BigInt

source

`Base.numerator`Function

numerator(x)

Numerator of the rational representation of x.

julia> numerator(2//3)
2

julia> numerator(4)
4

source

`Base.denominator`Function

denominator(x)

Denominator of the rational representation of x.

julia> denominator(2//3)
3

julia> denominator(4)
1

source

`Base.:<<`Function

<<(x, n)

Left bit shift operator, x << n. For n >= 0, the result is x shifted left by n bits, filling with 0s. This is equivalent to x * 2^n. For n < 0, this is equivalent to x >> -n.

julia> Int8(3) << 2
12

julia> bits(Int8(3))
"00000011"

julia> bits(Int8(12))
"00001100"

`Base.:>>`Function

>>(x, n)

Right bit shift operator, x >> n. For n >= 0, the result is x shifted right by n bits, where n >= 0, filling with 0s if x >= 0, 1s if x < 0, preserving the sign of x. This is equivalent to fld(x, 2^n). For n < 0, this is equivalent to x << -n.

julia> Int8(13) >> 2
3

julia> bits(Int8(13))
"00001101"

julia> bits(Int8(3))
"00000011"

julia> Int8(-14) >> 2
-4

julia> bits(Int8(-14))
"11110010"

julia> bits(Int8(-4))
"11111100"

`Base.:>>>`Function

>>>(x, n)

Unsigned right bit shift operator, x >>> n. For n >= 0, the result is x shifted right by n bits, where n >= 0, filling with 0s. For n < 0, this is equivalent to x << -n.

For Unsigned integer types, this is equivalent to >>. For Signed integer types, this is equivalent to signed(unsigned(x) >> n).

julia> Int8(-14) >>> 2
60

julia> bits(Int8(-14))
"11110010"

julia> bits(Int8(60))
"00111100"

BigInts are treated as if having infinite size, so no filling is required and this is equivalent to >>.

`Base.colon`Function

colon(start, [step], stop)

Called by : syntax for constructing ranges.

julia> colon(1, 2, 5)
1:2:5

source

:(start, [step], stop)

Range operator. a:b constructs a range from a to b with a step size of 1, and a:s:b is similar but uses a step size of s. These syntaxes call the function colon. The colon is also used in indexing to select whole dimensions.

source

`Base.range`Function

range(start, [step], length)

Construct a range by length, given a starting value and optional step (defaults to 1).

source

`Base.OneTo`Type

Base.OneTo(n)

Define an AbstractUnitRange that behaves like 1:n, with the added distinction that the lower limit is guaranteed (by the type system) to be 1.

source

`Base.StepRangeLen`Type

StepRangeLen{T,R,S}(ref::R, step::S, len, [offset=1])

A range r where r[i] produces values of type T, parametrized by a reference value, a step, and the length. By default ref is the starting value r[1], but alternatively you can supply it as the value of r[offset] for some other index 1 <= offset <= len. In conjunction with TwicePrecision this can be used to implement ranges that are free of roundoff error.

source

`Base.:==`Function

==(x, y)

Generic equality operator, giving a single Bool result. Falls back to ===. Should be implemented for all types with a notion of equality, based on the abstract value that an instance represents. For example, all numeric types are compared by numeric value, ignoring type. Strings are compared as sequences of characters, ignoring encoding.

Follows IEEE semantics for floating-point numbers.

Collections should generally implement == by calling == recursively on all contents.

New numeric types should implement this function for two arguments of the new type, and handle comparison to other types via promotion rules where possible.

source

`Base.:!=`Function

!=(x, y)
≠(x,y)

Not-equals comparison operator. Always gives the opposite answer as ==. New types should generally not implement this, and rely on the fallback definition !=(x,y) = !(x==y) instead.

julia> 3 != 2
true

julia> "foo" ≠ "foo"
false

source

`Base.:!==`Function

!==(x, y)
≢(x,y)

Equivalent to !(x === y).

julia> a = [1, 2]; b = [1, 2];

julia> a ≢ b
true

julia> a ≢ a
false

source

`Base.:<`Function

<(x, y)

Less-than comparison operator. New numeric types should implement this function for two arguments of the new type. Because of the behavior of floating-point NaN values, < implements a partial order. Types with a canonical partial order should implement <, and types with a canonical total order should implement isless.

julia> 'a' < 'b'
true

julia> "abc" < "abd"
true

julia> 5 < 3
false

source

`Base.:<=`Function

<=(x, y)
≤(x,y)

Less-than-or-equals comparison operator.

julia> 'a' <= 'b'
true

julia> 7 ≤ 7 ≤ 9
true

julia> "abc" ≤ "abc"
true

julia> 5 <= 3
false

source

`Base.:>`Function

>(x, y)

Greater-than comparison operator. Generally, new types should implement < instead of this function, and rely on the fallback definition >(x, y) = y < x.

julia> 'a' > 'b'
false

julia> 7 > 3 > 1
true

julia> "abc" > "abd"
false

julia> 5 > 3
true

source

`Base.:>=`Function

>=(x, y)
≥(x,y)

Greater-than-or-equals comparison operator.

julia> 'a' >= 'b'
false

julia> 7 ≥ 7 ≥ 3
true

julia> "abc" ≥ "abc"
true

julia> 5 >= 3
true

source

`Base.cmp`Function

cmp(x,y)

Return -1, 0, or 1 depending on whether x is less than, equal to, or greater than y, respectively. Uses the total order implemented by isless. For floating-point numbers, uses < but throws an error for unordered arguments.

julia> cmp(1, 2)
-1

julia> cmp(2, 1)
1

julia> cmp(2+im, 3-im)
ERROR: MethodError: no method matching isless(::Complex{Int64}, ::Complex{Int64})
[...]

source

`Base.:~`Function

~(x)

Bitwise not.

Examples

julia> ~4
-5

julia> ~10
-11

julia> ~true
false

source

`Base.:&`Function

&(x, y)

Bitwise and.

Examples

julia> 4 & 10
0

julia> 4 & 12
4

source

`Base.:|`Function

|(x, y)

Bitwise or.

Examples

julia> 4 | 10
14

julia> 4 | 1
5

source

`Base.xor`Function

xor(x, y)
⊻(x, y)

Bitwise exclusive or of x and y. The infix operation a ⊻ b is a synonym for xor(a,b), and ⊻ can be typed by tab-completing \xor or \veebar in the Julia REPL.

julia> [true; true; false] .⊻ [true; false; false]
3-element BitArray{1}:
 false
  true
 false

source

`Base.:!`Function

!(x)

Boolean not.

julia> !true
false

julia> !false
true

julia> .![true false true]
1×3 BitArray{2}:
 false  true  false

source

!f::Function

Predicate function negation: when the argument of ! is a function, it returns a function which computes the boolean negation of f. Example:

julia> str = "∀ ε > 0, ∃ δ > 0: |x-y| < δ ⇒ |f(x)-f(y)| < ε"
"∀ ε > 0, ∃ δ > 0: |x-y| < δ ⇒ |f(x)-f(y)| < ε"

julia> filter(isalpha, str)
"εδxyδfxfyε"

julia> filter(!isalpha, str)
"∀  > 0, ∃  > 0: |-| <  ⇒ |()-()| < "

source

`&&`Keyword

x && y

Short-circuiting boolean AND.

source

`||`Keyword

x || y

Short-circuiting boolean OR.

source

Mathematical Functions

`Base.isapprox`Function

isapprox(x, y; rtol::Real=sqrt(eps), atol::Real=0, nans::Bool=false, norm::Function)

Inexact equality comparison: true if norm(x-y) <= atol + rtol*max(norm(x), norm(y)). The default atol is zero and the default rtol depends on the types of x and y. The keyword argument nans determines whether or not NaN values are considered equal (defaults to false).

For real or complex floating-point values, rtol defaults to sqrt(eps(typeof(real(x-y)))). This corresponds to requiring equality of about half of the significand digits. For other types, rtol defaults to zero.

x and y may also be arrays of numbers, in which case norm defaults to vecnorm but may be changed by passing a norm::Function keyword argument. (For numbers, norm is the same thing as abs.) When x and y are arrays, if norm(x-y) is not finite (i.e. ±Inf or NaN), the comparison falls back to checking whether all elements of x and y are approximately equal component-wise.

The binary operator ≈ is equivalent to isapprox with the default arguments, and x ≉ y is equivalent to !isapprox(x,y).

julia> 0.1 ≈ (0.1 - 1e-10)
true

julia> isapprox(10, 11; atol = 2)
true

julia> isapprox([10.0^9, 1.0], [10.0^9, 2.0])
true

source

`Base.sin`Function

sin(x)

Compute sine of x, where x is in radians.

source

`Base.cos`Function

cos(x)

Compute cosine of x, where x is in radians.

source

`Base.tan`Function

tan(x)

Compute tangent of x, where x is in radians.

source

`Base.Math.sind`Function

sind(x)

Compute sine of x, where x is in degrees.

source

`Base.Math.cosd`Function

cosd(x)

Compute cosine of x, where x is in degrees.

source

`Base.Math.tand`Function

tand(x)

Compute tangent of x, where x is in degrees.

source

`Base.Math.sinpi`Function

sinpi(x)

Compute $\sin(\pi x)$ more accurately than sin(pi*x), especially for large x.

source

`Base.Math.cospi`Function

cospi(x)

Compute $\cos(\pi x)$ more accurately than cos(pi*x), especially for large x.

source

`Base.sinh`Function

sinh(x)

Compute hyperbolic sine of x.

source

`Base.cosh`Function

cosh(x)

Compute hyperbolic cosine of x.

source

`Base.tanh`Function

tanh(x)

Compute hyperbolic tangent of x.

source

`Base.asin`Function

asin(x)

Compute the inverse sine of x, where the output is in radians.

source

`Base.acos`Function

acos(x)

Compute the inverse cosine of x, where the output is in radians

source

`Base.atan`Function

atan(x)

Compute the inverse tangent of x, where the output is in radians.

source

`Base.Math.atan2`Function

atan2(y, x)

Compute the inverse tangent of y/x, using the signs of both x and y to determine the quadrant of the return value.

source

`Base.Math.asind`Function

asind(x)

Compute the inverse sine of x, where the output is in degrees.

source

`Base.Math.acosd`Function

acosd(x)

Compute the inverse cosine of x, where the output is in degrees.

source

`Base.Math.atand`Function

atand(x)

Compute the inverse tangent of x, where the output is in degrees.

source

`Base.Math.sec`Function

sec(x)

Compute the secant of x, where x is in radians.

source

`Base.Math.csc`Function

csc(x)

Compute the cosecant of x, where x is in radians.

source

`Base.Math.cot`Function

cot(x)

Compute the cotangent of x, where x is in radians.

source

`Base.Math.secd`Function

secd(x)

Compute the secant of x, where x is in degrees.

source

`Base.Math.cscd`Function

cscd(x)

Compute the cosecant of x, where x is in degrees.

source

`Base.Math.cotd`Function

cotd(x)

Compute the cotangent of x, where x is in degrees.

source

`Base.Math.asec`Function

asec(x)

Compute the inverse secant of x, where the output is in radians.

source

`Base.Math.acsc`Function

acsc(x)

Compute the inverse cosecant of x, where the output is in radians.

source

`Base.Math.acot`Function

acot(x)

Compute the inverse cotangent of x, where the output is in radians.

source

`Base.Math.asecd`Function

asecd(x)

Compute the inverse secant of x, where the output is in degrees.

source

`Base.Math.acscd`Function

acscd(x)

Compute the inverse cosecant of x, where the output is in degrees.

source

`Base.Math.acotd`Function

acotd(x)

Compute the inverse cotangent of x, where the output is in degrees.

source

`Base.Math.sech`Function

sech(x)

Compute the hyperbolic secant of x

source

`Base.Math.csch`Function

csch(x)

Compute the hyperbolic cosecant of x.

source

`Base.Math.coth`Function

coth(x)

Compute the hyperbolic cotangent of x.

source

`Base.asinh`Function

asinh(x)

Compute the inverse hyperbolic sine of x.

source

`Base.acosh`Function

acosh(x)

Compute the inverse hyperbolic cosine of x.

source

`Base.atanh`Function

atanh(x)

Compute the inverse hyperbolic tangent of x.

source

`Base.Math.asech`Function

asech(x)

Compute the inverse hyperbolic secant of x.

source

`Base.Math.acsch`Function

acsch(x)

Compute the inverse hyperbolic cosecant of x.

source

`Base.Math.acoth`Function

acoth(x)

Compute the inverse hyperbolic cotangent of x.

source

`Base.Math.sinc`Function

sinc(x)

Compute $\sin(\pi x) / (\pi x)$ if $x \neq 0$, and $1$ if $x = 0$.

source

`Base.Math.cosc`Function

cosc(x)

Compute $\cos(\pi x) / x - \sin(\pi x) / (\pi x^2)$ if $x \neq 0$, and $0$ if $x = 0$. This is the derivative of sinc(x).

source

`Base.Math.deg2rad`Function

deg2rad(x)

Convert x from degrees to radians.

julia> deg2rad(90)
1.5707963267948966

source

`Base.Math.rad2deg`Function

rad2deg(x)

Convert x from radians to degrees.

julia> rad2deg(pi)
180.0

source

`Base.Math.hypot`Function

hypot(x, y)

Compute the hypotenuse $\sqrt{x^2+y^2}$ avoiding overflow and underflow.

Examples

julia> a = 10^10;

julia> hypot(a, a)
1.4142135623730951e10

julia> √(a^2 + a^2) # a^2 overflows
ERROR: DomainError:
sqrt will only return a complex result if called with a complex argument. Try sqrt(complex(x)).
Stacktrace:
 [1] sqrt(::Int64) at ./math.jl:434

source

hypot(x...)

Compute the hypotenuse $\sqrt{\sum x_i^2}$ avoiding overflow and underflow.

source

`Base.log`Method

log(x)

Compute the natural logarithm of x. Throws DomainError for negative Real arguments. Use complex negative arguments to obtain complex results.

There is an experimental variant in the Base.Math.JuliaLibm module, which is typically faster and more accurate.

source

`Base.log`Method

log(b,x)

Compute the base b logarithm of x. Throws DomainError for negative Real arguments.

julia> log(4,8)
1.5

julia> log(4,2)
0.5

Note

If b is a power of 2 or 10, log2 or log10 should be used, as these will typically be faster and more accurate. For example,

julia> log(100,1000000)
2.9999999999999996

julia> log10(1000000)/2
3.0

source

`Base.log2`Function

log2(x)

Compute the logarithm of x to base 2. Throws DomainError for negative Real arguments.

Example

julia> log2(4)
2.0

julia> log2(10)
3.321928094887362

source

`Base.log10`Function

log10(x)

Compute the logarithm of x to base 10. Throws DomainError for negative Real arguments.

Example

julia> log10(100)
2.0

julia> log10(2)
0.3010299956639812

source

`Base.log1p`Function

log1p(x)

Accurate natural logarithm of 1+x. Throws DomainError for Real arguments less than -1.

There is an experimental variant in the Base.Math.JuliaLibm module, which is typically faster and more accurate.

Examples

julia> log1p(-0.5)
-0.6931471805599453

julia> log1p(0)
0.0

source

`Base.Math.frexp`Function

frexp(val)

Return (x,exp) such that x has a magnitude in the interval $[1/2, 1)$ or 0, and val is equal to $x \times 2^{exp}$.

source

`Base.exp`Function

exp(x)

Compute the natural base exponential of x, in other words $e^x$.

source

`Base.exp2`Function

exp2(x)

Compute $2^x$.

julia> exp2(5)
32.0

source

`Base.exp10`Function

exp10(x)

Compute $10^x$.

Examples

julia> exp10(2)
100.0

julia> exp10(0.2)
1.5848931924611136

source

`Base.Math.ldexp`Function

ldexp(x, n)

Compute $x \times 2^n$.

Example

julia> ldexp(5., 2)
20.0

source

`Base.Math.modf`Function

modf(x)

Return a tuple (fpart,ipart) of the fractional and integral parts of a number. Both parts have the same sign as the argument.

Example

julia> modf(3.5)
(0.5, 3.0)

source

`Base.expm1`Function

expm1(x)

Accurately compute $e^x-1$.

source

`Base.round`Method

round([T,] x, [digits, [base]], [r::RoundingMode])

Rounds x to an integer value according to the provided RoundingMode, returning a value of the same type as x. When not specifying a rounding mode the global mode will be used (see rounding), which by default is round to the nearest integer (RoundNearest mode), with ties (fractional values of 0.5) being rounded to the nearest even integer.

julia> round(1.7)
2.0

julia> round(1.5)
2.0

julia> round(2.5)
2.0

The optional RoundingMode argument will change how the number gets rounded.

round(T, x, [r::RoundingMode]) converts the result to type T, throwing an InexactError if the value is not representable.

round(x, digits) rounds to the specified number of digits after the decimal place (or before if negative). round(x, digits, base) rounds using a base other than 10.

julia> round(pi, 2)
3.14

julia> round(pi, 3, 2)
3.125

Note

Rounding to specified digits in bases other than 2 can be inexact when operating on binary floating point numbers. For example, the Float64 value represented by 1.15 is actually less than 1.15, yet will be rounded to 1.2.

julia> x = 1.15
1.15

julia> @sprintf "%.20f" x
"1.14999999999999991118"

julia> x < 115//100
true

julia> round(x, 1)
1.2

source

`Base.Rounding.RoundingMode`Type

RoundingMode

A type used for controlling the rounding mode of floating point operations (via rounding/setrounding functions), or as optional arguments for rounding to the nearest integer (via the round function).

Currently supported rounding modes are:

RoundNearest (default)
RoundNearestTiesAway
RoundNearestTiesUp
RoundToZero
RoundFromZero (BigFloat only)
RoundUp
RoundDown

source

`Base.Rounding.RoundNearest`Constant

RoundNearest

The default rounding mode. Rounds to the nearest integer, with ties (fractional values of 0.5) being rounded to the nearest even integer.

source

`Base.Rounding.RoundNearestTiesAway`Constant

RoundNearestTiesAway

Rounds to nearest integer, with ties rounded away from zero (C/C++ round behaviour).

source

`Base.Rounding.RoundNearestTiesUp`Constant

RoundNearestTiesUp

Rounds to nearest integer, with ties rounded toward positive infinity (Java/JavaScript round behaviour).

source

`Base.Rounding.RoundToZero`Constant

RoundToZero

round using this rounding mode is an alias for trunc.

source

`Base.Rounding.RoundUp`Constant

RoundUp

round using this rounding mode is an alias for ceil.

source

`Base.Rounding.RoundDown`Constant

RoundDown

round using this rounding mode is an alias for floor.

source

`Base.round`Method

round(z, RoundingModeReal, RoundingModeImaginary)

Returns the nearest integral value of the same type as the complex-valued z to z, breaking ties using the specified RoundingModes. The first RoundingMode is used for rounding the real components while the second is used for rounding the imaginary components.

source

`Base.ceil`Function

ceil([T,] x, [digits, [base]])

ceil(x) returns the nearest integral value of the same type as x that is greater than or equal to x.

ceil(T, x) converts the result to type T, throwing an InexactError if the value is not representable.

digits and base work as for round.

source

`Base.floor`Function

floor([T,] x, [digits, [base]])

floor(x) returns the nearest integral value of the same type as x that is less than or equal to x.

floor(T, x) converts the result to type T, throwing an InexactError if the value is not representable.

digits and base work as for round.

source

`Base.trunc`Function

trunc([T,] x, [digits, [base]])

trunc(x) returns the nearest integral value of the same type as x whose absolute value is less than or equal to x.

trunc(T, x) converts the result to type T, throwing an InexactError if the value is not representable.

digits and base work as for round.

source

`Base.unsafe_trunc`Function

unsafe_trunc(T, x)

unsafe_trunc(T, x) returns the nearest integral value of type T whose absolute value is less than or equal to x. If the value is not representable by T, an arbitrary value will be returned.

source

`Base.signif`Function

signif(x, digits, [base])

Rounds (in the sense of round) x so that there are digits significant digits, under a base base representation, default 10. E.g., signif(123.456, 2) is 120.0, and signif(357.913, 4, 2) is 352.0.

source

`Base.min`Function

min(x, y, ...)

Return the minimum of the arguments. See also the minimum function to take the minimum element from a collection.

julia> min(2, 5, 1)
1

source

`Base.max`Function

max(x, y, ...)

Return the maximum of the arguments. See also the maximum function to take the maximum element from a collection.

julia> max(2, 5, 1)
5

source

`Base.minmax`Function

minmax(x, y)

Return (min(x,y), max(x,y)). See also: extrema that returns (minimum(x), maximum(x)).

julia> minmax('c','b')
('b', 'c')

source

`Base.Math.clamp`Function

clamp(x, lo, hi)

Return x if lo <= x <= hi. If x < lo, return lo. If x > hi, return hi. Arguments are promoted to a common type.

julia> clamp.([pi, 1.0, big(10.)], 2., 9.)
3-element Array{BigFloat,1}:
 3.141592653589793238462643383279502884197169399375105820974944592307816406286198
 2.000000000000000000000000000000000000000000000000000000000000000000000000000000
 9.000000000000000000000000000000000000000000000000000000000000000000000000000000

source

`Base.Math.clamp!`Function

clamp!(array::AbstractArray, lo, hi)

Restrict values in array to the specified range, in-place. See also clamp.

source

`Base.abs`Function

abs(x)

The absolute value of x.

When abs is applied to signed integers, overflow may occur, resulting in the return of a negative value. This overflow occurs only when abs is applied to the minimum representable value of a signed integer. That is, when x == typemin(typeof(x)), abs(x) == x < 0, not -x as might be expected.

julia> abs(-3)
3

julia> abs(1 + im)
1.4142135623730951

julia> abs(typemin(Int64))
-9223372036854775808

source

`Base.Checked.checked_abs`Function

Base.checked_abs(x)

Calculates abs(x), checking for overflow errors where applicable. For example, standard two's complement signed integers (e.g. Int) cannot represent abs(typemin(Int)), thus leading to an overflow.