Julia Language
Aritmetisk

Syntax

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

Kvadratiska formel

Julia använder liknande binära operatörer för grundläggande aritmetiska operationer liksom matematik eller andra programmeringsspråk. De flesta operatörer kan skrivas i infixnotation (det vill säga placeras mellan värdena som beräknas). Julia har en ordning av operationer som matchar den vanliga konventionen i matematik.

Exempelvis implementerar koden nedan den kvadratiska formeln , som visar + , - , * och / operatörerna för tillägg, subtraktion, multiplikation respektive delning. Också visas implicit multiplikation , där ett nummer kan placeras direkt före en symbol för att betyda multiplikation; det vill säga 4a betyder detsamma som 4*a .

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

Användande:

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

Sikt av Eratosthenes

Restoperatören i Julia är % -operatören. Den här operatören uppför sig på samma sätt som % i språk som C och C ++. a % b är den signerade återstoden som är kvar efter att ha delat a med b .

Denna operatör är mycket användbar för att implementera vissa algoritmer, såsom följande implementering av Sieve of Eratosthenes .

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

Användande:

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

Matrix Aritmetic

Julia använder de matematiska standardbeteckningarna för aritmetiska operationer när de tillämpas på matriser. Ibland önskas elementvisa operationer istället. Dessa är markerade med ett helt stopp ( . ) Före operatören som ska göras elementvis. (Observera att elementvisa operationer ofta inte är lika effektiva som slingor.)

Belopp

Operatören + på matriser är en matrissumma. Det liknar en elementvis summa, men den sänder inte form. Det vill säga, om A och B har samma form, är A + B densamma som A .+ B ; annars är A + B ett fel, medan A .+ B kanske inte nödvändigtvis är det.

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

Likaledes - beräknar en matrisskillnad. Både + och - kan också användas som olika operatörer.

Produkter

Operatören * på matriser är matrisprodukten (inte elementvis produkt). För en elementvis produkt använder du operatören. .* . Jämför (med samma matriser som ovan):

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

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

Powers

^ -Operatören beräknar matriseksponentiering . Matriseksponentiering kan vara användbar för att snabbt beräkna värden för vissa återfall. Till exempel kan Fibonacci-siffrorna genereras genom matrisuttrycket

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

Som vanligt kan .^ -Operatören användas där elementvis exponentiering är den önskade operationen.