Mathematics

Mathematical Operators

Base.:- — Method

  1. -(x)

Unary minus operator.

Examples

  1. julia> -1
  2. -1
  3. julia> -(2)
  4. -2
  5. julia> -[1 2; 3 4]
  6. 2×2 Matrix{Int64}:
  7. -1 -2
  8. -3 -4

source

Base.:+ — Function

  1. +(x, y...)

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

Examples

  1. julia> 1 + 20 + 4
  2. 25
  3. julia> +(1, 20, 4)
  4. 25

source

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

Base.:- — Method

  1. -(x, y)

Subtraction operator.

Examples

  1. julia> 2 - 3
  2. -1
  3. julia> -(2, 4.5)
  4. -2.5

source

Base.:* — Method

  1. *(x, y...)

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

Examples

  1. julia> 2 * 7 * 8
  2. 112
  3. julia> *(2, 7, 8)
  4. 112

source

Base.:/ — Function

  1. /(x, y)

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

Examples

  1. julia> 1/2
  2. 0.5
  3. julia> 4/2
  4. 2.0
  5. julia> 4.5/2
  6. 2.25

source

Base.:\ — Method

  1. \(x, y)

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

Examples

  1. julia> 3 \ 6
  2. 2.0
  3. julia> inv(3) * 6
  4. 2.0
  5. julia> A = [4 3; 2 1]; x = [5, 6];
  6. julia> A \ x
  7. 2-element Vector{Float64}:
  8. 6.5
  9. -7.0
  10. julia> inv(A) * x
  11. 2-element Vector{Float64}:
  12. 6.5
  13. -7.0

source

Base.:^ — Method

  1. ^(x, y)

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

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

  1. julia> 3^5
  2. 243
  3. julia> A = [1 2; 3 4]
  4. 2×2 Matrix{Int64}:
  5. 1 2
  6. 3 4
  7. julia> A^3
  8. 2×2 Matrix{Int64}:
  9. 37 54
  10. 81 118

source

Base.fma — Function

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

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

  1. julia> muladd(3, 2, 1)
  2. 7
  3. julia> 3 * 2 + 1
  4. 7

source

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

  1. julia> A=[1.0 2.0; 3.0 4.0]; B=[1.0 1.0; 1.0 1.0]; z=[0, 100];
  2. julia> muladd(A, B, z)
  3. 2×2 Matrix{Float64}:
  4. 3.0 3.0
  5. 107.0 107.0

source

Base.inv — Method

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

  1. julia> inv(2)
  2. 0.5
  3. julia> inv(1 + 2im)
  4. 0.2 - 0.4im
  5. julia> inv(1 + 2im) * (1 + 2im)
  6. 1.0 + 0.0im
  7. julia> inv(2//3)
  8. 3//2

Julia 1.2

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

source

Base.div — Function

  1. div(x, y)
  2. ÷(x, y)

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

Examples

  1. julia> 9 ÷ 4
  2. 2
  3. julia> -5 ÷ 3
  4. -1
  5. julia> 5.0 ÷ 2
  6. 2.0

source

Base.fld — Function

  1. fld(x, y)

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

See also: div

Examples

  1. julia> fld(7.3,5.5)
  2. 1.0

source

Base.cld — Function

  1. cld(x, y)

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

See also: div

Examples

  1. julia> cld(5.5,2.2)
  2. 3.0

source

Base.mod — Function

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

  1. julia> mod(0, Base.OneTo(3))
  2. 3
  3. julia> mod(3, 0:2)
  4. 0

Julia 1.3

This method requires at least Julia 1.3.

source

  1. mod(x, y)
  2. 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.

  1. julia> mod(8, 3)
  2. 2
  3. julia> mod(9, 3)
  4. 0
  5. julia> mod(8.9, 3)
  6. 2.9000000000000004
  7. julia> mod(eps(), 3)
  8. 2.220446049250313e-16
  9. julia> mod(-eps(), 3)
  10. 3.0

source

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

Find y::T such that xy (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

  1. julia> 129 % Int8
  2. -127

source

Base.rem — Function

  1. rem(x, y)
  2. %(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.

Examples

  1. julia> x = 15; y = 4;
  2. julia> x % y
  3. 3
  4. julia> x == div(x, y) * y + rem(x, y)
  5. true

source

Base.Math.rem2pi — Function

  1. rem2pi(x, r::RoundingMode)

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

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

  1. julia> rem2pi(7pi/4, RoundNearest)
  2. -0.7853981633974485
  3. julia> rem2pi(7pi/4, RoundDown)
  4. 5.497787143782138

source

Base.Math.mod2pi — Function

  1. mod2pi(x)

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

This function computes a floating point representation of the modulus after division by numerically exact , 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 .

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

  1. julia> mod2pi(9*pi/4)
  2. 0.7853981633974481

source

Base.divrem — Function

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

Examples

  1. julia> divrem(3,7)
  2. (0, 3)
  3. julia> divrem(7,3)
  4. (2, 1)

source

Base.fldmod — Function

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

source

Base.fld1 — Function

  1. fld1(x, y)

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

See also: mod1, fldmod1.

Examples

  1. julia> x = 15; y = 4;
  2. julia> fld1(x, y)
  3. 4
  4. julia> x == fld(x, y) * y + mod(x, y)
  5. true
  6. julia> x == (fld1(x, y) - 1) * y + mod1(x, y)
  7. true

source

Base.mod1 — Function

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

See also: fld1, fldmod1.

Examples

  1. julia> mod1(4, 2)
  2. 2
  3. julia> mod1(4, 3)
  4. 1

source

Base.fldmod1 — Function

  1. fldmod1(x, y)

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

See also: fld1, mod1.

source

Base.:// — Function

  1. //(num, den)

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

Examples

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

source

Base.rationalize — Function

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

  1. julia> rationalize(5.6)
  2. 28//5
  3. julia> a = rationalize(BigInt, 10.3)
  4. 103//10
  5. julia> typeof(numerator(a))
  6. BigInt

source

Base.numerator — Function

  1. numerator(x)

Numerator of the rational representation of x.

Examples

  1. julia> numerator(2//3)
  2. 2
  3. julia> numerator(4)
  4. 4

source

Base.denominator — Function

  1. denominator(x)

Denominator of the rational representation of x.

Examples

  1. julia> denominator(2//3)
  2. 3
  3. julia> denominator(4)
  4. 1

source

Base.:<< — Function

  1. <<(x, n)

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

Examples

  1. julia> Int8(3) << 2
  2. 12
  3. julia> bitstring(Int8(3))
  4. "00000011"
  5. julia> bitstring(Int8(12))
  6. "00001100"

See also >>, >>>.

source

  1. <<(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

  1. julia> B = BitVector([true, false, true, false, false])
  2. 5-element BitVector:
  3. 1
  4. 0
  5. 1
  6. 0
  7. 0
  8. julia> B << 1
  9. 5-element BitVector:
  10. 0
  11. 1
  12. 0
  13. 0
  14. 0
  15. julia> B << -1
  16. 5-element BitVector:
  17. 0
  18. 1
  19. 0
  20. 1
  21. 0

source

Base.:>> — Function

  1. >>(x, n)

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

Examples

  1. julia> Int8(13) >> 2
  2. 3
  3. julia> bitstring(Int8(13))
  4. "00001101"
  5. julia> bitstring(Int8(3))
  6. "00000011"
  7. julia> Int8(-14) >> 2
  8. -4
  9. julia> bitstring(Int8(-14))
  10. "11110010"
  11. julia> bitstring(Int8(-4))
  12. "11111100"

See also >>>, <<.

source

  1. >>(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

  1. julia> B = BitVector([true, false, true, false, false])
  2. 5-element BitVector:
  3. 1
  4. 0
  5. 1
  6. 0
  7. 0
  8. julia> B >> 1
  9. 5-element BitVector:
  10. 0
  11. 1
  12. 0
  13. 1
  14. 0
  15. julia> B >> -1
  16. 5-element BitVector:
  17. 0
  18. 1
  19. 0
  20. 0
  21. 0

source

Base.:>>> — Function

  1. >>>(x, n)

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

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

Examples

  1. julia> Int8(-14) >>> 2
  2. 60
  3. julia> bitstring(Int8(-14))
  4. "11110010"
  5. julia> bitstring(Int8(60))
  6. "00111100"

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

See also >>, <<.

source

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

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

source

Base.bitrotate — Function

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

  1. julia> bitrotate(UInt8(114), 2)
  2. 0xc9
  3. julia> bitstring(bitrotate(0b01110010, 2))
  4. "11001001"
  5. julia> bitstring(bitrotate(0b01110010, -2))
  6. "10011100"
  7. julia> bitstring(bitrotate(0b01110010, 8))
  8. "01110010"

source

Base.:: — Function

  1. (:)(start, [step], stop)

Range operator. a:b constructs a range from a to b with a step size of 1 (a UnitRange) , and a:s:b is similar but uses a step size of s (a StepRange).

: is also used in indexing to select whole dimensions and for Symbol literals, as in e.g. :hello.

source

  1. (:)(start::CartesianIndex, [step::CartesianIndex], stop::CartesianIndex)

Construct CartesianIndices from two CartesianIndex and an optional step.

Julia 1.1

This method requires at least Julia 1.1.

Julia 1.6

The step range method start:step:stop requires at least Julia 1.6.

Examples

  1. julia> I = CartesianIndex(2,1);
  2. julia> J = CartesianIndex(3,3);
  3. julia> I:J
  4. 2×3 CartesianIndices{2, Tuple{UnitRange{Int64}, UnitRange{Int64}}}:
  5. CartesianIndex(2, 1) CartesianIndex(2, 2) CartesianIndex(2, 3)
  6. CartesianIndex(3, 1) CartesianIndex(3, 2) CartesianIndex(3, 3)
  7. julia> I:CartesianIndex(1, 2):J
  8. 2×2 CartesianIndices{2, Tuple{StepRange{Int64, Int64}, StepRange{Int64, Int64}}}:
  9. CartesianIndex(2, 1) CartesianIndex(2, 3)
  10. CartesianIndex(3, 1) CartesianIndex(3, 3)

source

Base.range — Function

  1. range(start[, stop]; length, stop, step=1)

Given a starting value, construct a range either by length or from start to stop, optionally with a given step (defaults to 1, a UnitRange). One of length or stop is required. If length, stop, and step are all specified, they must agree.

If length and stop are provided and step is not, the step size will be computed automatically such that there are length linearly spaced elements in the range.

If step and stop are provided and length is not, the overall range length will be computed automatically such that the elements are step spaced.

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

stop may be specified as either a positional or keyword argument.

Julia 1.1

stop as a positional argument requires at least Julia 1.1.

Examples

  1. julia> range(1, length=100)
  2. 1:100
  3. julia> range(1, stop=100)
  4. 1:100
  5. julia> range(1, step=5, length=100)
  6. 1:5:496
  7. julia> range(1, step=5, stop=100)
  8. 1:5:96
  9. julia> range(1, 10, length=101)
  10. 1.0:0.09:10.0
  11. julia> range(1, 100, step=5)
  12. 1:5:96

source

Base.OneTo — Type

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

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

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

source

Base.:== — Function

  1. ==(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. For collections, == is generally called recursively on all contents, though other properties (like the shape for arrays) may also be taken into account.

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). For collections, missing is returned if at least one of the operands contains a missing value and all non-missing values 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.

isequal falls back to ==, so new methods of == will be used by the Dict type to compare keys. If your type will be used as a dictionary key, it should therefore also implement hash.

source

Base.:!= — Function

  1. !=(x, y)
  2. ≠(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

  1. julia> 3 != 2
  2. true
  3. julia> "foo" "foo"
  4. false

source

  1. !=(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

Base.:!== — Function

  1. !==(x, y)
  2. ≢(x,y)

Always gives the opposite answer as \===.

Examples

  1. julia> a = [1, 2]; b = [1, 2];
  2. julia> a b
  3. true
  4. julia> a a
  5. false

source

Base.:< — Function

  1. <(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 numeric 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. (x < y) | (x == y)

Examples

  1. julia> 'a' < 'b'
  2. true
  3. julia> "abc" < "abd"
  4. true
  5. julia> 5 < 3
  6. false

source

  1. <(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

Base.:<= — Function

  1. <=(x, y)
  2. ≤(x,y)

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

Examples

  1. julia> 'a' <= 'b'
  2. true
  3. julia> 7 7 9
  4. true
  5. julia> "abc" "abc"
  6. true
  7. julia> 5 <= 3
  8. false

source

  1. <=(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

Base.:> — Function

  1. >(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

  1. julia> 'a' > 'b'
  2. false
  3. julia> 7 > 3 > 1
  4. true
  5. julia> "abc" > "abd"
  6. false
  7. julia> 5 > 3
  8. true

source

  1. >(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

Base.:>= — Function

  1. >=(x, y)
  2. ≥(x,y)

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

Examples

  1. julia> 'a' >= 'b'
  2. false
  3. julia> 7 7 3
  4. true
  5. julia> "abc" "abc"
  6. true
  7. julia> 5 >= 3
  8. true

source

  1. >=(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

Base.cmp — Function

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

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

source

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

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

  1. julia> cmp("abc", "abc")
  2. 0
  3. julia> cmp("ab", "abc")
  4. -1
  5. julia> cmp("abc", "ab")
  6. 1
  7. julia> cmp("ab", "ac")
  8. -1
  9. julia> cmp("ac", "ab")
  10. 1
  11. julia> cmp("α", "a")
  12. 1
  13. julia> cmp("b", "β")
  14. -1

source

Base.:~ — Function

  1. ~(x)

Bitwise not.

Examples

  1. julia> ~4
  2. -5
  3. julia> ~10
  4. -11
  5. julia> ~true
  6. false

source

Base.:& — Function

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

Examples

  1. julia> 4 & 10
  2. 0
  3. julia> 4 & 12
  4. 4
  5. julia> true & missing
  6. missing
  7. julia> false & missing
  8. false

source

Base.:| — Function

  1. x | y

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

Examples

  1. julia> 4 | 10
  2. 14
  3. julia> 4 | 1
  4. 5
  5. julia> true | missing
  6. true
  7. julia> false | missing
  8. missing

source

Base.xor — Function

  1. xor(x, y)
  2. ⊻(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

  1. julia> xor(true, false)
  2. true
  3. julia> xor(true, true)
  4. false
  5. julia> xor(true, missing)
  6. missing
  7. julia> false false
  8. false
  9. julia> [true; true; false] .⊻ [true; false; false]
  10. 3-element BitVector:
  11. 0
  12. 1
  13. 0

source

Base.:! — Function

  1. !(x)

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

Examples

  1. julia> !true
  2. false
  3. julia> !false
  4. true
  5. julia> !missing
  6. missing
  7. julia> .![true false true]
  8. 1×3 BitMatrix:
  9. 0 1 0

source

  1. !f::Function

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

Examples

  1. julia> str = "∀ ε > 0, ∃ δ > 0: |x-y| < δ ⇒ |f(x)-f(y)| < ε"
  2. "∀ ε > 0, ∃ δ > 0: |x-y| < δ ⇒ |f(x)-f(y)| < ε"
  3. julia> filter(isletter, str)
  4. "εδxyδfxfyε"
  5. julia> filter(!isletter, str)
  6. "∀ > 0, ∃ > 0: |-| < ⇒ |()-()| < "

source

&& — Keyword

  1. x && y

Short-circuiting boolean AND.

source

|| — Keyword

  1. x || y

Short-circuiting boolean OR.

source

Mathematical Functions

Base.isapprox — Function

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

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

For real or complex floating-point values, 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 significand 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

  1. julia> 0.1 (0.1 - 1e-10)
  2. true
  3. julia> isapprox(10, 11; atol = 2)
  4. true
  5. julia> isapprox([10.0^9, 1.0], [10.0^9, 2.0])
  6. true
  7. julia> 1e-10 0
  8. false
  9. julia> isapprox(1e-10, 0, atol=1e-8)
  10. true

source

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

source

Base.sin — Method

  1. sin(x)

Compute sine of x, where x is in radians.

source

Base.cos — Method

  1. cos(x)

Compute cosine of x, where x is in radians.

source

Base.Math.sincos — Method

  1. sincos(x)

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

source

Base.tan — Method

  1. tan(x)

Compute tangent of x, where x is in radians.

source

Base.Math.sind — Function

  1. sind(x)

Compute sine of x, where x is in degrees.

source

Base.Math.cosd — Function

  1. cosd(x)

Compute cosine of x, where x is in degrees.

source

Base.Math.tand — Function

  1. tand(x)

Compute tangent of x, where x is in degrees.

source

Base.Math.sinpi — Function

  1. sinpi(x)

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

source

Base.Math.cospi — Function

  1. cospi(x)

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

source

Base.Math.sincospi — Function

  1. sincospi(x)

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

Julia 1.6

This function requires Julia 1.6 or later.

source

Base.sinh — Method

  1. sinh(x)

Compute hyperbolic sine of x.

source

Base.cosh — Method

  1. cosh(x)

Compute hyperbolic cosine of x.

source

Base.tanh — Method

  1. tanh(x)

Compute hyperbolic tangent of x.

source

Base.asin — Method

  1. asin(x)

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

source

Base.acos — Method

  1. acos(x)

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

source

Base.atan — Method

  1. atan(y)
  2. atan(y, x)

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

For one 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.

source

Base.Math.asind — Function

  1. asind(x)

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

source

Base.Math.acosd — Function

  1. acosd(x)

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

source

Base.Math.atand — Function

  1. atand(y)
  2. atand(y,x)

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

source

Base.Math.sec — Method

  1. sec(x)

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

source

Base.Math.csc — Method

  1. csc(x)

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

source

Base.Math.cot — Method

  1. cot(x)

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

source

Base.Math.secd — Function

  1. secd(x)

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

source

Base.Math.cscd — Function

  1. cscd(x)

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

source

Base.Math.cotd — Function

  1. cotd(x)

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

source

Base.Math.asec — Method

  1. asec(x)

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

source

Base.Math.acsc — Method

  1. acsc(x)

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

source

Base.Math.acot — Method

  1. acot(x)

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

source

Base.Math.asecd — Function

  1. asecd(x)

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

source

Base.Math.acscd — Function

  1. acscd(x)

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

source

Base.Math.acotd — Function

  1. acotd(x)

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

source

Base.Math.sech — Method

  1. sech(x)

Compute the hyperbolic secant of x.

source

Base.Math.csch — Method

  1. csch(x)

Compute the hyperbolic cosecant of x.

source

Base.Math.coth — Method

  1. coth(x)

Compute the hyperbolic cotangent of x.

source

Base.asinh — Method

  1. asinh(x)

Compute the inverse hyperbolic sine of x.

source

Base.acosh — Method

  1. acosh(x)

Compute the inverse hyperbolic cosine of x.

source

Base.atanh — Method

  1. atanh(x)

Compute the inverse hyperbolic tangent of x.

source

Base.Math.asech — Method

  1. asech(x)

Compute the inverse hyperbolic secant of x.

source

Base.Math.acsch — Method

  1. acsch(x)

Compute the inverse hyperbolic cosecant of x.

source

Base.Math.acoth — Method

  1. acoth(x)

Compute the inverse hyperbolic cotangent of x.

source

Base.Math.sinc — Function

  1. sinc(x)

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

source

Base.Math.cosc — Function

  1. cosc(x)

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

source

Base.Math.deg2rad — Function

  1. deg2rad(x)

Convert x from degrees to radians.

Examples

  1. julia> deg2rad(90)
  2. 1.5707963267948966

source

Base.Math.rad2deg — Function

  1. rad2deg(x)

Convert x from radians to degrees.

Examples

  1. julia> rad2deg(pi)
  2. 180.0

source

Base.Math.hypot — Function

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

  1. hypot(x...)

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

Examples

  1. julia> a = Int64(10)^10;
  2. julia> hypot(a, a)
  3. 1.4142135623730951e10
  4. julia> √(a^2 + a^2) # a^2 overflows
  5. ERROR: DomainError with -2.914184810805068e18:
  6. sqrt will only return a complex result if called with a complex argument. Try sqrt(Complex(x)).
  7. Stacktrace:
  8. [...]
  9. julia> hypot(3, 4im)
  10. 5.0
  11. julia> hypot(-5.7)
  12. 5.7
  13. julia> hypot(3, 4im, 12.0)
  14. 13.0

source

Base.log — Method

  1. log(x)

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

Examples

  1. julia> log(2)
  2. 0.6931471805599453
  3. julia> log(-3)
  4. ERROR: DomainError with -3.0:
  5. log will only return a complex result if called with a complex argument. Try log(Complex(x)).
  6. Stacktrace:
  7. [1] throw_complex_domainerror(::Symbol, ::Float64) at ./math.jl:31
  8. [...]

source

Base.log — Method

  1. log(b,x)

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

Examples

  1. julia> log(4,8)
  2. 1.5
  3. julia> log(4,2)
  4. 0.5
  5. julia> log(-2, 3)
  6. ERROR: DomainError with -2.0:
  7. log will only return a complex result if called with a complex argument. Try log(Complex(x)).
  8. Stacktrace:
  9. [1] throw_complex_domainerror(::Symbol, ::Float64) at ./math.jl:31
  10. [...]
  11. julia> log(2, -3)
  12. ERROR: DomainError with -3.0:
  13. log will only return a complex result if called with a complex argument. Try log(Complex(x)).
  14. Stacktrace:
  15. [1] throw_complex_domainerror(::Symbol, ::Float64) at ./math.jl:31
  16. [...]

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,

  1. julia> log(100,1000000)
  2. 2.9999999999999996
  3. julia> log10(1000000)/2
  4. 3.0

source

Base.log2 — Function

  1. log2(x)

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

Examples

  1. julia> log2(4)
  2. 2.0
  3. julia> log2(10)
  4. 3.321928094887362
  5. julia> log2(-2)
  6. ERROR: DomainError with -2.0:
  7. NaN result for non-NaN input.
  8. Stacktrace:
  9. [1] nan_dom_err at ./math.jl:325 [inlined]
  10. [...]

source

Base.log10 — Function

  1. log10(x)

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

Examples

  1. julia> log10(100)
  2. 2.0
  3. julia> log10(2)
  4. 0.3010299956639812
  5. julia> log10(-2)
  6. ERROR: DomainError with -2.0:
  7. NaN result for non-NaN input.
  8. Stacktrace:
  9. [1] nan_dom_err at ./math.jl:325 [inlined]
  10. [...]

source

Base.log1p — Function

  1. log1p(x)

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

Examples

  1. julia> log1p(-0.5)
  2. -0.6931471805599453
  3. julia> log1p(0)
  4. 0.0
  5. julia> log1p(-2)
  6. ERROR: DomainError with -2.0:
  7. log1p will only return a complex result if called with a complex argument. Try log1p(Complex(x)).
  8. Stacktrace:
  9. [1] throw_complex_domainerror(::Symbol, ::Float64) at ./math.jl:31
  10. [...]

source

Base.Math.frexp — Function

  1. frexp(val)

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

source

Base.exp — Method

  1. exp(x)

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

Examples

  1. julia> exp(1.0)
  2. 2.718281828459045

source

Base.exp2 — Function

  1. exp2(x)

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

Examples

  1. julia> exp2(5)
  2. 32.0

source

Base.exp10 — Function

  1. exp10(x)

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

Examples

  1. julia> exp10(2)
  2. 100.0

source

Base.Math.ldexp — Function

  1. ldexp(x, n)

Compute $x \times 2^n$.

Examples

  1. julia> ldexp(5., 2)
  2. 20.0

source

Base.Math.modf — Function

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

  1. julia> modf(3.5)
  2. (0.5, 3.0)
  3. julia> modf(-3.5)
  4. (-0.5, -3.0)

source

Base.expm1 — Function

  1. expm1(x)

Accurately compute $e^x-1$.

source

Base.round — Method

  1. round([T,] x, [r::RoundingMode])
  2. round(x, [r::RoundingMode]; digits::Integer=0, base = 10)
  3. 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).

Examples

  1. julia> round(1.7)
  2. 2.0
  3. julia> round(Int, 1.7)
  4. 2
  5. julia> round(1.5)
  6. 2.0
  7. julia> round(2.5)
  8. 2.0
  9. julia> round(pi; digits=2)
  10. 3.14
  11. julia> round(pi; digits=3, base=2)
  12. 3.125
  13. julia> round(123.456; sigdigits=2)
  14. 120.0
  15. julia> round(357.913; sigdigits=4, base=2)
  16. 352.0

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.

Examples

  1. julia> x = 1.15
  2. 1.15
  3. julia> @sprintf "%.20f" x
  4. "1.14999999999999991118"
  5. julia> x < 115//100
  6. true
  7. julia> round(x, digits=1)
  8. 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

  1. 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:

source

Base.Rounding.RoundNearest — Constant

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

  1. RoundNearestTiesAway

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

source

Base.Rounding.RoundNearestTiesUp — Constant

  1. RoundNearestTiesUp

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

source

Base.Rounding.RoundToZero — Constant

  1. RoundToZero

round using this rounding mode is an alias for trunc.

source

Base.Rounding.RoundFromZero — Constant

  1. RoundFromZero

Rounds away from zero. This rounding mode may only be used with T == BigFloat inputs to round.

Examples

  1. julia> BigFloat("1.0000000000000001", 5, RoundFromZero)
  2. 1.06

source

Base.Rounding.RoundUp — Constant

  1. RoundUp

round using this rounding mode is an alias for ceil.

source

Base.Rounding.RoundDown — Constant

  1. RoundDown

round using this rounding mode is an alias for floor.

source

Base.round — Method

  1. round(z::Complex[, RoundingModeReal, [RoundingModeImaginary]])
  2. round(z::Complex[, RoundingModeReal, [RoundingModeImaginary]]; digits=, base=10)
  3. 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 RoundingModes. The first RoundingMode is used for rounding the real components while the second is used for rounding the imaginary components.

Example

  1. julia> round(3.14 + 4.5im)
  2. 3.0 + 4.0im

source

Base.ceil — Function

  1. ceil([T,] x)
  2. ceil(x; digits::Integer= [, base = 10])
  3. 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 value is not representable.

digits, sigdigits and base work as for round.

source

Base.floor — Function

  1. floor([T,] x)
  2. floor(x; digits::Integer= [, base = 10])
  3. 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 value is not representable.

digits, sigdigits and base work as for round.

source

Base.trunc — Function

  1. trunc([T,] x)
  2. trunc(x; digits::Integer= [, base = 10])
  3. 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 x.

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

digits, sigdigits and base work as for round.

source

Base.unsafe_trunc — Function

  1. unsafe_trunc(T, x)

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

source

Base.min — Function

  1. min(x, y, ...)

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

Examples

  1. julia> min(2, 5, 1)
  2. 1

source

Base.max — Function

  1. max(x, y, ...)

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

Examples

  1. julia> max(2, 5, 1)
  2. 5

source

Base.minmax — Function

  1. minmax(x, y)

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

Examples

  1. julia> minmax('c','b')
  2. ('b', 'c')

source

Base.Math.clamp — Function

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

Examples

  1. julia> clamp.([pi, 1.0, big(10.)], 2., 9.)
  2. 3-element Vector{BigFloat}:
  3. 3.141592653589793238462643383279502884197169399375105820974944592307816406286198
  4. 2.0
  5. 9.0
  6. julia> clamp.([11,8,5],10,6) # an example where lo > hi
  7. 3-element Vector{Int64}:
  8. 6
  9. 6
  10. 10

source

  1. clamp(x, T)::T

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

Examples

  1. julia> clamp(200, Int8)
  2. 127
  3. julia> clamp(-200, Int8)
  4. -128

source

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

Clamp x to lie within range r.

Julia 1.6

This method requires at least Julia 1.6.

source

Base.Math.clamp! — Function

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

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

source

Base.abs — Function

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

Examples

  1. julia> abs(-3)
  2. 3
  3. julia> abs(1 + im)
  4. 1.4142135623730951
  5. julia> abs(typemin(Int64))
  6. -9223372036854775808

source

Base.Checked.checked_abs — Function

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

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

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

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

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

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

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

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

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

  1. 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.add_with_overflow — Function

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

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

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

  1. abs2(x)

Squared absolute value of x.

Examples

  1. julia> abs2(-3)
  2. 9

source

Base.copysign — Function

  1. copysign(x, y) -> z

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

Examples

  1. julia> copysign(1, -2)
  2. -1
  3. julia> copysign(-1, 2)
  4. 1

source

Base.sign — Function

  1. sign(x)

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

source

Base.signbit — Function

  1. signbit(x)

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

Examples

  1. julia> signbit(-4)
  2. true
  3. julia> signbit(5)
  4. false
  5. julia> signbit(5.5)
  6. false
  7. julia> signbit(-4.1)
  8. true

source

Base.flipsign — Function

  1. flipsign(x, y)

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

Examples

  1. julia> flipsign(5, 3)
  2. 5
  3. julia> flipsign(5, -3)
  4. -5

source

Base.sqrt — Method

  1. sqrt(x)

Return $\sqrt{x}$. Throws DomainError for negative Real arguments. Use complex negative arguments instead. The prefix operator is equivalent to sqrt.

Examples

  1. julia> sqrt(big(81))
  2. 9.0
  3. julia> sqrt(big(-81))
  4. ERROR: DomainError with -81.0:
  5. NaN result for non-NaN input.
  6. Stacktrace:
  7. [1] sqrt(::BigFloat) at ./mpfr.jl:501
  8. [...]
  9. julia> sqrt(big(complex(-81)))
  10. 0.0 + 9.0im

source

Base.isqrt — Function

  1. isqrt(n::Integer)

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

  1. julia> isqrt(5)
  2. 2

source

Base.Math.cbrt — Function

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

  1. julia> cbrt(big(27))
  2. 3.0
  3. julia> cbrt(big(-27))
  4. -3.0

source

Base.real — Method

  1. real(z)

Return the real part of the complex number z.

Examples

  1. julia> real(1 + 3im)
  2. 1

source

Base.imag — Function

  1. imag(z)

Return the imaginary part of the complex number z.

Examples

  1. julia> imag(1 + 3im)
  2. 3

source

Base.reim — Function

  1. reim(z)

Return both the real and imaginary parts of the complex number z.

Examples

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

source

Base.conj — Function

  1. conj(z)

Compute the complex conjugate of a complex number z.

Examples

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

source

Base.angle — Function

  1. angle(z)

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

Examples

  1. julia> rad2deg(angle(1 + im))
  2. 45.0
  3. julia> rad2deg(angle(1 - im))
  4. -45.0
  5. julia> rad2deg(angle(-1 - im))
  6. -135.0

source

Base.cis — Function

  1. cis(z)

Return $\exp(iz)$.

Examples

  1. julia> cis(π) -1
  2. true

source

Base.cispi — Function

  1. cispi(z)

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

Examples

  1. julia> cispi(1)
  2. -1.0 + 0.0im
  3. julia> cispi(0.25 + 1im)
  4. 0.030556854645952924 + 0.030556854645952924im

Julia 1.6

This function requires Julia 1.6 or later.

source

Base.binomial — Function

  1. 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}\]

Examples

  1. julia> binomial(5, 3)
  2. 10
  3. julia> factorial(5) ÷ (factorial(5-3) * factorial(3))
  4. 10
  5. julia> binomial(-5, 3)
  6. -35

See also

External links

source

Base.factorial — Function

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

Examples

  1. julia> factorial(6)
  2. 720
  3. julia> factorial(21)
  4. ERROR: OverflowError: 21 is too large to look up in the table; consider using `factorial(big(21))` instead
  5. Stacktrace:
  6. [...]
  7. julia> factorial(big(21))
  8. 51090942171709440000

See also

External links

source

Base.gcd — Function

  1. gcd(x, y...)

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

Julia 1.4

Rational arguments require Julia 1.4 or later.

Examples

  1. julia> gcd(6,9)
  2. 3
  3. julia> gcd(6,-9)
  4. 3
  5. julia> gcd(6,0)
  6. 6
  7. julia> gcd(0,0)
  8. 0
  9. julia> gcd(1//3,2//3)
  10. 1//3
  11. julia> gcd(1//3,-2//3)
  12. 1//3
  13. julia> gcd(1//3,2)
  14. 1//3
  15. julia> gcd(0, 0, 10, 15)
  16. 5

source

Base.lcm — Function

  1. lcm(x, y...)

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

Julia 1.4

Rational arguments require Julia 1.4 or later.

Examples

  1. julia> lcm(2,3)
  2. 6
  3. julia> lcm(-2,3)
  4. 6
  5. julia> lcm(0,3)
  6. 0
  7. julia> lcm(0,0)
  8. 0
  9. julia> lcm(1//3,2//3)
  10. 2//3
  11. julia> lcm(1//3,-2//3)
  12. 2//3
  13. julia> lcm(1//3,2)
  14. 2//1
  15. julia> lcm(1,3,5,7)
  16. 105

source

Base.gcdx — Function

  1. 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 $ua+vb = d = gcd(a, b)$. $gcdx(a, b)$ returns $(d, u, v)$.

The arguments may be integer and rational numbers.

Julia 1.4

Rational arguments require Julia 1.4 or later.

Examples

  1. julia> gcdx(12, 42)
  2. (6, -3, 1)
  3. julia> gcdx(240, 46)
  4. (2, -9, 47)

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| < |y/d|$ and $|v| < |x/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

  1. ispow2(n::Number) -> Bool

Test whether n is an integer power of two.

Examples

  1. julia> ispow2(4)
  2. true
  3. julia> ispow2(5)
  4. false
  5. julia> ispow2(4.5)
  6. false
  7. julia> ispow2(0.25)
  8. true
  9. julia> ispow2(1//8)
  10. true

Julia 1.6

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

source

Base.nextpow — Function

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

Examples

  1. julia> nextpow(2, 7)
  2. 8
  3. julia> nextpow(2, 9)
  4. 16
  5. julia> nextpow(5, 20)
  6. 25
  7. julia> nextpow(4, 16)
  8. 16

See also prevpow.

source

Base.prevpow — Function

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

Examples

  1. julia> prevpow(2, 7)
  2. 4
  3. julia> prevpow(2, 9)
  4. 8
  5. julia> prevpow(5, 20)
  6. 5
  7. julia> prevpow(4, 16)
  8. 16

See also nextpow.

source

Base.nextprod — Function

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

  1. julia> nextprod((2, 3), 105)
  2. 108
  3. julia> 2^2 * 3^3
  4. 108

Julia 1.6

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

source

Base.invmod — Function

  1. invmod(n, m)

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

  1. julia> invmod(2,5)
  2. 3
  3. julia> invmod(2,3)
  4. 2
  5. julia> invmod(5,6)
  6. 5

source

Base.powermod — Function

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

Compute $x^p \pmod m$.

Examples

  1. julia> powermod(2, 6, 5)
  2. 4
  3. julia> mod(2^6, 5)
  4. 4
  5. julia> powermod(5, 2, 20)
  6. 5
  7. julia> powermod(5, 2, 19)
  8. 6
  9. julia> powermod(5, 3, 19)
  10. 11

source

Base.ndigits — Function

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

Examples

  1. julia> ndigits(12345)
  2. 5
  3. julia> ndigits(1022, base=16)
  4. 3
  5. julia> string(1022, base=16)
  6. "3fe"
  7. julia> ndigits(123, pad=5)
  8. 5

source

Base.widemul — Function

  1. widemul(x, y)

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

Examples

  1. julia> widemul(Float32(3.), 4.)
  2. 12.0

source

Base.Math.evalpoly — Function

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

Example

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

source

Base.Math.@evalpoly — Macro

  1. @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.

Examples

  1. julia> @evalpoly(3, 1, 0, 1)
  2. 10
  3. julia> @evalpoly(2, 1, 0, 1)
  4. 5
  5. julia> @evalpoly(2, 1, 1, 1)
  6. 7

source

Base.FastMath.@fastmath — Macro

  1. @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

  1. julia> @fastmath 1+2
  2. 3
  3. julia> @fastmath(sin(3))
  4. 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.