Julia Language
Rekenkundig

Syntaxis

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

Kwadratische formule

Julia gebruikt vergelijkbare binaire operatoren voor elementaire rekenkundige bewerkingen, net als wiskunde of andere programmeertalen. De meeste operatoren kunnen worden geschreven in infix-notatie (dat wil zeggen geplaatst tussen de waarden die worden berekend). Julia heeft een volgorde van bewerkingen die overeenkomt met de algemene conventie in de wiskunde.

De onderstaande code implementeert bijvoorbeeld de kwadratische formule , die respectievelijk de + , - , * en / operatoren voor optellen, aftrekken, vermenigvuldigen en delen toont. Ook wordt impliciete vermenigvuldiging getoond, waarbij een getal direct voor een symbool kan worden geplaatst om vermenigvuldiging te betekenen; dat wil zeggen 4a betekent hetzelfde als 4*a .

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

Gebruik:

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

Zeef van Eratosthenes

De restoperator in Julia is de % -operator. Deze operator gedraagt zich vergelijkbaar met het % in talen zoals C en C ++. a % b is de getekende rest overblijven nadat delen a door b .

Deze operator is erg handig voor het implementeren van bepaalde algoritmen, zoals de volgende implementatie van de 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

Gebruik:

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

Matrix rekenkunde

Julia gebruikt de standaard wiskundige betekenissen van rekenkundige bewerkingen wanneer toegepast op matrices. Soms zijn elementaire bewerkingen in plaats daarvan gewenst. Deze zijn gemarkeerd met een punt ( . ) Voorafgaand aan de operator om elementair te worden uitgevoerd. (Merk op dat elementaire bewerkingen vaak niet zo efficiënt zijn als lussen.)

sommen

De operator + op matrices is een matrixsom. Het is vergelijkbaar met een elementgewijze som, maar het zendt geen vorm uit. Dat wil zeggen, als A en B dezelfde vorm hebben, dan is A + B hetzelfde als A .+ B ; anders is A + B een fout, terwijl A .+ B dat niet noodzakelijk is.

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

Evenzo, - berekent een verschil matrix. Zowel + als - kunnen ook worden gebruikt als unaire operatoren.

producten

De * -operator op matrices is het matrixproduct (niet het elementgewijze product). Gebruik voor een elementgewijs product de operator. .* . Vergelijk (met dezelfde matrices als hierboven):

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

De operator ^ berekent matrix-exponentiatie . Matrixvermenigvuldiging kan nuttig zijn om waarden van bepaalde recidieven snel te berekenen. De Fibonacci-getallen kunnen bijvoorbeeld worden gegenereerd door de matrixexpressie

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

Zoals gewoonlijk kan de .^ -Operator worden gebruikt waar elementaire exponentiëring de gewenste bewerking is.