Mathematics
- Mathematical Operators
- Mathematical Functions

Mathematics

Mathematical Operators

Base.:- — Method

1. -(x)

Unary minus operator.

See also: <<, circshift, BitArray.

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

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

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

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

source

Base.:: — Function

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

3. julia> J = CartesianIndex(3,3);

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

10. julia> I:CartesianIndex(1, 2):J
11. 2×2 CartesianIndices{2, Tuple{StepRange{Int64, Int64}, StepRange{Int64, Int64}}}:
12. CartesianIndex(2, 1)  CartesianIndex(2, 3)
13. CartesianIndex(3, 1)  CartesianIndex(3, 3)

source

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

Base.range — Function

1. range(start, stop, length)
2. range(start, stop; length, step)
3. range(start; length, stop, step)
4. 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 one. If both arguments are Integers, a UnitRange will be returned.

Examples

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

4. julia> range(1, stop=100)
5. 1:100

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

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

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

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

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

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

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

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

1. julia> range(1, 3.5, step=2)
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.

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

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

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

4. julia> "foo" ≠ "foo"
5. 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];

3. julia> a ≢ b
4. true

6. julia> a ≢ a
7. 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.

Examples

1. julia> 'a' < 'b'
2. true

4. julia> "abc" < "abd"
5. 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)
2. ≤(x,y)

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

Examples

1. julia> 'a' <= 'b'
2. true

4. julia> 7 ≤ 7 ≤ 9
5. true

7. julia> "abc" ≤ "abc"
8. true

10. julia> 5 <= 3
11. 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

4. julia> 7 > 3 > 1
5. true

7. julia> "abc" > "abd"
8. false

10. julia> 5 > 3
11. 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

4. julia> 7 ≥ 7 ≥ 3
5. true

7. julia> "abc" ≥ "abc"
8. true

10. julia> 5 >= 3
11. 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

4. julia> cmp(2, 1)
5. 1

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

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

4. julia> cmp("ab", "abc")
5. -1

7. julia> cmp("abc", "ab")
8. 1

10. julia> cmp("ab", "ac")
11. -1

13. julia> cmp("ac", "ab")
14. 1

16. julia> cmp("α", "a")
17. 1

19. julia> cmp("b", "β")
20. -1

source

Base.:~ — Function

1. ~(x)

Bitwise not.

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. 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 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> isapprox(0.1, 0.15; atol=0.05)
2. true

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

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

10. julia> 0.1 + 1e-10 ≈ 0.1
11. true

13. julia> 1e-10 ≈ 0
14. false

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

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

source

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

Create a function that compares its argu

（本文超出站点单文档体积上限，已截断）