Mathematical operations and elementary functions

The following are supported for all primitive numeric types https://en.wikipedia.org/wiki/Arithmetic#Arithmetic_operations [arithmetic operators].

Putting a numeric literal directly in front of an identifier or parentheses, such as 2x or 2(x + y), is considered a multiplication, and with a higher priority than other binary operations. For more information: see Numeric literal coefficients.

Thanks to the Julia promotion system, arithmetic operations on combinations of different types of arguments are performed automatically, naturally, and intuitively. For more information about this system, see Transformation and promotion.

You can use \div<tab> in the REPL or the Julia IDE to conveniently enter the sign. For more information: see section of the guide on entering Unicode characters.

Here are some simple examples of using arithmetic operators.

(By convention, operators executed earlier than other nearby operators are separated by a shorter distance. For example, writing -x + 2 usually means that x is accessed first, and then 2 is added to the result.)

When used in multiplication, the value `false' acts as a _ strong zero_.

This prevents the substitution of NaN values in obviously zero amounts. The rationale: https://arxiv.org/abs/math/9205211 [Knut (1992)].

For types Bool the following are supported https://en.wikipedia.org/wiki/Boolean_algebra#Operations [logical operators].

Negation changes true to `false', and vice versa. Explanations for the calculation operations according to the abbreviated scheme are available at the links provided.

Note that Bool is an integer type and all the standard promotion rules and numeric operators are defined for it as well.

For all primitive integer types, the following are supported https://en.wikipedia.org/wiki/Bitwise_operation#Bitwise_operators [bitwise operators].

Here are some examples of using bitwise operators.

All binary arithmetic and bitwise operators also have an assignment version that passes the result to the operand on the left. To use the assignment version of the binary operator, you must specify the = sign immediately after the operator. For example, the entry x += 3 is equivalent to `x = x + 3'.

All versions of binary arithmetic and bit assignment operators:

For every binary operation like ^, there is a corresponding "dot" operation .^ that is automatically defined to perform ^ element-by-element on arrays. For example, [1, 2, 3] ^ 3 is not defined, since there is no standard mathematical meaning to "cubing" a (non-square) array, but [1, 2, 3] .^ 3 is defined as computing the elementwise (or "vectorized") result [1^3, 2^3, 3^3]. Similarly for unary operators like ! or √, there is a corresponding .√ that applies the operator elementwise.

For example, a .^ b is analyzed as dot call (^).(a,b), which performs the operation broadcasts. This operation allows you to combine arrays with scalar values, combine arrays of the same size with each other (performed element by element), and even arrays of different shapes (for example, horizontal and vertical vectors, creating a matrix). In addition, like all "dot" calls, dot operators are connecting. For example, when calculating the expression +2 .* A.^2 .+ sin for the array `A.(A)` (or the equivalent expression `@. 2A^2 + sin(A)` with a macro xref:base/arrays.adoc#Base.Broadcast.@__dot__[`@.`]) a single loop is executed with the array `A`, in which `+2a^2 + sin(a)` is calculated for each element a from A. In particular, nested dot calls such as f.(g.(x)) are combined, and adjacent binary operators such as x .+3 .*x.^2 are equivalent to nested dot calls (+).(x, (*).(3, (^).( x, 2))).

In addition, dot operators with assignment, such as a .+= b (or @. a += b), are analyzed as a .= a .+ b, where .= represents the combined operation of assigning _ to a place (see documentation on syntax with a dot).

The dot syntax is also applicable to user-defined operators. For example, if you define ⊗(A, B) = kron(A, B) to use the convenient infix syntax A ⊗ B for the Kronecker product (kron), then [A, B] .⊗ [C, D] will calculate [A⊗C, B⊗D] without the need to write additional code.

When dot operators are combined with numeric literals, ambiguity may occur. For example, what does 1.+x mean? It could be 1. + x or 1 .+ x. Therefore, this syntax is not allowed; in such cases, you need to put spaces around the operator.

Standard comparison operations are defined for all primitive numeric types.

Here are some simple examples.

Integers are compared using the standard bit comparison. Floating point numbers are compared according to https://en.wikipedia.org/wiki/IEEE_754-2008 [IEEE 754 standard]:

The last point may be unexpected, so it makes sense to note the following.

It can also create problems when working with arrays.

Additional functions are available in Julia to check special values of numbers, which can be useful, for example, when comparing a hash key.

isequal evaluates the values of NaN as equals to each other:

'isequal` also allows you to distinguish between signed zeros.

Comparing different types of values when comparing signed, unsigned, and floating-point integers is often difficult. Significant efforts have been made to ensure that they are executed correctly in Julia.

For other types, isequal calls by default ==, so if you want to define equality for your own type, just add a method for it. ==. If you are defining your own equality function, it makes sense to define an appropriate method. hash so that isequal(x,y) implies `hash(x) == hash(y)'.

The Julia language uses the following order and associativity of operators, from the highest priority to the lowest.

For a complete list of priorities for each Julia operator, see at the top of the file: https://github.com/JuliaLang/julia/blob/master/src/julia-parser.scm [src/julia-parser.scm]. Note that some of these operators are not defined in the Base module, but may have definitions in standard libraries, packages, or user code.

You can also find out the numerical priority value of any operator using the built-in function Base.operator_precedence (the higher the number, the higher the priority).

A symbolic representation of operator associativity can also be obtained by calling the built-in function `Base.operator_associativity'.

Please note that characters such as :sin return the priority of `0'. This value represents invalid operators, not operators with the lowest priority. Similarly, such operators are assigned the associativity `:none'.

Numeric literal coefficients, such as 2x', are treated as multiplication performed before any other binary operations. The exception is the exponentiation operation (^`), in which multiplication will be performed first only if it is in the exponent.

Their combination will be analyzed as a unary operator with standard asymmetry during exponentiation: the expressions -x^y and 2x^y are analyzed as -(x^y) and 2(x^y) respectively, whereas x^-y and x^2y are analyzed as x^(-y) and `x^(2y)'.

Julia supports three number type conversion options, which differ in how they handle inaccurate conversions.

The various forms of conversion are shown in the following examples.

In the section Transformation and Promotion describes how you can define your own transformations and promotions.