# Mathematics

## Mathematical Operators

`Base.:-` — Method

    -(x)

Unary minus operator.

See also: `abs`, `flipsign`.

Examples

    julia> -1
    -1

    julia> -(2)
    -2

    julia> -[1 2; 3 4]
    2×2 Matrix{Int64}:
     -1  -2
     -3  -4

    julia> -(true)  # promotes to Int
    -1

    julia> -(0x003)
    0xfffd

source
`Base.:+` — Function

    dt::Date + t::Time -> DateTime

The addition of a `Date` with a `Time` produces a `DateTime`. The hour, minute, second, and millisecond parts of the `Time` are used along with the year, month, and day of the `Date` to create the new `DateTime`. Non-zero microseconds or nanoseconds in the `Time` type will result in an `InexactError` being thrown.

source

    +(x, y...)

Addition operator.

Infix `x+y+z+...` calls this function with all arguments, i.e. `+(x, y, z, ...)`, which by default then calls `(x+y) + z + ...` starting from the left.

Note that overflow is possible for most integer types, including the default `Int`, when adding large numbers.

Examples

    julia> 1 + 20 + 4
    25

    julia> +(1, 20, 4)
    25

    julia> [1,2] + [3,4]
    2-element Vector{Int64}:
     4
     6

    julia> typemax(Int) + 1 < 0
    true

source
`Base.:-` — Method

    -(x, y)

Subtraction operator.

Examples

    julia> 2 - 3
    -1

    julia> -(2, 4.5)
    -2.5

source
`Base.:*` — Method

    *(x, y...)

Multiplication operator.

Infix `x*y*z*...` calls this function with all arguments, i.e. `*(x, y, z, ...)`, which by default then calls `(x*y) * z * ...` starting from the left.

Juxtaposition such as `2pi` also calls `*(2, pi)`. Note that this operation has higher precedence than a literal `*`. Note also that juxtaposition "0x..." (integer zero times a variable whose name starts with `x`) is forbidden as it clashes with unsigned integer literals: `0x01 isa UInt8`.

Note that overflow is possible for most integer types, including the default `Int`, when multiplying large numbers.

Examples

    julia> 2 * 7 * 8
    112

    julia> *(2, 7, 8)
    112

    julia> [2 0; 0 3] * [1, 10]  # matrix * vector
    2-element Vector{Int64}:
      2
     30

    julia> 1/2pi, 1/2*pi  # juxtaposition has higher precedence
    (0.15915494309189535, 1.5707963267948966)

    julia> x = [1, 2]; x'x  # adjoint vector * vector
    5

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. See `÷` for integer division, or `//` for `Rational` results.

Examples

    julia> 1/2
    0.5

    julia> 4/2
    2.0

    julia> 4.5/2
    2.25

source

    A / B

Matrix right-division: `A / B` is equivalent to `(B' \ A')'` where `\` is the left-division operator. For square matrices, the result `X` is such that `A == X*B`.

See also: `rdiv!`.

Examples

    julia> A = Float64[1 4 5; 3 9 2]; B = Float64[1 4 2; 3 4 2; 8 7 1];

    julia> X = A / B
    2×3 Matrix{Float64}:
     -0.65   3.75  -1.2
      3.25  -2.75   1.0

    julia> isapprox(A, X*B)
    true

    julia> isapprox(X, A*pinv(B))
    true

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.

Examples

    julia> 3 \ 6
    2.0

    julia> inv(3) * 6
    2.0

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

    julia> A \ x
    2-element Vector{Float64}:
      6.5
     -7.0

    julia> inv(A) * x
    2-element Vector{Float64}:
      6.5
     -7.0

source
`Base.:^` — Method

    ^(x, y)

Exponentiation operator.

If `x` and `y` are integers, the result may overflow. To enter numbers in scientific notation, use `Float64` literals such as `1.2e3` rather than `1.2 * 10^3`.

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.) If `y` is a negative integer literal, then `Base.literal_pow` transforms the operation to `inv(x)^-y` by default, where `-y` is positive.

See also `exp2`, `<<`.

Examples

    julia> 3^5
    243

    julia> 3^-1  # uses Base.literal_pow
    0.3333333333333333

    julia> p = -1;

    julia> 3^p
    ERROR: DomainError with -1:
    Cannot raise an integer x to a negative power -1.
    [...]

    julia> 3.0^p
    0.3333333333333333

    julia> 10^19 > 0  # integer overflow
    false

    julia> big(10)^19 == 1e19
    true

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`, but allowing the add and multiply to be merged with each other or with surrounding operations for performance. For example, this may be implemented as an `fma` if the hardware supports it efficiently. The result can be different on different machines and can also be different on the same machine due to constant propagation or other optimizations. See `fma`.

Examples

    julia> muladd(3, 2, 1)
    7

    julia> 3 * 2 + 1
    7

source

    muladd(A, y, z)

Combined multiply-add, `A*y .+ z`, for matrix-matrix or matrix-vector multiplication. The result is always the same size as `A*y`, but `z` may be smaller, or a scalar.

Julia 1.6

These methods require Julia 1.6 or later.

Examples

    julia> A=[1.0 2.0; 3.0 4.0]; B=[1.0 1.0; 1.0 1.0]; z=[0, 100];

    julia> muladd(A, B, z)
    2×2 Matrix{Float64}:
       3.0    3.0
     107.0  107.0

source
`Base.inv` — Method

    inv(x)

Return the multiplicative inverse of `x`, such that `x*inv(x)` or `inv(x)*x` yields `one(x)` (the multiplicative identity) up to roundoff errors.

If `x` is a number, this is essentially the same as `one(x)/x`, but for some types `inv(x)` may be slightly more efficient.

Examples

    julia> inv(2)
    0.5

    julia> inv(1 + 2im)
    0.2 - 0.4im

    julia> inv(1 + 2im) * (1 + 2im)
    1.0 + 0.0im

    julia> inv(2//3)
    3//2

Julia 1.2

`inv(::Missing)` requires at least Julia 1.2.

source
`Base.div` — Function

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

The quotient from Euclidean (integer) division. Generally equivalent to a mathematical operation x/y without a fractional part.

See also: `cld`, `fld`, `rem`, `divrem`.

Examples

    julia> 9 ÷ 4
    2

    julia> -5 ÷ 3
    -1

    julia> 5.0 ÷ 2
    2.0

    julia> div.(-5:5, 3)'
    1×11 adjoint(::Vector{Int64}) with eltype Int64:
     -1  -1  -1  0  0  0  0  0  1  1  1

source
`Base.div` — Method

    div(x, y, r::RoundingMode=RoundToZero)

The quotient from Euclidean (integer) division. Computes `x / y`, rounded to an integer according to the rounding mode `r`. In other words, the quantity

    round(x / y, r)

without any intermediate rounding.

Julia 1.4

The three-argument method taking a `RoundingMode` requires Julia 1.4 or later.

See also `fld` and `cld`, which are special cases of this function.

Julia 1.9

`RoundFromZero` requires at least Julia 1.9.

Examples:

    julia> div(4, 3, RoundToZero) # Matches div(4, 3)
    1
    julia> div(4, 3, RoundDown) # Matches fld(4, 3)
    1
    julia> div(4, 3, RoundUp) # Matches cld(4, 3)
    2
    julia> div(5, 2, RoundNearest)
    2
    julia> div(5, 2, RoundNearestTiesAway)
    3
    julia> div(-5, 2, RoundNearest)
    -2
    julia> div(-5, 2, RoundNearestTiesAway)
    -3
    julia> div(-5, 2, RoundNearestTiesUp)
    -2
    julia> div(4, 3, RoundFromZero)
    2
    julia> div(-4, 3, RoundFromZero)
    -2

Because `div(x, y)` implements strictly correct truncated rounding based on the true value of floating-point numbers, unintuitive situations can arise. For example:

    julia> div(6.0, 0.1)
    59.0
    julia> 6.0 / 0.1
    60.0
    julia> 6.0 / big(0.1)
    59.99999999999999666933092612453056361837965690217069245739573412231113406246995

What is happening here is that the true value of the floating-point number written as `0.1` is slightly larger than the numerical value 1/10 while `6.0` represents the number 6 precisely. Therefore the true value of `6.0 / 0.1` is slightly less than 60. When doing division, this is rounded to precisely `60.0`, but `div(6.0, 0.1, RoundToZero)` always truncates the true value, so the result is `59.0`.

source
`Base.fld` — Function

    fld(x, y)

Largest integer less than or equal to `x / y`. Equivalent to `div(x, y, RoundDown)`.

See also `div`, `cld`, `fld1`.

Examples

    julia> fld(7.3, 5.5)
    1.0

    julia> fld.(-5:5, 3)'
    1×11 adjoint(::Vector{Int64}) with eltype Int64:
     -2  -2  -1  -1  -1  0  0  0  1  1  1

Because `fld(x, y)` implements strictly correct floored rounding based on the true value of floating-point numbers, unintuitive situations can arise. For example:

    julia> fld(6.0, 0.1)
    59.0
    julia> 6.0 / 0.1
    60.0
    julia> 6.0 / big(0.1)
    59.99999999999999666933092612453056361837965690217069245739573412231113406246995

What is happening here is that the true value of the floating-point number written as `0.1` is slightly larger than the numerical value 1/10 while `6.0` represents the number 6 precisely. Therefore the true value of `6.0 / 0.1` is slightly less than 60. When doing division, this is rounded to precisely `60.0`, but `fld(6.0, 0.1)` always takes the floor of the true value, so the result is `59.0`.

source
`Base.cld` — Function

    cld(x, y)

Smallest integer larger than or equal to `x / y`. Equivalent to `div(x, y, RoundUp)`.

See also `div`, `fld`.

Examples

    julia> cld(5.5, 2.2)
    3.0

    julia> cld.(-5:5, 3)'
    1×11 adjoint(::Vector{Int64}) with eltype Int64:
     -1  -1  -1  0  0  0  1  1  1  2  2

source
`Base.mod` — Function

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

Examples

    julia> x = 129 % Int8
    -127

    julia> typeof(x)
    Int8

    julia> x = 129 % BigInt
    129

    julia> typeof(x)
    BigInt

source

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

See also: `rem`, `div`, `fld`, `mod1`, `invmod`.

    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

    julia> mod.(-5:5, 3)'
    1×11 adjoint(::Vector{Int64}) with eltype Int64:
     1  2  0  1  2  0  1  2  0  1  2

source

    mod(x::Integer, r::AbstractUnitRange)

Find `y` in the range `r` such that `x` ≡ `y` (mod `n`), where `n = length(r)`, i.e. `y = mod(x - first(r), n) + first(r)`.

See also `mod1`.

Examples

    julia> mod(0, Base.OneTo(3))  # mod1(0, 3)
    3

    julia> mod(3, 0:2)  # mod(3, 3)
    0

Julia 1.3

This method requires at least Julia 1.3.

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.

See also: `div`, `mod`, `mod1`, `divrem`.

Examples

    julia> x = 15; y = 4;

    julia> x % y
    3

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

    julia> rem.(-5:5, 3)'
    1×11 adjoint(::Vector{Int64}) with eltype Int64:
     -2  -1  0  -2  -1  0  1  2  0  1  2

source
`Base.rem` — Method

    rem(x, y, r::RoundingMode=RoundToZero)

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

    x - y * round(x / y, r)

without any intermediate rounding.

- if `r == RoundNearest`, then the result is exact, and in the interval $[-|y| / 2, |y| / 2]$. See also `RoundNearest`.

- if `r == RoundToZero` (default), then the result is exact, and in the interval $[0, |y|)$ if `x` is positive, or $(-|y|, 0]$ otherwise. See also `RoundToZero`.

- if `r == RoundDown`, then the result is in the interval $[0, y)$ if `y` is positive, or $(y, 0]$ otherwise. The result may not be exact if `x` and `y` have different signs, and `abs(x) < abs(y)`. See also `RoundDown`.

- if `r == RoundUp`, then the result is in the interval $(-y, 0]$ if `y` is positive, or $[0, -y)$ otherwise. The result may not be exact if `x` and `y` have the same sign, and `abs(x) < abs(y)`. See also `RoundUp`.

- if `r == RoundFromZero`, then the result is in the interval $(-y, 0]$ if `y` is positive, or $[0, -y)$ otherwise. The result may not be exact if `x` and `y` have the same sign, and `abs(x) < abs(y)`. See also `RoundFromZero`.

Julia 1.9

`RoundFromZero` requires at least Julia 1.9.

Examples:

    julia> x = 9; y = 4;

    julia> x % y  # same as rem(x, y)
    1

    julia> x ÷ y  # same as div(x, y)
    2

    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. See also `RoundNearest`.

- if `r == RoundToZero`, then the result is in the interval $[0, 2π]$ if `x` is positive,. or $[-2π, 0]$ otherwise. See also `RoundToZero`.

- if `r == RoundDown`, then the result is in the interval $[0, 2π]$. See also `RoundDown`.

- if `r == RoundUp`, then the result is in the interval $[-2π, 0]$. See also `RoundUp`.

Examples

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

Note

Depending on the format of the input value, the closest representable value to 2π may be less than 2π. For example, the expression `mod2pi(2π)` will not return `0`, because the intermediate value of `2*π` is a `Float64` and `2*Float64(π) < 2*big(π)`. See `rem2pi` for more refined control of this behavior.

Examples

    julia> mod2pi(9*pi/4)
    0.7853981633974481

source
`Base.divrem` — Function

    divrem(x, y, r::RoundingMode=RoundToZero)

The quotient and remainder from Euclidean division. Equivalent to `(div(x, y, r), rem(x, y, r))`. Equivalently, with the default value of `r`, this call is equivalent to `(x ÷ y, x % y)`.

See also: `fldmod`, `cld`.

Examples

    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. A convenience wrapper for `divrem(x, y, RoundDown)`. Equivalent to `(fld(x, y), mod(x, y))`.

See also: `fld`, `cld`, `fldmod1`.

source
`Base.fld1` — Function

    fld1(x, y)

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

See also `mod1`, `fldmod1`.

Examples

    julia> x = 15; y = 4;

    julia> fld1(x, y)
    4

    julia> x == fld(x, y) * y + mod(x, y)
    true

    julia> x == (fld1(x, y) - 1) * y + mod1(x, y)
    true

source
`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`.

With integer arguments and positive `y`, this is equal to `mod(x, 1:y)`, and hence natural for 1-based indexing. By comparison, `mod(x, y) == mod(x, 0:y-1)` is natural for computations with offsets or strides.

See also `mod`, `fld1`, `fldmod1`.

Examples

    julia> mod1(4, 2)
    2

    julia> mod1.(-5:5, 3)'
    1×11 adjoint(::Vector{Int64}) with eltype Int64:
     1  2  3  1  2  3  1  2  3  1  2

    julia> mod1.([-0.1, 0, 0.1, 1, 2, 2.9, 3, 3.1]', 3)
    1×8 Matrix{Float64}:
     2.9  3.0  0.1  1.0  2.0  2.9  3.0  0.1

source
`Base.fldmod1` — Function

    fldmod1(x, y)

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

See also `fld1`, `mod1`.

source
`Base.://` — Function

    //(num, den)

Divide two integers or rational numbers, giving a `Rational` result. More generally, `//` can be used for exact rational division of other numeric types with integer or rational components, such as complex numbers with integer components.

Note that floating-point (`AbstractFloat`) arguments are not permitted by `//` (even if the values are rational). The arguments must be subtypes of `Integer`, `Rational`, or composites thereof.

Examples

    julia> 3 // 5
    3//5

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

    julia> (1+2im) // (3+4im)
    11//25 + 2//25*im

    julia> 1.0 // 2
    ERROR: MethodError: no method matching //(::Float64, ::Int64)
    [...]

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

Examples

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

Examples

    julia> numerator(2//3)
    2

    julia> numerator(4)
    4

source
`Base.denominator` — Function

    denominator(x)

Denominator of the rational representation of `x`.

Examples

    julia> denominator(2//3)
    3

    julia> denominator(4)
    1

source
`Base.:<<` — Function

    <<(B::BitVector, n) -> BitVector

Left bit shift operator, `B << n`. For `n >= 0`, the result is `B` with elements shifted `n` positions backwards, filling with `false` values. If `n < 0`, elements are shifted forwards. Equivalent to `B >> -n`.

Examples

    julia> B = BitVector([true, false, true, false, false])
    5-element BitVector:
     1
     0
     1
     0
     0

    julia> B << 1
    5-element BitVector:
     0
     1
     0
     0
     0

    julia> B << -1
    5-element BitVector:
     0
     1
     0
     1
     0

source

    <<(x, n)

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

Examples

    julia> Int8(3) << 2
    12

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

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

See also `>>`, `>>>`, `exp2`, `ldexp`.

source
`Base.:>>` — Function

    >>(B::BitVector, n) -> BitVector

Right bit shift operator, `B >> n`. For `n >= 0`, the result is `B` with elements shifted `n` positions forward, filling with `false` values. If `n < 0`, elements are shifted backwards. Equivalent to `B << -n`.

Examples

    julia> B = BitVector([true, false, true, false, false])
    5-element BitVector:
     1
     0
     1
     0
     0

    julia> B >> 1
    5-element BitVector:
     0
     1
     0
     1
     0

    julia> B >> -1
    5-element BitVector:
     0
     1
     0
     0
     0

source

    >>(x, n)

Right bit shift operator, `x >> n`. For `n >= 0`, the result is `x` shifted right by `n` bits, filling with `0`s if `x >= 0`, `1`s 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`.

Examples

    julia> Int8(13) >> 2
    3

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

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

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

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

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

See also `>>>`, `<<`.

source
`Base.:>>>` — Function

    >>>(B::BitVector, n) -> BitVector

Unsigned right bitshift operator, `B >>> n`. Equivalent to `B >> n`. See `>>` for details and examples.

source

    >>>(x, n)

Unsigned right bit shift operator, `x >>> n`. For `n >= 0`, the result is `x` shifted right by `n` bits, filling with `0`s. 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)`.

Examples

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

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

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

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

See also `>>`, `<<`.

source
`Base.bitrotate` — Function

    bitrotate(x::Base.BitInteger, k::Integer)

`bitrotate(x, k)` implements bitwise rotation. It returns the value of `x` with its bits rotated left `k` times. A negative value of `k` will rotate to the right instead.

Julia 1.5

This function requires Julia 1.5 or later.

See also: `<<`, `circshift`, `BitArray`.

    julia> bitrotate(UInt8(114), 2)
    0xc9

    julia> bitstring(bitrotate(0b01110010, 2))
    "11001001"

    julia> bitstring(bitrotate(0b01110010, -2))
    "10011100"

    julia> bitstring(bitrotate(0b01110010, 8))
    "01110010"

source
`Base.::` — Function

    :expr

Quote an expression `expr`, returning the abstract syntax tree (AST) of `expr`. The AST may be of type `Expr`, `Symbol`, or a literal value. The syntax `:identifier` evaluates to a `Symbol`.

See also: `Expr`, `Symbol`, `Meta.parse`

Examples

    julia> expr = :(a = b + 2*x)
    :(a = b + 2x)

    julia> sym = :some_identifier
    :some_identifier

    julia> value = :0xff
    0xff

    julia> typeof((expr, sym, value))
    Tuple{Expr, Symbol, UInt8}

source
`Base.range` — Function

    range(start, stop, length)
    range(start, stop; length, step)
    range(start; length, stop, step)
    range(;start, length, stop, step)

Construct a specialized array with evenly spaced elements and optimized storage (an `AbstractRange`) from the arguments. Mathematically a range is uniquely determined by any three of `start`, `step`, `stop` and `length`. Valid invocations of range are:

- Call `range` with any three of `start`, `step`, `stop`, `length`.
- Call `range` with two of `start`, `stop`, `length`. In this case `step` will be assumed to be positive one. If both arguments are Integers, a `UnitRange` will be returned.
- Call `range` with one of `stop` or `length`. `start` and `step` will be assumed to be positive one.

To construct a descending range, specify a negative step size, e.g. `range(5, 1; step = -1)` => [5,4,3,2,1]. Otherwise, a `stop` value less than the `start` value, with the default `step` of `+1`, constructs an empty range. Empty ranges are normalized such that the `stop` is one less than the `start`, e.g. `range(5, 1) == 5:4`.

See Extended Help for additional details on the returned type. See also `logrange` for logarithmically spaced points.

Examples

    julia> range(1, length=100)
    1:100

    julia> range(1, stop=100)
    1:100

    julia> range(1, step=5, length=100)
    1:5:496

    julia> range(1, step=5, stop=100)
    1:5:96

    julia> range(1, 10, length=101)
    1.0:0.09:10.0

    julia> range(1, 100, step=5)
    1:5:96

    julia> range(stop=10, length=5)
    6:10

    julia> range(stop=10, step=1, length=5)
    6:1:10

    julia> range(start=1, step=1, stop=10)
    1:1:10

    julia> range(; length = 10)
    Base.OneTo(10)

    julia> range(; stop = 6)
    Base.OneTo(6)

    julia> range(; stop = 6.5)
    1.0:1.0:6.0

If `length` is not specified and `stop - start` is not an integer multiple of `step`, a range that ends before `stop` will be produced.

    julia> range(1, 3.5, step=2)
    1.0:2.0:3.0

Special care is taken to ensure intermediate values are computed rationally. To avoid this induced overhead, see the `LinRange` constructor.

Julia 1.1

`stop` as a positional argument requires at least Julia 1.1.

Julia 1.7

The versions without keyword arguments and `start` as a keyword argument require at least Julia 1.7.

Julia 1.8

The versions with `stop` as a sole keyword argument, or `length` as a sole keyword argument require at least Julia 1.8.

Extended Help

`range` will produce a `Base.OneTo` when the arguments are Integers and

- Only `length` is provided
- Only `stop` is provided

`range` will produce a `UnitRange` when the arguments are Integers and

- Only `start` and `stop` are provided
- Only `length` and `stop` are provided

A `UnitRange` is not produced if `step` is provided even if specified as one.

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(         ref::R, step::S, len, [offset=1]) where {  R,S}
    StepRangeLen{T,R,S}(  ref::R, step::S, len, [offset=1]) where {T,R,S}
    StepRangeLen{T,R,S,L}(ref::R, step::S, len, [offset=1]) where {T,R,S,L}

A range `r` where `r[i]` produces values of type `T` (in the first form, `T` is deduced automatically), parameterized by a `ref`erence value, a `step`, and the `len`gth. 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`. The syntax `a:b` or `a:b:c`, where any of `a`, `b`, or `c` are floating-point numbers, creates a `StepRangeLen`.

Julia 1.7

The 4th type parameter `L` requires at least Julia 1.7.

source
`Base.logrange` — Function

    logrange(start, stop, length)
    logrange(start, stop; length)

Construct a specialized array whose elements are spaced logarithmically between the given endpoints. That is, the ratio of successive elements is a constant, calculated from the length.

This is similar to `geomspace` in Python. Unlike `PowerRange` in Mathematica, you specify the number of elements not the ratio. Unlike `logspace` in Python and Matlab, the `start` and `stop` arguments are always the first and last elements of the result, not powers applied to some base.

Examples

    julia> logrange(10, 4000, length=3)
    3-element Base.LogRange{Float64, Base.TwicePrecision{Float64}}:
     10.0, 200.0, 4000.0

    julia> ans[2] ≈ sqrt(10 * 4000)  # middle element is the geometric mean
    true

    julia> range(10, 40, length=3)[2] ≈ (10 + 40)/2  # arithmetic mean
    true

    julia> logrange(1f0, 32f0, 11)
    11-element Base.LogRange{Float32, Float64}:
     1.0, 1.41421, 2.0, 2.82843, 4.0, 5.65685, 8.0, 11.3137, 16.0, 22.6274, 32.0

    julia> logrange(1, 1000, length=4) ≈ 10 .^ (0:3)
    true

See the `LogRange` type for further details.

See also `range` for linearly spaced points.

Julia 1.11

This function requires at least Julia 1.11.

source
`Base.LogRange` — Type

    LogRange{T}(start, stop, len) <: AbstractVector{T}

A range whose elements are spaced logarithmically between `start` and `stop`, with spacing controlled by `len`. Returned by `logrange`.

Like `LinRange`, the first and last elements will be exactly those provided, but intermediate values may have small floating-point errors. These are calculated using the logs of the endpoints, which are stored on construction, often in higher precision than `T`.

Examples

    julia> logrange(1, 4, length=5)
    5-element Base.LogRange{Float64, Base.TwicePrecision{Float64}}:
     1.0, 1.41421, 2.0, 2.82843, 4.0

    julia> Base.LogRange{Float16}(1, 4, 5)
    5-element Base.LogRange{Float16, Float64}:
     1.0, 1.414, 2.0, 2.828, 4.0

    julia> logrange(1e-310, 1e-300, 11)[1:2:end]
    6-element Vector{Float64}:
     1.0e-310
     9.999999999999974e-309
     9.999999999999981e-307
     9.999999999999988e-305
     9.999999999999994e-303
     1.0e-300

    julia> prevfloat(1e-308, 5) == ans[2]
    true

Note that integer eltype `T` is not allowed. Use for instance `round.(Int, xs)`, or explicit powers of some integer base:

    julia> xs = logrange(1, 512, 4)
    4-element Base.LogRange{Float64, Base.TwicePrecision{Float64}}:
     1.0, 8.0, 64.0, 512.0

    julia> 2 .^ (0:3:9) |> println
    [1, 8, 64, 512]

Julia 1.11

This type requires at least Julia 1.11.

source
`Base.:==` — Function

    ==(x, y)

Generic equality operator. 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. Collections of the same type generally compare their key sets, and if those are `==`, then compare the values for each of those keys, returning true if all such pairs are `==`. Other properties are typically not taken into account (such as the exact type).

This operator follows IEEE semantics for floating-point numbers: `0.0 == -0.0` and `NaN != NaN`.

The result is of type `Bool`, except when one of the operands is `missing`, in which case `missing` is returned (three-valued logic). Collections generally implement three-valued logic akin to `all`, returning missing if any operands contain missing values and all other pairs are equal. Use `isequal` or `===` to always get a `Bool` result.

Implementation

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.

Equality and hashing are intimately related; two values that are considered `isequal` must have the same `hash` and by default `isequal` falls back to `==`. If a type customizes the behavior of `==` and/or `isequal`, then `hash` must be similarly implemented to ensure `isequal` and `hash` agree. `Set`s, `Dict`s, and many other internal implementations assume that this invariant holds.

If some type defines `==`, `isequal`, and `isless` then it should also implement `<` to ensure consistency of comparisons.

source
`Base.:!=` — Function

    !=(x)

Create a function that compares its argument to `x` using `!=`, i.e. a function equivalent to `y -> y != x`. The returned function is of type `Base.Fix2{typeof(!=)}`, which can be used to implement specialized methods.

Julia 1.2

This functionality requires at least Julia 1.2.

source

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

Not-equals comparison operator. Always gives the opposite answer as `==`.

Implementation

New types should generally not implement this, and rely on the fallback definition `!=(x,y) = !(x==y)` instead.

Examples

    julia> 3 != 2
    true

    julia> "foo" ≠ "foo"
    false

source
`Core.:!==` — Function

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

Always gives the opposite answer as `===`.

Examples

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

    julia> a ≢ b
    true

    julia> a ≢ a
    false

source
`Base.:<` — Function

    <(x)

Create a function that compares its argument to `x` using `<`, i.e. a function equivalent to `y -> y < x`. The returned function is of type `Base.Fix2{typeof(<)}`, which can be used to implement specialized methods.

Julia 1.2

This functionality requires at least Julia 1.2.

source

    <(x, y)

Less-than comparison operator. Falls back to `isless`. Because of the behavior of floating-point NaN values, this operator implements a partial order.

Implementation

New types with a canonical partial order should implement this function for two arguments of the new type. Types with a canonical total order should implement `isless` instead.

See also `isunordered`.

Examples

    julia> 'a' < 'b'
    true

    julia> "abc" < "abd"
    true

    julia> 5 < 3
    false

source
`Base.:<=` — Function

    <=(x)

Create a function that compares its argument to `x` using `<=`, i.e. a function equivalent to `y -> y <= x`. The returned function is of type `Base.Fix2{typeof(<=)}`, which can be used to implement specialized methods.

Julia 1.2

This functionality requires at least Julia 1.2.

source

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

Less-than-or-equals comparison operator. Falls back to `(x < y) | (x == y)`.

Examples

    julia> 'a' <= 'b'
    true

    julia> 7 ≤ 7 ≤ 9
    true

    julia> "abc" ≤ "abc"
    true

    julia> 5 <= 3
    false

source
`Base.:>` — Function

    >(x)

Create a function that compares its argument to `x` using `>`, i.e. a function equivalent to `y -> y > x`. The returned function is of type `Base.Fix2{typeof(>)}`, which can be used to implement specialized methods.

Julia 1.2

This functionality requires at least Julia 1.2.

source

    >(x, y)

Greater-than comparison operator. Falls back to `y < x`.

Implementation

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

Examples

    julia> 'a' > 'b'
    false

    julia> 7 > 3 > 1
    true

    julia> "abc" > "abd"
    false

    julia> 5 > 3
    true

source
`Base.:>=` — Function

    >=(x)

Create a function that compares its argument to `x` using `>=`, i.e. a function equivalent to `y -> y >= x`. The returned function is of type `Base.Fix2{typeof(>=)}`, which can be used to implement specialized methods.

Julia 1.2

This functionality requires at least Julia 1.2.

source

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

Greater-than-or-equals comparison operator. Falls back to `y <= x`.

Examples

    julia> 'a' >= 'b'
    false

    julia> 7 ≥ 7 ≥ 3
    true

    julia> "abc" ≥ "abc"
    true

    julia> 5 >= 3
    true

source
`Base.cmp` — Function

    cmp(a::AbstractString, b::AbstractString) -> Int

Compare two strings. Return `0` if both strings have the same length and the character at each index is the same in both strings. Return `-1` if `a` is a prefix of `b`, or if `a` comes before `b` in alphabetical order. Return `1` if `b` is a prefix of `a`, or if `b` comes before `a` in alphabetical order (technically, lexicographical order by Unicode code points).

Examples

    julia> cmp("abc", "abc")
    0

    julia> cmp("ab", "abc")
    -1

    julia> cmp("abc", "ab")
    1

    julia> cmp("ab", "ac")
    -1

    julia> cmp("ac", "ab")
    1

    julia> cmp("α", "a")
    1

    julia> cmp("b", "β")
    -1

source

    cmp(<, x, y)

Return -1, 0, or 1 depending on whether `x` is less than, equal to, or greater than `y`, respectively. The first argument specifies a less-than comparison function to use.

source

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

Examples

    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.

See also: `!`, `&`, `|`.

Examples

    julia> ~4
    -5

    julia> ~10
    -11

    julia> ~true
    false

source
`Base.:&` — Function

    x & y

Bitwise and. Implements three-valued logic, returning `missing` if one operand is `missing` and the other is `true`. Add parentheses for function application form: `(&)(x, y)`.

See also: `|`, `xor`, `&&`.

Examples

    julia> 4 & 10
    0

    julia> 4 & 12
    4

    julia> true & missing
    missing

    julia> false & missing
    false

source
`Base.:|` — Function

    x | y

Bitwise or. Implements three-valued logic, returning `missing` if one operand is `missing` and the other is `false`.

See also: `&`, `xor`, `||`.

Examples

    julia> 4 | 10
    14

    julia> 4 | 1
    5

    julia> true | missing
    true

    julia> false | missing
    missing

source
`Base.xor` — Function

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

Bitwise exclusive or of `x` and `y`. Implements three-valued logic, returning `missing` if one of the arguments is `missing`.

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.

Examples

    julia> xor(true, false)
    true

    julia> xor(true, true)
    false

    julia> xor(true, missing)
    missing

    julia> false ⊻ false
    false

    julia> [true; true; false] .⊻ [true; false; false]
    3-element BitVector:
     0
     1
     0

source
`Base.nand` — Function

    nand(x, y)
    ⊼(x, y)

Bitwise nand (not and) of `x` and `y`. Implements three-valued logic, returning `missing` if one of the arguments is `missing`.

The infix operation `a ⊼ b` is a synonym for `nand(a,b)`, and `⊼` can be typed by tab-completing `\nand` or `\barwedge` in the Julia REPL.

Examples

    julia> nand(true, false)
    true

    julia> nand(true, true)
    false

    julia> nand(true, missing)
    missing

    julia> false ⊼ false
    true

    julia> [true; true; false] .⊼ [true; false; false]
    3-element BitVector:
     0
     1
     1

source
`Base.nor` — Function

    nor(x, y)
    ⊽(x, y)

Bitwise nor (not or) of `x` and `y`. Implements three-valued logic, returning `missing` if one of the arguments is `missing` and the other is not `true`.

The infix operation `a ⊽ b` is a synonym for `nor(a,b)`, and `⊽` can be typed by tab-completing `\nor` or `\barvee` in the Julia REPL.

Examples

    julia> nor(true, false)
    false

    julia> nor(true, true)
    false

    julia> nor(true, missing)
    false

    julia> false ⊽ false
    true

    julia> false ⊽ missing
    missing

    julia> [true; true; false] .⊽ [true; false; false]
    3-element BitVector:
     0
     0
     1

source
`Base.:!` — Function

    !f::Function

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

See also `∘`.

Examples

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

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

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

Julia 1.9

Starting with Julia 1.9, `!f` returns a `ComposedFunction` instead of an anonymous function.

source

    !(x)

Boolean not. Implements three-valued logic, returning `missing` if `x` is `missing`.

See also `~` for bitwise not.

Examples

    julia> !true
    false

    julia> !false
    true

    julia> !missing
    missing

    julia> .![true false true]
    1×3 BitMatrix:
     0  1  0

source
`&&` — Keyword

    x && y

Short-circuiting boolean AND.

This is equivalent to `x ? y : false`: it returns `false` if `x` is `false` and the result of evaluating `y` if `x` is `true`. Note that if `y` is an expression, it is only evaluated when `x` is `true`, which is called "short-circuiting" behavior.

Also, `y` does not need to have a boolean value. This means that `(condition) && (statement)` can be used as shorthand for `if condition; statement; end` for an arbitrary `statement`.

See also `&`, the ternary operator `? :`, and the manual section on control flow.

Examples

    julia> x = 3;

    julia> x > 1 && x < 10 && x isa Int
    true

    julia> x < 0 && error("expected positive x")
    false

    julia> x > 0 && "not a boolean"
    "not a boolean"

source
`||` — Keyword

    x || y

Short-circuiting boolean OR.

This is equivalent to `x ? true : y`: it returns `true` if `x` is `true` and the result of evaluating `y` if `x` is `false`. Note that if `y` is an expression, it is only evaluated when `x` is `false`, which is called "short-circuiting" behavior.

Also, `y` does not need to have a boolean value. This means that `(condition) || (statement)` can be used as shorthand for `if !(condition); statement; end` for an arbitrary `statement`.

See also: `|`, `xor`, `&&`.

Examples

    julia> pi < 3 || ℯ < 3
    true

    julia> false || true || println("neither is true!")
    true

    julia> pi < 3 || "not a boolean"
    "not a boolean"

source

## Mathematical Functions

`Base.isapprox` — Function

    isapprox(x; kwargs...) / ≈(x; kwargs...)

Create a function that compares its argument to `x` using `≈`, i.e. a function equivalent to `y -> y ≈ x`.

The keyword arguments supported here are the same as those in the 2-argument `isapprox`.

Julia 1.5

This method requires Julia 1.5 or later.

source

    isapprox(x, y; atol::Real=0, rtol::Real=atol>0 ? 0 : √eps, nans::Bool=false[, norm::Function])

Inexact equality comparison. Two numbers compare equal if their relative distance or their absolute distance is within tolerance bounds: `isapprox` returns `true` if `norm(x-y) <= max(atol, rtol*max(norm(x), norm(y)))`. The default `atol` (absolute tolerance) is zero and the default `rtol` (relative tolerance) 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, if an `atol > 0` is not specified, `rtol` defaults to the square root of `eps` of the type of `x` or `y`, whichever is bigger (least precise). This corresponds to requiring equality of about half of the significant digits. Otherwise, e.g. for integer arguments or if an `atol > 0` is supplied, `rtol` defaults to zero.

The `norm` keyword defaults to `abs` for numeric `(x,y)` and to `LinearAlgebra.norm` for arrays (where an alternative `norm` choice is sometimes useful). 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)`.

Note that `x ≈ 0` (i.e., comparing to zero with the default tolerances) is equivalent to `x == 0` since the default `atol` is `0`. In such cases, you should either supply an appropriate `atol` (or use `norm(x) ≤ atol`) or rearrange your code (e.g. use `x ≈ y` rather than `x - y ≈ 0`). It is not possible to pick a nonzero `atol` automatically because it depends on the overall scaling (the "units") of your problem: for example, in `x - y ≈ 0`, `atol=1e-9` is an absurdly small tolerance if `x` is the radius of the Earth in meters, but an absurdly large tolerance if `x` is the radius of a Hydrogen atom in meters.

Julia 1.6

Passing the `norm` keyword argument when comparing numeric (non-array) arguments requires Julia 1.6 or later.

Examples

    julia> isapprox(0.1, 0.15; atol=0.05)
    true

    julia> isapprox(0.1, 0.15; rtol=0.34)
    true

    julia> isapprox(0.1, 0.15; rtol=0.33)
    false

    julia> 0.1 + 1e-10 ≈ 0.1
    true

    julia> 1e-10 ≈ 0
    false

    julia> isapprox(1e-10, 0, atol=1e-8)
    true

    julia> isapprox([10.0^9, 1.0], [10.0^9, 2.0]) # using `norm`
    true

source
`Base.sin` — Method

    sin(x::T) where {T <: Number} -> float(T)

Compute sine of `x`, where `x` is in radians.

Throw a `DomainError` if `isinf(x)`, return a `T(NaN)` if `isnan(x)`.

See also `sind`, `sinpi`, `sincos`, `cis`, `asin`.

Examples

    julia> round.(sin.(range(0, 2pi, length=9)'), digits=3)
    1×9 Matrix{Float64}:
     0.0  0.707  1.0  0.707  0.0  -0.707  -1.0  -0.707  -0.0

    julia> sind(45)
    0.7071067811865476

    julia> sinpi(1/4)
    0.7071067811865475

    julia> round.(sincos(pi/6), digits=3)
    (0.5, 0.866)

    julia> round(cis(pi/6), digits=3)
    0.866 + 0.5im

    julia> round(exp(im*pi/6), digits=3)
    0.866 + 0.5im

source
`Base.cos` — Method

    cos(x::T) where {T <: Number} -> float(T)

Compute cosine of `x`, where `x` is in radians.

Throw a `DomainError` if `isinf(x)`, return a `T(NaN)` if `isnan(x)`.

See also `cosd`, `cospi`, `sincos`, `cis`.

source
`Base.Math.sincos` — Method

    sincos(x::T) where T -> Tuple{float(T),float(T)}

Simultaneously compute the sine and cosine of `x`, where `x` is in radians, returning a tuple `(sine, cosine)`.

Throw a `DomainError` if `isinf(x)`, return a `(T(NaN), T(NaN))` if `isnan(x)`.

See also `cis`, `sincospi`, `sincosd`.

source
`Base.tan` — Method

    tan(x::T) where {T <: Number} -> float(T)

Compute tangent of `x`, where `x` is in radians.

Throw a `DomainError` if `isinf(x)`, return a `T(NaN)` if `isnan(x)`.

See also `tanh`.

source
`Base.Math.sind` — Function

    sind(x::T) where T -> float(T)

Compute sine of `x`, where `x` is in degrees. If `x` is a matrix, `x` needs to be a square matrix.

Throw a `DomainError` if `isinf(x)`, return a `T(NaN)` if `isnan(x)`.

Julia 1.7

Matrix arguments require Julia 1.7 or later.

source
`Base.Math.cosd` — Function

    cosd(x::T) where T -> float(T)

Compute cosine of `x`, where `x` is in degrees. If `x` is a matrix, `x` needs to be a square matrix.

Throw a `DomainError` if `isinf(x)`, return a `T(NaN)` if `isnan(x)`.

Julia 1.7

Matrix arguments require Julia 1.7 or later.

source
`Base.Math.tand` — Function

    tand(x::T) where T -> float(T)

Compute tangent of `x`, where `x` is in degrees. If `x` is a matrix, `x` needs to be a square matrix.

Throw a `DomainError` if `isinf(x)`, return a `T(NaN)` if `isnan(x)`.

Julia 1.7

Matrix arguments require Julia 1.7 or later.

source
`Base.Math.sincosd` — Function

    sincosd(x::T) where T -> Tuple{float(T),float(T)}

Simultaneously compute the sine and cosine of `x`, where `x` is in degrees, returning a tuple `(sine, cosine)`.

Throw a `DomainError` if `isinf(x)`, return a `(T(NaN), T(NaN))` tuple if `isnan(x)`.

Julia 1.3

This function requires at least Julia 1.3.

source
`Base.Math.sinpi` — Function

    sinpi(x::T) where T -> float(T)

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

Throw a `DomainError` if `isinf(x)`, return a `T(NaN)` if `isnan(x)`.

See also `sind`, `cospi`, `sincospi`.

source
`Base.Math.cospi` — Function

    cospi(x::T) where T -> float(T)

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

Throw a `DomainError` if `isinf(x)`, return a `T(NaN)` if `isnan(x)`.

See also: `cispi`, `sincosd`, `cospi`.

source
`Base.Math.tanpi` — Function

    tanpi(x::T) where T -> float(T)

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

Throw a `DomainError` if `isinf(x)`, return a `T(NaN)` if `isnan(x)`.

Julia 1.10

This function requires at least Julia 1.10.

See also `tand`, `sinpi`, `cospi`, `sincospi`.

source
`Base.Math.sincospi` — Function

    sincospi(x::T) where T -> Tuple{float(T),float(T)}

Simultaneously compute `sinpi(x)` and `cospi(x)` (the sine and cosine of `π*x`, where `x` is in radians), returning a tuple `(sine, cosine)`.

Throw a `DomainError` if `isinf(x)`, return a `(T(NaN), T(NaN))` tuple if `isnan(x)`.

Julia 1.6

This function requires Julia 1.6 or later.

See also: `cispi`, `sincosd`, `sinpi`.

source
`Base.sinh` — Method

    sinh(x)

Compute hyperbolic sine of `x`.

See also `sin`.

source
`Base.cosh` — Method

    cosh(x)

Compute hyperbolic cosine of `x`.

See also `cos`.

source
`Base.tanh` — Method

    tanh(x)

Compute hyperbolic tangent of `x`.

See also `tan`, `atanh`.

Examples

    julia> tanh.(-3:3f0)  # Here 3f0 isa Float32
    7-element Vector{Float32}:
     -0.9950548
     -0.9640276
     -0.7615942
      0.0
      0.7615942
      0.9640276
      0.9950548

    julia> tan.(im .* (1:3))
    3-element Vector{ComplexF64}:
     0.0 + 0.7615941559557649im
     0.0 + 0.9640275800758169im
     0.0 + 0.9950547536867306im

source
`Base.asin` — Method

    asin(x::T) where {T <: Number} -> float(T)

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

Return a `T(NaN)` if `isnan(x)`.

See also `asind` for output in degrees.

Examples

    julia> asin.((0, 1/2, 1))
    (0.0, 0.5235987755982989, 1.5707963267948966)

    julia> asind.((0, 1/2, 1))
    (0.0, 30.000000000000004, 90.0)

source
`Base.acos` — Method

    acos(x::T) where {T <: Number} -> float(T)

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

Return a `T(NaN)` if `isnan(x)`.

source
`Base.atan` — Method

    atan(y)
    atan(y, x)

Compute the inverse tangent of `y` or `y/x`, respectively.

For one real argument, this is the angle in radians between the positive x-axis and the point (1, y), returning a value in the interval $[-\pi/2, \pi/2]$.

For two arguments, this is the angle in radians between the positive x-axis and the point (x, y), returning a value in the interval $[-\pi, \pi]$. This corresponds to a standard `atan2` function. Note that by convention `atan(0.0,x)` is defined as $\pi$ and `atan(-0.0,x)` is defined as $-\pi$ when `x < 0`.

See also `atand` for degrees.

Examples

    julia> rad2deg(atan(-1/√3))
    -30.000000000000004

    julia> rad2deg(atan(-1, √3))
    -30.000000000000004

    julia> rad2deg(atan(1, -√3))
    150.0

source
`Base.Math.asind` — Function

    asind(x)

Compute the inverse sine of `x`, where the output is in degrees. If `x` is a matrix, `x` needs to be a square matrix.

Julia 1.7

Matrix arguments require Julia 1.7 or later.

source
`Base.Math.acosd` — Function

    acosd(x)

Compute the inverse cosine of `x`, where the output is in degrees. If `x` is a matrix, `x` needs to be a square matrix.

Julia 1.7

Matrix arguments require Julia 1.7 or later.

source
`Base.Math.atand` — Function

    atand(y::T) where T -> float(T)
    atand(y::T, x::S) where {T,S} -> promote_type(T,S)
    atand(y::AbstractMatrix{T}) where T -> AbstractMatrix{Complex{float(T)}}

Compute the inverse tangent of `y` or `y/x`, respectively, where the output is in degrees.

Return a `NaN` if `isnan(y)` or `isnan(x)`. The returned `NaN` is either a `T` in the single argument version, or a `promote_type(T,S)` in the two argument version.

Julia 1.7

The one-argument method supports square matrix arguments as of Julia 1.7.

source
`Base.Math.sec` — Method

    sec(x::T) where {T <: Number} -> float(T)

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

Throw a `DomainError` if `isinf(x)`, return a `T(NaN)` if `isnan(x)`.

source
`Base.Math.csc` — Method

    csc(x::T) where {T <: Number} -> float(T)

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

Throw a `DomainError` if `isinf(x)`, return a `T(NaN)` if `isnan(x)`.

source
`Base.Math.cot` — Method

    cot(x::T) where {T <: Number} -> float(T)

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

Throw a `DomainError` if `isinf(x)`, return a `T(NaN)` if `isnan(x)`.

source
`Base.Math.secd` — Function

    secd(x::T) where {T <: Number} -> float(T)

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

Throw a `DomainError` if `isinf(x)`, return a `T(NaN)` if `isnan(x)`.

source
`Base.Math.cscd` — Function

    cscd(x::T) where {T <: Number} -> float(T)

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

Throw a `DomainError` if `isinf(x)`, return a `T(NaN)` if `isnan(x)`.

source
`Base.Math.cotd` — Function

    cotd(x::T) where {T <: Number} -> float(T)

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

Throw a `DomainError` if `isinf(x)`, return a `T(NaN)` if `isnan(x)`.

source
`Base.Math.asec` — Method

    asec(x::T) where {T <: Number} -> float(T)

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

source
`Base.Math.acsc` — Method

    acsc(x::T) where {T <: Number} -> float(T)

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

source
`Base.Math.acot` — Method

    acot(x::T) where {T <: Number} -> float(T)

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. If `x` is a matrix, `x` needs to be a square matrix.

Julia 1.7

Matrix arguments require Julia 1.7 or later.

source
`Base.Math.acscd` — Function

    acscd(x)

Compute the inverse cosecant of `x`, where the output is in degrees. If `x` is a matrix, `x` needs to be a square matrix.

Julia 1.7

Matrix arguments require Julia 1.7 or later.

source
`Base.Math.acotd` — Function

    acotd(x)

Compute the inverse cotangent of `x`, where the output is in degrees. If `x` is a matrix, `x` needs to be a square matrix.

Julia 1.7

Matrix arguments require Julia 1.7 or later.

source
`Base.Math.sech` — Method

    sech(x::T) where {T <: Number} -> float(T)

Compute the hyperbolic secant of `x`.

Return a `T(NaN)` if `isnan(x)`.

source
`Base.Math.csch` — Method

    csch(x::T) where {T <: Number} -> float(T)

Compute the hyperbolic cosecant of `x`.

Return a `T(NaN)` if `isnan(x)`.

source
`Base.Math.coth` — Method

    coth(x::T) where {T <: Number} -> float(T)

Compute the hyperbolic cotangent of `x`.

Return a `T(NaN)` if `isnan(x)`.

source
`Base.asinh` — Method

    asinh(x)

Compute the inverse hyperbolic sine of `x`.

source
`Base.acosh` — Method

    acosh(x)

Compute the inverse hyperbolic cosine of `x`.

source
`Base.atanh` — Method

    atanh(x)

Compute the inverse hyperbolic tangent of `x`.

source
`Base.Math.asech` — Method

    asech(x::T) where {T <: Number} -> float(T)

Compute the inverse hyperbolic secant of `x`.

source
`Base.Math.acsch` — Method

    acsch(x::T) where {T <: Number} -> float(T)

Compute the inverse hyperbolic cosecant of `x`.

source
`Base.Math.acoth` — Method

    acoth(x::T) where {T <: Number} -> float(T)

Compute the inverse hyperbolic cotangent of `x`.

source
`Base.Math.sinc` — Function

    sinc(x::T) where {T <: Number} -> float(T)

Compute normalized sinc function $\operatorname{sinc}(x) = \sin(\pi x) / (\pi x)$ if $x \neq 0$, and $1$ if $x = 0$.

Return a `T(NaN)` if `isnan(x)`.

See also `cosc`, its derivative.

source
`Base.Math.cosc` — Function

    cosc(x::T) where {T <: Number} -> float(T)

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

Return a `T(NaN)` if `isnan(x)`.

See also `sinc`.

source
`Base.Math.deg2rad` — Function

    deg2rad(x)

Convert `x` from degrees to radians.

See also `rad2deg`, `sind`, `pi`.

Examples

    julia> deg2rad(90)
    1.5707963267948966

source
`Base.Math.rad2deg` — Function

    rad2deg(x)

Convert `x` from radians to degrees.

See also `deg2rad`.

Examples

    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.

This code is an implementation of the algorithm described in: An Improved Algorithm for `hypot(a,b)` by Carlos F. Borges The article is available online at arXiv at the link https://arxiv.org/abs/1904.09481

    hypot(x...)

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

See also `norm` in the `LinearAlgebra` standard library.

Examples

    julia> a = Int64(10)^10;

    julia> hypot(a, a)
    1.4142135623730951e10

    julia> √(a^2 + a^2) # a^2 overflows
    ERROR: DomainError with -2.914184810805068e18:
    sqrt was called with a negative real argument but will only return a complex result if called with a complex argument. Try sqrt(Complex(x)).
    Stacktrace:
    [...]

    julia> hypot(3, 4im)
    5.0

    julia> hypot(-5.7)
    5.7

    julia> hypot(3, 4im, 12.0)
    13.0

    julia> using LinearAlgebra

    julia> norm([a, a, a, a]) == hypot(a, a, a, a)
    true

source
`Base.log` — Method

    log(x)

Compute the natural logarithm of `x`.

Throw a `DomainError` for negative `Real` arguments. Use `Complex` arguments to obtain `Complex` results.

Branch cut

`log` has a branch cut along the negative real axis; `-0.0im` is taken to be below the axis.

See also `ℯ`, `log1p`, `log2`, `log10`.

Examples

    julia> log(2)
    0.6931471805599453

    julia> log(-3)
    ERROR: DomainError with -3.0:
    log was called with a negative real argument but will only return a complex result if called with a complex argument. Try log(Complex(x)).
    Stacktrace:
     [1] throw_complex_domainerror(::Symbol, ::Float64) at ./math.jl:31
    [...]

    julia> log(-3 + 0im)
    1.0986122886681098 + 3.141592653589793im

    julia> log(-3 - 0.0im)
    1.0986122886681098 - 3.141592653589793im

    julia> log.(exp.(-1:1))
    3-element Vector{Float64}:
     -1.0
      0.0
      1.0

source
`Base.log` — Method

    log(b,x)

Compute the base `b` logarithm of `x`. Throw a `DomainError` for negative `Real` arguments.

Examples

    julia> log(4,8)
    1.5

    julia> log(4,2)
    0.5

    julia> log(-2, 3)
    ERROR: DomainError with -2.0:
    log was called with a negative real argument but will only return a complex result if called with a complex argument. Try log(Complex(x)).
    Stacktrace:
     [1] throw_complex_domainerror(::Symbol, ::Float64) at ./math.jl:31
    [...]

    julia> log(2, -3)
    ERROR: DomainError with -3.0:
    log was called with a negative real argument but will only return a complex result if called with a complex argument. Try log(Complex(x)).
    Stacktrace:
     [1] throw_complex_domainerror(::Symbol, ::Float64) at ./math.jl:31
    [...]

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. Throw a `DomainError` for negative `Real` arguments.

See also: `exp2`, `ldexp`, `ispow2`.

Examples

    julia> log2(4)
    2.0

    julia> log2(10)
    3.321928094887362

    julia> log2(-2)
    ERROR: DomainError with -2.0:
    log2 was called with a negative real argument but will only return a complex result if called with a complex argument. Try log2(Complex(x)).
    Stacktrace:
     [1] throw_complex_domainerror(f::Symbol, x::Float64) at ./math.jl:31
    [...]

    julia> log2.(2.0 .^ (-1:1))
    3-element Vector{Float64}:
     -1.0
      0.0
      1.0

source
`Base.log10` — Function

    log10(x)

Compute the logarithm of `x` to base 10. Throw a `DomainError` for negative `Real` arguments.

Examples

    julia> log10(100)
    2.0

    julia> log10(2)
    0.3010299956639812

    julia> log10(-2)
    ERROR: DomainError with -2.0:
    log10 was called with a negative real argument but will only return a complex result if called with a complex argument. Try log10(Complex(x)).
    Stacktrace:
     [1] throw_complex_domainerror(f::Symbol, x::Float64) at ./math.jl:31
    [...]

source
`Base.log1p` — Function

    log1p(x)

Accurate natural logarithm of `1+x`. Throw a `DomainError` for `Real` arguments less than -1.

Examples

    julia> log1p(-0.5)
    -0.6931471805599453

    julia> log1p(0)
    0.0

    julia> log1p(-2)
    ERROR: DomainError with -2.0:
    log1p was called with a real argument < -1 but will only return a complex result if called with a complex argument. Try log1p(Complex(x)).
    Stacktrace:
     [1] throw_complex_domainerror(::Symbol, ::Float64) at ./math.jl:31
    [...]

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

See also `significand`, `exponent`, `ldexp`.

Examples

    julia> frexp(6.0)
    (0.75, 3)

    julia> significand(6.0), exponent(6.0)  # interval [1, 2) instead
    (1.5, 2)

    julia> frexp(0.0), frexp(NaN), frexp(-Inf)  # exponent would give an error
    ((0.0, 0), (NaN, 0), (-Inf, 0))

source
`Base.exp` — Method

    exp(x)

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

See also `exp2`, `exp10` and `cis`.

Examples

    julia> exp(1.0)
    2.718281828459045

    julia> exp(im * pi) ≈ cis(pi)
    true

source
`Base.exp2` — Function

    exp2(x)

Compute the base 2 exponential of `x`, in other words $2^x$.

See also `ldexp`, `<<`.

Examples

    julia> exp2(5)
    32.0

    julia> 2^5
    32

    julia> exp2(63) > typemax(Int)
    true

source
`Base.exp10` — Function

    exp10(x)

Compute the base 10 exponential of `x`, in other words $10^x$.

Examples

    julia> exp10(2)
    100.0

    julia> 10^2
    100

source
`Base.Math.ldexp` — Function

    ldexp(x, n)

Compute $x \times 2^n$.

See also `frexp`, `exponent`.

Examples

    julia> ldexp(5.0, 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.

Examples

    julia> modf(3.5)
    (0.5, 3.0)

    julia> modf(-3.5)
    (-0.5, -3.0)

source
`Base.expm1` — Function

    expm1(x)

Accurately compute $e^x-1$. It avoids the loss of precision involved in the direct evaluation of exp(x)-1 for small values of x.

Examples

    julia> expm1(1e-16)
    1.0e-16

    julia> exp(1e-16) - 1
    0.0

source
`Base.round` — Function

    round([T,] x, [r::RoundingMode])
    round(x, [r::RoundingMode]; digits::Integer=0, base = 10)
    round(x, [r::RoundingMode]; sigdigits::Integer, base = 10)

Rounds the number `x`.

Without keyword arguments, `x` is rounded to an integer value, returning a value of type `T`, or of the same type of `x` if no `T` is provided. An `InexactError` will be thrown if the value is not representable by `T`, similar to `convert`.

If the `digits` keyword argument is provided, it rounds to the specified number of digits after the decimal place (or before if negative), in base `base`.

If the `sigdigits` keyword argument is provided, it rounds to the specified number of significant digits, in base `base`.

The `RoundingMode` `r` controls the direction of the rounding; the default is `RoundNearest`, which rounds to the nearest integer, with ties (fractional values of 0.5) being rounded to the nearest even integer. Note that `round` may give incorrect results if the global rounding mode is changed (see `rounding`).

When rounding to a floating point type, will round to integers representable by that type (and Inf) rather than true integers. Inf is treated as one ulp greater than the `floatmax(T)` for purposes of determining "nearest", similar to `convert`.

Examples

    julia> round(1.7)
    2.0

    julia> round(Int, 1.7)
    2

    julia> round(1.5)
    2.0

    julia> round(2.5)
    2.0

    julia> round(pi; digits=2)
    3.14

    julia> round(pi; digits=3, base=2)
    3.125

    julia> round(123.456; sigdigits=2)
    120.0

    julia> round(357.913; sigdigits=4, base=2)
    352.0

    julia> round(Float16, typemax(UInt128))
    Inf16

    julia> floor(Float16, typemax(UInt128))
    Float16(6.55e4)

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. For example:

    julia> x = 1.15
    1.15

    julia> big(1.15)
    1.149999999999999911182158029987476766109466552734375

    julia> x < 115//100
    true

    julia> round(x, digits=1)
    1.2

Extensions

To extend `round` to new numeric types, it is typically sufficient to define `Base.round(x::NewType, r::RoundingMode)`.

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`
- `RoundUp`
- `RoundDown`

Julia 1.9

`RoundFromZero` requires at least Julia 1.9. Prior versions support `RoundFromZero` for `BigFloat`s only.

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.RoundFromZero` — Constant

    RoundFromZero

Rounds away from zero.

Julia 1.9

`RoundFromZero` requires at least Julia 1.9. Prior versions support `RoundFromZero` for `BigFloat`s only.

Examples

    julia> BigFloat("1.0000000000000001", 5, RoundFromZero)
    1.06

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::Complex[, RoundingModeReal, [RoundingModeImaginary]])
    round(z::Complex[, RoundingModeReal, [RoundingModeImaginary]]; digits=0, base=10)
    round(z::Complex[, RoundingModeReal, [RoundingModeImaginary]]; sigdigits, base=10)

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

`RoundingModeReal` and `RoundingModeImaginary` default to `RoundNearest`, which rounds to the nearest integer, with ties (fractional values of 0.5) being rounded to the nearest even integer.

Examples

    julia> round(3.14 + 4.5im)
    3.0 + 4.0im

    julia> round(3.14 + 4.5im, RoundUp, RoundNearestTiesUp)
    4.0 + 5.0im

    julia> round(3.14159 + 4.512im; digits = 1)
    3.1 + 4.5im

    julia> round(3.14159 + 4.512im; sigdigits = 3)
    3.14 + 4.51im

source
`Base.ceil` — Function

    ceil([T,] x)
    ceil(x; digits::Integer= [, base = 10])
    ceil(x; sigdigits::Integer= [, base = 10])

`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 ceiled value is not representable as a `T`.

Keywords `digits`, `sigdigits` and `base` work as for `round`.

To support `ceil` for a new type, define `Base.round(x::NewType, ::RoundingMode{:Up})`.

source
`Base.floor` — Function

    floor([T,] x)
    floor(x; digits::Integer= [, base = 10])
    floor(x; sigdigits::Integer= [, base = 10])

`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 floored value is not representable a `T`.

Keywords `digits`, `sigdigits` and `base` work as for `round`.

To support `floor` for a new type, define `Base.round(x::NewType, ::RoundingMode{:Down})`.

source
`Base.trunc` — Function

    trunc([T,] x)
    trunc(x; digits::Integer= [, base = 10])
    trunc(x; sigdigits::Integer= [, base = 10])

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

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

Keywords `digits`, `sigdigits` and `base` work as for `round`.

To support `trunc` for a new type, define `Base.round(x::NewType, ::RoundingMode{:ToZero})`.

See also: `%`, `floor`, `unsigned`, `unsafe_trunc`.

Examples

    julia> trunc(2.22)
    2.0

    julia> trunc(-2.22, digits=1)
    -2.2

    julia> trunc(Int, -2.22)
    -2

source
`Base.unsafe_trunc` — Function

    unsafe_trunc(T, x)

Return the nearest integral value of type `T` whose absolute value is less than or equal to the absolute value of `x`. If the value is not representable by `T`, an arbitrary value will be returned. See also `trunc`.

Examples

    julia> unsafe_trunc(Int, -2.2)
    -2

    julia> unsafe_trunc(Int, NaN)
    -9223372036854775808

source
`Base.min` — Function

    min(x, y, ...)

Return the minimum of the arguments, with respect to `isless`. If any of the arguments is `missing`, return `missing`. See also the `minimum` function to take the minimum element from a collection.

Examples

    julia> min(2, 5, 1)
    1

    julia> min(4, missing, 6)
    missing

source
`Base.max` — Function

    max(x, y, ...)

Return the maximum of the arguments, with respect to `isless`. If any of the arguments is `missing`, return `missing`. See also the `maximum` function to take the maximum element from a collection.

Examples

    julia> max(2, 5, 1)
    5

    julia> max(5, missing, 6)
    missing

source
`Base.minmax` — Function

    minmax(x, y)

Return `(min(x,y), max(x,y))`.

See also `extrema` that returns `(minimum(x), maximum(x))`.

Examples

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

source
`Base.clamp` — Function

    clamp(x::Integer, r::AbstractUnitRange)

Clamp `x` to lie within range `r`.

Julia 1.6

This method requires at least Julia 1.6.

source

    clamp(x, T)::T

Clamp `x` between `typemin(T)` and `typemax(T)` and convert the result to type `T`.

See also `trunc`.

Examples

    julia> clamp(200, Int8)
    127

    julia> clamp(-200, Int8)
    -128

    julia> trunc(Int, 4pi^2)
    39

source

    clamp(x, lo, hi)

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

See also `clamp!`, `min`, `max`.

Julia 1.3

`missing` as the first argument requires at least Julia 1.3.

Examples

    julia> clamp.([pi, 1.0, big(10)], 2.0, 9.0)
    3-element Vector{BigFloat}:
     3.141592653589793238462643383279502884197169399375105820974944592307816406286198
     2.0
     9.0

    julia> clamp.([11, 8, 5], 10, 6)  # an example where lo > hi
    3-element Vector{Int64}:
      6
      6
     10

source
`Base.clamp!` — Function

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

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

Julia 1.3

`missing` entries in `array` require at least Julia 1.3.

Examples

    julia> row = collect(-4:4)';

    julia> clamp!(row, 0, Inf)
    1×9 adjoint(::Vector{Int64}) with eltype Int64:
     0  0  0  0  0  1  2  3  4

    julia> clamp.((-4:4)', 0, Inf)
    1×9 Matrix{Float64}:
     0.0  0.0  0.0  0.0  0.0  1.0  2.0  3.0  4.0

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.

See also: `abs2`, `unsigned`, `sign`.

Examples

    julia> abs(-3)
    3

    julia> abs(1 + im)
    1.4142135623730951

    julia> abs.(Int8[-128 -127 -126 0 126 127])  # overflow at typemin(Int8)
    1×6 Matrix{Int8}:
     -128  127  126  0  126  127

    julia> maximum(abs, [1, -2, 3, -4])
    4

source
`Base.Checked` — Module

    Checked

The Checked module provides arithmetic functions for the built-in signed and unsigned Integer types which throw an error when an overflow occurs. They are named like `checked_sub`, `checked_div`, etc. In addition, `add_with_overflow`, `sub_with_overflow`, `mul_with_overflow` return both the unchecked results and a boolean value denoting the presence of an overflow.

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.

The overflow protection may impose a perceptible performance penalty.

source
`Base.Checked.checked_neg` — Function

    Base.checked_neg(x)

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

The overflow protection may impose a perceptible performance penalty.

source
`Base.Checked.checked_add` — Function

    Base.checked_add(x, y)

Calculates `x+y`, checking for overflow errors where applicable.

The overflow protection may impose a perceptible performance penalty.

source
`Base.Checked.checked_sub` — Function

    Base.checked_sub(x, y)

Calculates `x-y`, checking for overflow errors where applicable.

The overflow protection may impose a perceptible performance penalty.

source
`Base.Checked.checked_mul` — Function

    Base.checked_mul(x, y)

Calculates `x*y`, checking for overflow errors where applicable.

The overflow protection may impose a perceptible performance penalty.

source
`Base.Checked.checked_div` — Function

    Base.checked_div(x, y)

Calculates `div(x,y)`, checking for overflow errors where applicable.

The overflow protection may impose a perceptible performance penalty.

source
`Base.Checked.checked_rem` — Function

    Base.checked_rem(x, y)

Calculates `x%y`, checking for overflow errors where applicable.

The overflow protection may impose a perceptible performance penalty.

source
`Base.Checked.checked_fld` — Function

    Base.checked_fld(x, y)

Calculates `fld(x,y)`, checking for overflow errors where applicable.

The overflow protection may impose a perceptible performance penalty.

source
`Base.Checked.checked_mod` — Function

    Base.checked_mod(x, y)

Calculates `mod(x,y)`, checking for overflow errors where applicable.

The overflow protection may impose a perceptible performance penalty.

source
`Base.Checked.checked_cld` — Function

    Base.checked_cld(x, y)

Calculates `cld(x,y)`, checking for overflow errors where applicable.

The overflow protection may impose a perceptible performance penalty.

source
`Base.Checked.checked_pow` — Function

    Base.checked_pow(x, y)

Calculates `^(x,y)`, checking for overflow errors where applicable.

The overflow protection may impose a perceptible performance penalty.

source
`Base.Checked.add_with_overflow` — Function

    Base.add_with_overflow(x, y) -> (r, f)

Calculates `r = x+y`, with the flag `f` indicating whether overflow has occurred.

source
`Base.Checked.sub_with_overflow` — Function

    Base.sub_with_overflow(x, y) -> (r, f)

Calculates `r = x-y`, with the flag `f` indicating whether overflow has occurred.

source
`Base.Checked.mul_with_overflow` — Function

    Base.mul_with_overflow(x, y) -> (r, f)

Calculates `r = x*y`, with the flag `f` indicating whether overflow has occurred.

source
`Base.abs2` — Function

    abs2(x)

Squared absolute value of `x`.

This can be faster than `abs(x)^2`, especially for complex numbers where `abs(x)` requires a square root via `hypot`.

See also `abs`, `conj`, `real`.

Examples

    julia> abs2(-3)
    9

    julia> abs2(3.0 + 4.0im)
    25.0

    julia> sum(abs2, [1+2im, 3+4im])  # LinearAlgebra.norm(x)^2
    30

source
`Base.copysign` — Function

    copysign(x, y) -> z

Return `z` which has the magnitude of `x` and the same sign as `y`.

Examples

    julia> copysign(1, -2)
    -1

    julia> copysign(-1, 2)
    1

source
`Base.sign` — Function

    sign(x)

Return zero if `x==0` and $x/|x|$ otherwise (i.e., ±1 for real `x`).

See also `signbit`, `zero`, `copysign`, `flipsign`.

Examples

    julia> sign(-4.0)
    -1.0

    julia> sign(99)
    1

    julia> sign(-0.0)
    -0.0

    julia> sign(0 + im)
    0.0 + 1.0im

source
`Base.signbit` — Function

    signbit(x)

Return `true` if the value of the sign of `x` is negative, otherwise `false`.

See also `sign` and `copysign`.

Examples

    julia> signbit(-4)
    true

    julia> signbit(5)
    false

    julia> signbit(5.5)
    false

    julia> signbit(-4.1)
    true

source
`Base.flipsign` — Function

    flipsign(x, y)

Return `x` with its sign flipped if `y` is negative. For example `abs(x) = flipsign(x,x)`.

Examples

    julia> flipsign(5, 3)
    5

    julia> flipsign(5, -3)
    -5

source
`Base.sqrt` — Method

    sqrt(x)

Return $\sqrt{x}$.

Throw a `DomainError` for negative `Real` arguments. Use `Complex` negative arguments instead to obtain a `Complex` result.

The prefix operator `√` is equivalent to `sqrt`.

Branch cut

`sqrt` has a branch cut along the negative real axis; `-0.0im` is taken to be below the axis.

See also: `hypot`.

Examples

    julia> sqrt(big(81))
    9.0

    julia> sqrt(big(-81))
    ERROR: DomainError with -81.0:
    NaN result for non-NaN input.
    Stacktrace:
     [1] sqrt(::BigFloat) at ./mpfr.jl:501
    [...]

    julia> sqrt(big(complex(-81)))
    0.0 + 9.0im

    julia> sqrt(-81 - 0.0im)  # -0.0im is below the branch cut
    0.0 - 9.0im

    julia> .√(1:4)
    4-element Vector{Float64}:
     1.0
     1.4142135623730951
     1.7320508075688772
     2.0

source
`Base.isqrt` — Function

    isqrt(n::Integer)

Integer square root: the largest integer `m` such that `m*m <= n`.

    julia> isqrt(5)
    2

source
`Base.Math.cbrt` — Method

    cbrt(x::Real)

Return the cube root of `x`, i.e. $x^{1/3}$. Negative values are accepted (returning the negative real root when $x < 0$).

The prefix operator `∛` is equivalent to `cbrt`.

Examples

    julia> cbrt(big(27))
    3.0

    julia> cbrt(big(-27))
    -3.0

source
`Base.Math.fourthroot` — Method

    fourthroot(x)

Return the fourth root of `x` by applying `sqrt` twice successively.

source
`Base.real` — Function

    real(A::AbstractArray)

Return an array containing the real part of each entry in array `A`.

Equivalent to `real.(A)`, except that when `eltype(A) <: Real` `A` is returned without copying, and that when `A` has zero dimensions, a 0-dimensional array is returned (rather than a scalar).

Examples

    julia> real([1, 2im, 3 + 4im])
    3-element Vector{Int64}:
     1
     0
     3

    julia> real(fill(2 - im))
    0-dimensional Array{Int64, 0}:
    2

source

    real(T::Type)

Return the type that represents the real part of a value of type `T`. e.g: for `T == Complex{R}`, returns `R`. Equivalent to `typeof(real(zero(T)))`.

Examples

    julia> real(Complex{Int})
    Int64

    julia> real(Float64)
    Float64

source

    real(z)

Return the real part of the complex number `z`.

See also: `imag`, `reim`, `complex`, `isreal`, `Real`.

Examples

    julia> real(1 + 3im)
    1

source
`Base.imag` — Function

    imag(A::AbstractArray)

Return an array containing the imaginary part of each entry in array `A`.

Equivalent to `imag.(A)`, except that when `A` has zero dimensions, a 0-dimensional array is returned (rather than a scalar).

Examples

    julia> imag([1, 2im, 3 + 4im])
    3-element Vector{Int64}:
     0
     2
     4

    julia> imag(fill(2 - im))
    0-dimensional Array{Int64, 0}:
    -1

source

    imag(z)

Return the imaginary part of the complex number `z`.

See also: `conj`, `reim`, `adjoint`, `angle`.

Examples

    julia> imag(1 + 3im)
    3

source
`Base.reim` — Function

    reim(A::AbstractArray)

Return a tuple of two arrays containing respectively the real and the imaginary part of each entry in `A`.

Equivalent to `(real.(A), imag.(A))`, except that when `eltype(A) <: Real` `A` is returned without copying to represent the real part, and that when `A` has zero dimensions, a 0-dimensional array is returned (rather than a scalar).

Examples

    julia> reim([1, 2im, 3 + 4im])
    ([1, 0, 3], [0, 2, 4])

    julia> reim(fill(2 - im))
    (fill(2), fill(-1))

source

    reim(z)

Return a tuple of the real and imaginary parts of the complex number `z`.

Examples

    julia> reim(1 + 3im)
    (1, 3)

source
`Base.conj` — Function

    conj(A::AbstractArray)

Return an array containing the complex conjugate of each entry in array `A`.

Equivalent to `conj.(A)`, except that when `eltype(A) <: Real` `A` is returned without copying, and that when `A` has zero dimensions, a 0-dimensional array is returned (rather than a scalar).

Examples

    julia> conj([1, 2im, 3 + 4im])
    3-element Vector{Complex{Int64}}:
     1 + 0im
     0 - 2im
     3 - 4im

    julia> conj(fill(2 - im))
    0-dimensional Array{Complex{Int64}, 0}:
    2 + 1im

source

    conj(z)

Compute the complex conjugate of a complex number `z`.

See also: `angle`, `adjoint`.

Examples

    julia> conj(1 + 3im)
    1 - 3im

source
`Base.angle` — Function

    angle(z)

Compute the phase angle in radians of a complex number `z`.

Returns a number `-pi ≤ angle(z) ≤ pi`, and is thus discontinuous along the negative real axis.

See also: `atan`, `cis`, `rad2deg`.

Examples

    julia> rad2deg(angle(1 + im))
    45.0

    julia> rad2deg(angle(1 - im))
    -45.0

    julia> rad2deg(angle(-1 + 1e-20im))
    180.0

    julia> rad2deg(angle(-1 - 1e-20im))
    -180.0

source
`Base.cis` — Function

    cis(x)

More efficient method for `exp(im*x)` by using Euler's formula: $\cos(x) + i \sin(x) = \exp(i x)$.

See also `cispi`, `sincos`, `exp`, `angle`.

Examples

    julia> cis(π) ≈ -1
    true

source
`Base.cispi` — Function

    cispi(x)

More accurate method for `cis(pi*x)` (especially for large `x`).

See also `cis`, `sincospi`, `exp`, `angle`.

Examples

    julia> cispi(10000)
    1.0 + 0.0im

    julia> cispi(0.25 + 1im)
    0.030556854645954562 + 0.03055685464595456im

Julia 1.6

This function requires Julia 1.6 or later.

source
`Base.binomial` — Function

    binomial(x::Number, k::Integer)

The generalized binomial coefficient, defined for `k ≥ 0` by the polynomial

\[\frac{1}{k!} \prod_{j=0}^{k-1} (x - j)\]

When `k < 0` it returns zero.

For the case of integer `x`, this is equivalent to the ordinary integer binomial coefficient

\[\binom{n}{k} = \frac{n!}{k! (n-k)!}\]

Further generalizations to non-integer `k` are mathematically possible, but involve the Gamma function and/or the beta function, which are not provided by the Julia standard library but are available in external packages such as SpecialFunctions.jl.

External links

- Binomial coefficient on Wikipedia.

source

    binomial(n::Integer, k::Integer)

The binomial coefficient $\binom{n}{k}$, being the coefficient of the $k$th term in the polynomial expansion of $(1+x)^n$.

If $n$ is non-negative, then it is the number of ways to choose `k` out of `n` items:

\[\binom{n}{k} = \frac{n!}{k! (n-k)!}\]

where $n!$ is the `factorial` function.

If $n$ is negative, then it is defined in terms of the identity

\[\binom{n}{k} = (-1)^k \binom{k-n-1}{k}\]

See also `factorial`.

Examples

    julia> binomial(5, 3)
    10

    julia> factorial(5) ÷ (factorial(5-3) * factorial(3))
    10

    julia> binomial(-5, 3)
    -35

External links

- Binomial coefficient on Wikipedia.

source
`Base.factorial` — Function

    factorial(n::Integer)

Factorial of `n`. If `n` is an `Integer`, the factorial is computed as an integer (promoted to at least 64 bits). Note that this may overflow if `n` is not small, but you can use `factorial(big(n))` to compute the result exactly in arbitrary precision.

See also `binomial`.

Examples

    julia> factorial(6)
    720

    julia> factorial(21)
    ERROR: OverflowError: 21 is too large to look up in the table; consider using `factorial(big(21))` instead
    Stacktrace:
    [...]

    julia> factorial(big(21))
    51090942171709440000

External links

- Factorial on Wikipedia.

source
`Base.gcd` — Function

    gcd(x, y...)

Greatest common (positive) divisor (or zero if all arguments are zero). The arguments may be integer and rational numbers.

$a$ is a divisor of $b$ if there exists an integer $m$ such that $ma=b$.

Julia 1.4

Rational arguments require Julia 1.4 or later.

Examples

    julia> gcd(6, 9)
    3

    julia> gcd(6, -9)
    3

    julia> gcd(6, 0)
    6

    julia> gcd(0, 0)
    0

    julia> gcd(1//3, 2//3)
    1//3

    julia> gcd(1//3, -2//3)
    1//3

    julia> gcd(1//3, 2)
    1//3

    julia> gcd(0, 0, 10, 15)
    5

source
`Base.lcm` — Function

    lcm(x, y...)

Least common (positive) multiple (or zero if any argument is zero). The arguments may be integer and rational numbers.

$a$ is a multiple of $b$ if there exists an integer $m$ such that $a=mb$.

Julia 1.4

Rational arguments require Julia 1.4 or later.

Examples

    julia> lcm(2, 3)
    6

    julia> lcm(-2, 3)
    6

    julia> lcm(0, 3)
    0

    julia> lcm(0, 0)
    0

    julia> lcm(1//3, 2//3)
    2//3

    julia> lcm(1//3, -2//3)
    2//3

    julia> lcm(1//3, 2)
    2//1

    julia> lcm(1, 3, 5, 7)
    105

source
`Base.gcdx` — Function

    gcdx(a, b...)

Computes the greatest common (positive) divisor of `a` and `b` and their Bézout coefficients, i.e. the integer coefficients `u` and `v` that satisfy $u*a + v*b = d = gcd(a, b)$. $gcdx(a, b)$ returns $(d, u, v)$.

For more arguments than two, i.e., `gcdx(a, b, c, ...)` the Bézout coefficients are computed recursively, returning a solution `(d, u, v, w, ...)` to $u*a + v*b + w*c + ... = d = gcd(a, b, c, ...)$.

The arguments may be integer and rational numbers.

Julia 1.4

Rational arguments require Julia 1.4 or later.

Julia 1.12

More or fewer arguments than two require Julia 1.12 or later.

Examples

    julia> gcdx(12, 42)
    (6, -3, 1)

    julia> gcdx(240, 46)
    (2, -9, 47)

    julia> gcdx(15, 12, 20)
    (1, 7, -7, -1)

Note

Bézout coefficients are not uniquely defined. `gcdx` returns the minimal Bézout coefficients that are computed by the extended Euclidean algorithm. (Ref: D. Knuth, TAoCP, 2/e, p. 325, Algorithm X.) For signed integers, these coefficients `u` and `v` are minimal in the sense that $|u| < |b/d|$ and $|v| < |a/d|$. Furthermore, the signs of `u` and `v` are chosen so that `d` is positive. For unsigned integers, the coefficients `u` and `v` might be near their `typemax`, and the identity then holds only via the unsigned integers' modulo arithmetic.

source
`Base.ispow2` — Function

    ispow2(n::Number) -> Bool

Test whether `n` is an integer power of two.

See also `count_ones`, `prevpow`, `nextpow`.

Examples

    julia> ispow2(4)
    true

    julia> ispow2(5)
    false

    julia> ispow2(4.5)
    false

    julia> ispow2(0.25)
    true

    julia> ispow2(1//8)
    true

Julia 1.6

Support for non-`Integer` arguments was added in Julia 1.6.

source
`Base.nextpow` — Function

    nextpow(a, x)

The smallest `a^n` not less than `x`, where `n` is a non-negative integer. `a` must be greater than 1, and `x` must be greater than 0.

See also `prevpow`.

Examples

    julia> nextpow(2, 7)
    8

    julia> nextpow(2, 9)
    16

    julia> nextpow(5, 20)
    25

    julia> nextpow(4, 16)
    16

source
`Base.prevpow` — Function

    prevpow(a, x)

The largest `a^n` not greater than `x`, where `n` is a non-negative integer. `a` must be greater than 1, and `x` must not be less than 1.

See also `nextpow`, `isqrt`.

Examples

    julia> prevpow(2, 7)
    4

    julia> prevpow(2, 9)
    8

    julia> prevpow(5, 20)
    5

    julia> prevpow(4, 16)
    16

source
`Base.nextprod` — Function

    nextprod(factors::Union{Tuple,AbstractVector}, n)

Next integer greater than or equal to `n` that can be written as $\prod k_i^{p_i}$ for integers $p_1$, $p_2$, etcetera, for factors $k_i$ in `factors`.

Examples

    julia> nextprod((2, 3), 105)
    108

    julia> 2^2 * 3^3
    108

Julia 1.6

The method that accepts a tuple requires Julia 1.6 or later.

source
`Base.invmod` — Function

    invmod(n::Integer, T) where {T <: Base.BitInteger}
    invmod(n::T) where {T <: Base.BitInteger}

Compute the modular inverse of `n` in the integer ring of type `T`, i.e. modulo `2^N` where `N = 8*sizeof(T)` (e.g. `N = 32` for `Int32`). In other words, these methods satisfy the following identities:

    n * invmod(n) == 1
    (n * invmod(n, T)) % T == 1
    (n % T) * invmod(n, T) == 1

Note that `*` here is modular multiplication in the integer ring, `T`. This will throw an error if `n` is even, because then it is not relatively prime with `2^N` and thus has no such inverse.

Specifying the modulus implied by an integer type as an explicit value is often inconvenient since the modulus is by definition too big to be represented by the type.

The modular inverse is computed much more efficiently than the general case using the algorithm described in https://arxiv.org/pdf/2204.04342.pdf.

Julia 1.11

The `invmod(n)` and `invmod(n, T)` methods require Julia 1.11 or later.

source

    invmod(n::Integer, m::Integer)

Take the inverse of `n` modulo `m`: `y` such that $n y = 1 \pmod m$, and $div(y,m) = 0$. This will throw an error if $m = 0$, or if $gcd(n,m) \neq 1$.

Examples

    julia> invmod(2, 5)
    3

    julia> invmod(2, 3)
    2

    julia> invmod(5, 6)
    5

source
`Base.powermod` — Function

    powermod(x::Integer, p::Integer, m)

Compute $x^p \pmod m$.

Examples

    julia> powermod(2, 6, 5)
    4

    julia> mod(2^6, 5)
    4

    julia> powermod(5, 2, 20)
    5

    julia> powermod(5, 2, 19)
    6

    julia> powermod(5, 3, 19)
    11

source
`Base.ndigits` — Function

    ndigits(n::Integer; base::Integer=10, pad::Integer=1)

Compute the number of digits in integer `n` written in base `base` (`base` must not be in `[-1, 0, 1]`), optionally padded with zeros to a specified size (the result will never be less than `pad`).

See also `digits`, `count_ones`.

Examples

    julia> ndigits(0)
    1

    julia> ndigits(12345)
    5

    julia> ndigits(1022, base=16)
    3

    julia> string(1022, base=16)
    "3fe"

    julia> ndigits(123, pad=5)
    5

    julia> ndigits(-123)
    3

source
`Base.add_sum` — Function

    Base.add_sum(x, y)

The reduction operator used in `sum`. The main difference from `+` is that small integers are promoted to `Int`/`UInt`.

source
`Base.widemul` — Function

    widemul(x, y)

Multiply `x` and `y`, giving the result as a larger type.

See also `promote`, `Base.add_sum`.

Examples

    julia> widemul(Float32(3.0), 4.0) isa BigFloat
    true

    julia> typemax(Int8) * typemax(Int8)
    1

    julia> widemul(typemax(Int8), typemax(Int8))  # == 127^2
    16129

source
`Base.Math.evalpoly` — Function

    evalpoly(x, p)

Evaluate the polynomial $\sum_k x^{k-1} p[k]$ for the coefficients `p[1]`, `p[2]`, ...; that is, the coefficients are given in ascending order by power of `x`. Loops are unrolled at compile time if the number of coefficients is statically known, i.e. when `p` is a `Tuple`. This function generates efficient code using Horner's method if `x` is real, or using a Goertzel-like [DK62] algorithm if `x` is complex.

Julia 1.4

This function requires Julia 1.4 or later.

Examples

    julia> evalpoly(2, (1, 2, 3))
    17

source
`Base.Math.@evalpoly` — Macro

    @evalpoly(z, c...)

Evaluate the polynomial $\sum_k z^{k-1} c[k]$ for the coefficients `c[1]`, `c[2]`, ...; that is, the coefficients are given in ascending order by power of `z`. This macro expands to efficient inline code that uses either Horner's method or, for complex `z`, a more efficient Goertzel-like algorithm.

See also `evalpoly`.

Examples

    julia> @evalpoly(3, 1, 0, 1)
    10

    julia> @evalpoly(2, 1, 0, 1)
    5

    julia> @evalpoly(2, 1, 1, 1)
    7

source
`Base.FastMath.@fastmath` — Macro

    @fastmath expr

Execute a transformed version of the expression, which calls functions that may violate strict IEEE semantics. This allows the fastest possible operation, but results are undefined – be careful when doing this, as it may change numerical results.

This sets the LLVM Fast-Math flags, and corresponds to the `-ffast-math` option in clang. See the notes on performance annotations for more details.

Examples

    julia> @fastmath 1+2
    3

    julia> @fastmath(sin(3))
    0.1411200080598672

source

## Customizable binary operators

Some unicode characters can be used to define new binary operators that support infix notation. For example `⊗(x,y) = kron(x,y)` defines the `⊗` (otimes) function to be the Kronecker product, and one can call it as binary operator using infix syntax: `C = A ⊗ B` as well as with the usual prefix syntax `C = ⊗(A,B)`.

Other characters that support such extensions include \odot `⊙` and \oplus `⊕`

The complete list is in the parser code: https://github.com/JuliaLang/julia/blob/master/src/julia-parser.scm

Those that are parsed like `*` (in terms of precedence) include `* / ÷ % & ⋅ ∘ × |\\| ∩ ∧ ⊗ ⊘ ⊙ ⊚ ⊛ ⊠ ⊡ ⊓ ∗ ∙ ∤ ⅋ ≀ ⊼ ⋄ ⋆ ⋇ ⋉ ⋊ ⋋ ⋌ ⋏ ⋒ ⟑ ⦸ ⦼ ⦾ ⦿ ⧶ ⧷ ⨇ ⨰ ⨱ ⨲ ⨳ ⨴ ⨵ ⨶ ⨷ ⨸ ⨻ ⨼ ⨽ ⩀ ⩃ ⩄ ⩋ ⩍ ⩎ ⩑ ⩓ ⩕ ⩘ ⩚ ⩜ ⩞ ⩟ ⩠ ⫛ ⊍ ▷ ⨝ ⟕ ⟖ ⟗` and those that are parsed like `+` include `+ - |\|| ⊕ ⊖ ⊞ ⊟ |++| ∪ ∨ ⊔ ± ∓ ∔ ∸ ≏ ⊎ ⊻ ⊽ ⋎ ⋓ ⟇ ⧺ ⧻ ⨈ ⨢ ⨣ ⨤ ⨥ ⨦ ⨧ ⨨ ⨩ ⨪ ⨫ ⨬ ⨭ ⨮ ⨹ ⨺ ⩁ ⩂ ⩅ ⩊ ⩌ ⩏ ⩐ ⩒ ⩔ ⩖ ⩗ ⩛ ⩝ ⩡ ⩢ ⩣` There are many others that are related to arrows, comparisons, and powers.

- DK62Donald Knuth, Art of Computer Programming, Volume 2: Seminumerical Algorithms, Sec. 4.6.4.

Theme

This document was generated with Documenter.jl version 1.16.0 on Thursday 20 November 2025. Using Julia version 1.12.2.