Mathematics
- Mathematical Operators
- Mathematical Functions

Mathematics

Mathematical Operators

1. -(x)

Unary minus operator.

Examples

1. julia> -1
2. -1

4. julia> -(2)
5. -2

7. julia> -[1 2; 3 4]
8. 2×2 Array{Int64,2}:
9. -1  -2
10. -3  -4

source

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

4. julia> +(1, 20, 4)
5. 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

1. -(x, y)

Subtraction operator.

Examples

1. julia> 2 - 3
2. -1

4. julia> -(2, 4.5)
5. -2.5

source

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

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

source

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

4. julia> 4/2
5. 2.0

7. julia> 4.5/2
8. 2.25

source

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

4. julia> inv(3) * 6
5. 2.0

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

9. julia> A \ x
10. 2-element Array{Float64,1}:
11. 6.5
12. -7.0

14. julia> inv(A) * x
15. 2-element Array{Float64,1}:
16. 6.5
17. -7.0

source

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

1. julia> 3^5
2. 243

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

9. julia> A^3
10. 2×2 Array{Int64,2}:
11. 37   54
12. 81  118

source

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

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

4. julia> 3 * 2 + 1
5. 7

source

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

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

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

10. julia> inv(2//3)
11. 3//2

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

source

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

4. julia> -5 ÷ 3
5. -1

7. julia> 5.0 ÷ 2
8. 2.0

source

1. fld(x, y)

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

See also >>, <<.

source

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

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

source

(:)(I::CartesianIndex, J::CartesianIndex)

Construct CartesianIndices from two CartesianIndex.

This method requires at least Julia 1.1.

Examples

julia> I = CartesianIndex(2,1);

julia> J = CartesianIndex(3,3);

julia> I:J
2×3 CartesianIndices{2,Tuple{UnitRange{Int64},UnitRange{Int64}}}:
 CartesianIndex(2, 1)  CartesianIndex(2, 2)  CartesianIndex(2, 3)
 CartesianIndex(3, 1)  CartesianIndex(3, 2)  CartesianIndex(3, 3)

source

(:)(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

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 (a LinRange).

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 (a StepRange).

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

stop as a positional argument requires at least Julia 1.1.

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

source

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

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

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

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

source

==(a::AbstractString, b::AbstractString) -> Bool

Test whether two strings are equal character by character (technically, Unicode code point by code point).

Examples

julia> "abc" == "abc"
true

julia> "abc" == "αβγ"
false

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

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

This functionality requires at least Julia 1.2.

source

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

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

julia> 'a' < 'b'
true

julia> "abc" < "abd"
true

julia> 5 < 3
false

source

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

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

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

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

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

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

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

This functionality requires at least Julia 1.2.

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

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

~(x)

Bitwise not.

Examples

julia> ~4
-5

julia> ~10
-11

julia> ~true
false

source

&(x, y)

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

Examples

julia> 4 & 10
0

julia> 4 & 12
4

julia> true & missing
missing

julia> false & missing
false

source

|(x, y)

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

Examples

julia> 4 | 10
14

julia> 4 | 1
5

julia> true | missing
true

julia> false | missing
missing

source

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 BitArray{1}:
 0
 1
 0

source

!(x)

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

Examples

julia> !true
false

julia> !false
true

julia> !missing
missing

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

source

!f::Function

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

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: |-| <  ⇒ |()-()| < "

source

x && y

Short-circuiting boolean AND.

source

x || y

Short-circuiting boolean OR.

source

Mathematical Functions

isapprox(x, y; rtol::Real=atol>0 ? 0 : √eps, atol::Real=0, 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.

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

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

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.

Examples

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

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

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

julia> 1e-10 ≈ 0
false

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

source

sin(x)

Compute sine of x, where x is in radians.

source

cos(x)

Compute cosine of x, where x is in radians.

source

sincos(x)

Simultaneously compute the sine and cosine of x, where the x is in radians.

source

tan(x)

Compute tangent of x, where x is in radians.

source

sind(x)

Compute sine of x, where x is in degrees.

source

cosd(x)

Compute cosine of x, where x is in degrees.

source

tand(x)

Compute tangent of x, where x is in degrees.

source

sinpi(x)

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

source

cospi(x)

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

source

sinh(x)

Compute hyperbolic sine of x.

source

cosh(x)

Compute hyperbolic cosine of x.

source

tanh(x)

Compute hyperbolic tangent of x.

source

asin(x)

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

source

acos(x)

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

source

atan(y)
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.

source

asind(x)

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

source

acosd(x)

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

source

atand(y)
atand(y,x)

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

source

sec(x)

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

source

csc(x)

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

source

cot(x)

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

source

secd(x)

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

source

cscd(x)

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

source

cotd(x)

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

source

asec(x)

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

source

acsc(x)

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

source

acot(x)

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

source

asecd(x)

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

source

acscd(x)

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

source

acotd(x)

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

source

sech(x)

Compute the hyperbolic secant of x.

source

csch(x)

Compute the hyperbolic cosecant of x.

source

coth(x)

Compute the hyperbolic cotangent of x.

source

asinh(x)

Compute the inverse hyperbolic sine of x.

source

acosh(x)

Compute the inverse hyperbolic cosine of x.

source

atanh(x)

Compute the inverse hyperbolic tangent of x.

source

asech(x)

Compute the inverse hyperbolic secant of x.

source

acsch(x)

Compute the inverse hyperbolic cosecant of x.

source

acoth(x)

Compute the inverse hyperbolic cotangent of x.

source

sinc(x)

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

source

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

deg2rad(x)

Convert x from degrees to radians.

Examples

julia> deg2rad(90)
1.5707963267948966

source

rad2deg(x)

Convert x from radians to degrees.

Examples

julia> rad2deg(pi)
180.0

source

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>

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 will only return a complex result if called with a complex argument. Try s

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