Julia Language
Aritmética

Sintaxis

• + x
• -X
• a + b
• a - b
• a * b
• a / b
• a ^ b
• a% b
• 4a
• sqrt (a)

Fórmula cuadrática

Julia usa operadores binarios similares para operaciones aritméticas básicas, al igual que las matemáticas u otros lenguajes de programación. La mayoría de los operadores pueden escribirse en notación infija (es decir, colocados entre los valores que se están calculando). Julia tiene un orden de operaciones que coincide con la convención común en matemáticas.

Por ejemplo, el siguiente código implementa la fórmula cuadrática , que demuestra los operadores + , - , * y / para la suma, resta, multiplicación y división, respectivamente. También se muestra la multiplicación implícita , donde un número se puede colocar directamente antes de un símbolo para significar multiplicación; es decir, 4a significa lo mismo que 4*a .

function solvequadratic(a, b, c)
    d = sqrt(b^2 - 4a*c)
    (-b - d) / 2a, (-b + d) / 2a
end

Uso:

julia> solvequadratic(1, -2, -3)
(-1.0,3.0)

Tamiz de Eratóstenes

El operador restante en Julia es el operador % . Este operador se comporta de manera similar al % en idiomas como C y C ++. a % b es el resto firmado después de dividir a por b .

Este operador es muy útil para implementar ciertos algoritmos, como la siguiente implementación del Tamiz de Eratóstenes .

iscoprime(P, i) = !any(x -> i % x == 0, P)

function sieve(n)
    P = Int[]
    for i in 2:n
        if iscoprime(P, i)
            push!(P, i)
        end
    end
    P
end

Uso:

julia> sieve(20)
8-element Array{Int64,1}:
  2
  3
  5
  7
 11
 13
 17
 19

Aritmética matricial

Julia usa los significados matemáticos estándar de las operaciones aritméticas cuando se aplica a matrices. A veces, las operaciones elementales son deseadas en su lugar. Estos están marcados con una parada completa ( . ) Que precede al operador para que se realice de forma elemental. (Tenga en cuenta que las operaciones elementales a menudo no son tan eficientes como los bucles).

Sumas

El operador + en las matrices es una suma de matrices. Es similar a una suma de elementos, pero no transmite forma. Es decir, si A y B tienen la misma forma, entonces A + B es lo mismo que A .+ B ; de lo contrario, A + B es un error, mientras que A .+ B puede no serlo necesariamente.

julia> A = [1 2
            3 4]
2×2 Array{Int64,2}:
 1  2
 3  4

julia> B = [5 6
            7 8]
2×2 Array{Int64,2}:
 5  6
 7  8

julia> A + B
2×2 Array{Int64,2}:
  6   8
 10  12

julia> A .+ B
2×2 Array{Int64,2}:
  6   8
 10  12

julia> C = [9, 10]
2-element Array{Int64,1}:
  9
 10

julia> A + C
ERROR: DimensionMismatch("dimensions must match")
 in promote_shape(::Tuple{Base.OneTo{Int64},Base.OneTo{Int64}}, ::Tuple{Base.OneTo{Int64}}) at ./operators.jl:396
 in promote_shape(::Array{Int64,2}, ::Array{Int64,1}) at ./operators.jl:382
 in _elementwise(::Base.#+, ::Array{Int64,2}, ::Array{Int64,1}, ::Type{Int64}) at ./arraymath.jl:61
 in +(::Array{Int64,2}, ::Array{Int64,1}) at ./arraymath.jl:53

julia> A .+ C
2×2 Array{Int64,2}:
 10  11
 13  14

Asimismo, - calcula una diferencia de matriz. Ambos + y - también se pueden utilizar como operadores unarios.

Productos

El operador * en matrices es el producto matricial (no el producto elementwise). Para un producto elementwise, use el operador. .* . Compara (usando las mismas matrices que arriba):

julia> A * B
2×2 Array{Int64,2}:
 19  22
 43  50

julia> A .* B
2×2 Array{Int64,2}:
  5  12
 21  32

Potestades

El operador ^ calcula la exponenciación de la matriz . La exponenciación de matrices puede ser útil para calcular valores de ciertas recurrencias rápidamente. Por ejemplo, los números de Fibonacci pueden ser generados por la expresión matricial

fib(n) = (BigInt[1 1; 1 0]^n)[2]

Como de costumbre, el operador .^ Se puede utilizar donde la operación deseada es la exponenciación elemental.