Mathematische Funktionen in Julia
Julia bietet eine Reihe effizienter, portabler mathematischer Standardfunktionen.
Numerischer Vergleich
Die folgende Tabelle listet die Funktionen auf, die für den numerischen Vergleich verwendet werden:
| Funktion | Prüft, ob die folgende Eigenschaft erfüllt ist |
|---|---|
isequal(x, y) |
xundyOb Wert und Typ exakt gleich sind |
isfinite(x) |
xOb es eine endliche Zahl ist |
isinf(x) |
xOb es (positiv/negativ) unendlich ist |
isnan(x) |
xOb es ... istNaN |
isequal betrachtet NaN-Werte als gleich:
Beispiel
wahr
julia> isequal([1 NaN], [1 NaN])
wahr
julia> isequal(NaN, NaN32)
wahr
isequal kann auch verwendet werden, um vorzeichenbehaftete Nullen zu unterscheiden:
Beispiel
wahr
julia> isequal(-0.0, 0.0)
false
Beispiele für andere Funktionen:
Beispiel
wahr
julia> isfinite(NaN32)
false
Rundungsfunktionen
Die folgende Tabelle listet die von Julia unterstützten Rundungsfunktionen auf:
| Funktion | Beschreibung | Rückgabetyp |
|---|---|---|
round(x) |
xRundet auf die nächste ganze Zahl |
typeof(x) |
round(T, x) |
xRundet auf die nächste ganze Zahl |
T |
floor(x) |
xin Richtung-InfRundung |
typeof(x) |
floor(T, x) |
xin Richtung-InfRundung |
T |
ceil(x) |
xin Richtung+InfGerichtetes Runden |
typeof(x) |
ceil(T, x) |
xin Richtung+InfGerichtetes Runden |
T |
trunc(x) |
xRunden gegen Null |
typeof(x) |
trunc(T, x) |
xRunden gegen Null |
T |
Beispiel
4.0
julia> round(Int, 3.8)
4
julia> floor(3.8)
3.0
julia> floor(Int, 3.8)
3
julia> ceil(3.8)
4.0
julia> ceil(Int, 3.8)
4
julia> trunc(3.8)
3.0
julia> trunc(Int, 3.8)
3
Divisionsfunktionen
Die folgende Tabelle listet die von Julia unterstützten Divisionsfunktionen auf:
| Funktion | Beschreibung |
|---|---|
div(x,y), x÷y |
Abgeschnittene Division: Unabhängig vom Typ lässt das Ergebnis der Division den Bruchteil weg, behält den ganzzahligen Teil bei, und der Quotient nähert sich Null. |
fld(x,y) |
Floor-Division; der Quotient in Richtung-Infnähert sich an |
cld(x,y) |
Ceiling-Division; der Quotient in Richtung+Infnähert sich an |
rem(x,y) |
Rest; erfülltx == div(x,y)*y + rem(x,y); das Vorzeichen ist konsistent mitxkonsistent |
mod(x,y) |
Modulo; erfülltx == fld(x,y)*y + mod(x,y); das Vorzeichen ist konsistent mitykonsistent |
mod1(x,y) |
Versatz um 1mod; wenny>0, dann zurückgebenr∈(0,y], wenny<0, dannr∈[y,0)und erfülltmod(r, y) == mod(x, y) |
mod2pi(x) |
Modulo 2pi;0 <= mod2pi(x) < 2pi |
divrem(x,y) |
Return(div(x,y),rem(x,y)) |
fldmod(x,y) |
Return(fld(x,y),mod(x,y)) |
gcd(x,y...) |
x, yGrößter gemeinsamer Teiler von , ... |
lcm(x,y...) |
x, yKleinstes gemeinsames Vielfaches von , ... |
Beispiel
2
julia> div(7, 4)
1
julia> fld(11, 4)
2
julia> fld(-5,3)
-2
julia> fld(7.5,3.3)
2.0
julia> cld(7.5,3.3)
3.0
julia> mod(5, 0:2)
2
julia> mod(3, 0:2)
0
julia> mod(8.9,2)
0.9000000000000004
julia> rem(8,4)
0
julia> rem(9,4)
1
julia> mod2pi(7*pi/5)
4.39822971502571
julia> divrem(8,3)
(2, 2)
julia> fldmod(12,4)
(3, 0)
julia> fldmod(13,4)
(3, 1)
julia> mod1(5,4)
1
julia> gcd(6,0)
6
julia> gcd(1//3,2//3)
1//3
julia> lcm(1//3,2//3)
2//3
Vorzeichen- und Betragsfunktionen
Die folgende Tabelle listet die von Julia unterstützten Vorzeichen- und Betragsfunktionen auf:
| Funktion | Beschreibung |
|---|---|
abs(x) |
xder Betrag von |
abs2(x) |
xdas Quadrat des Betrags von |
sign(x) |
repräsentiertxdas Vorzeichen von , gibt -1, 0 oder +1 zurück |
signbit(x) |
gibt an, ob das Vorzeichenbit true oder false ist |
copysign(x,y) |
gibt eine Zahl zurück, deren Wert gleich istxdem Betrag von , und das Vorzeichen stimmt überein mitykonsistent |
flipsign(x,y) |
gibt eine Zahl zurück, deren Wert gleich istxdem Betrag von , und das Vorzeichen stimmt überein mitx*ykonsistent |
Beispiel
7
julia> abs(5+3im)
5.830951894845301
julia> abs2(-7)
49
julia> abs2(5+3im)
34
julia> copysign(5,-10)
-5
julia> copysign(-5,10)
5
julia> sign(5)
1
julia> sign(-5)
-1
julia> signbit(-5)
wahr
julia> signbit(5)
false
julia> flipsign(5,10)
5
julia> flipsign(5,-10)
-5
Vorzeichen- und Betragsfunktionen
Die folgende Tabelle listet die von Julia unterstützten Vorzeichen- und Betragsfunktionen auf:
| Funktion | Beschreibung |
|---|---|
sqrt(x), √x |
xdie Quadratwurzel von |
cbrt(x), ∛x |
xdie Kubikwurzel von |
hypot(x,y) |
wenn die Längen der Katheten betragenxundy, die Länge der Hypotenuse eines rechtwinkligen Dreiecks |
exp(x) |
die natürliche Exponentialfunktion beixder Wert bei |
expm1(x) |
Wannxwenn nahe bei 0, dieexp(x)-1exakter Wert von |
ldexp(x,n) |
x*2^neffizienter Algorithmus für ,neine ganze Zahl ist |
log(x) |
xden natürlichen Logarithmus von |
log(b,x) |
withbals Basisxden Logarithmus von |
log2(x) |
Basis 2xLogarithmus von |
log10(x) |
Basis 10xLogarithmus von |
log1p(x) |
Wannxwenn nahe bei 0, dielog(1+x)exakter Wert von |
exponent(x) |
xden binären Exponenten von |
significand(x) |
Gleitkommazahlxden binären Signifikanden (das heißt, die Mantisse) von |
Beispiel
7.0
julia> sqrt(-49)
FEHLER: DomainError mit -49.0:
sqrt gibt nur dann ein komplexes Ergebnis zurück , wenn es mit einem komplexen Argument aufgerufen wird. Versuche sqrt(Complex(x)).
Stacktrace:
[1] throw_complex_domainerror(::Symbol, ::Float64) bei .\math.jl:33
[2] sqrt bei .\math.jl:573 [inlined]
[3] sqrt(::Int64) bei .\math.jl:599
[4] Top-Level-Scope bei REPL[43]:1
julia> cbrt(8)
2.0
julia> cbrt(-8)
-2.0
julia> a = Int64(5)^10;
julia> hypot(a, a)
1.3810679320049757e7
julia> exp(5.0)
148.4131591025766
julia> expm1(10)
22025.465794806718
julia> expm1(1.0)
1.718281828459045
julia> ldexp(4.0, 2)
16.0
julia> log(5,2)
0.43067655807339306
julia> log(4,2)
0.5
julia> log(4)
1.3862943611198906
julia> log2(4)
2.0
julia> log10(4)
0.6020599913279624
julia> log1p(4)
1.6094379124341003
julia> log1p(-2)
FEHLER: DomainError mit -2.0:
log1p gibt nur dann ein komplexes Ergebnis zurück , wenn es mit einem komplexen Argument aufgerufen wird. Versuchen log1p(Complex(x)).
Stacktrace:
[1] throw_complex_domainerror(::Symbol, ::Float64) bei .\math.jl:33
[2] log1p(::Float64) in .\special\log.jl:356
[3] log1p(::Int64) in .\special\log.jl:395
[4] Top-Level-Scope bei REPL[65]:1
julia> exponent(6.8)
2
julia> significand(15.2)/10.2
0.18627450980392157
julia> significand(15.2)*8
15.2
Trigonometrische und hyperbolische Funktionen
Julia bietet auch alle standardmäßigen trigonometrischen und hyperbolischen Funktionen:
sin cos tan cot sec csc sinh cosh tanh coth sech csch asin acos atan acot asec acsc asinh acosh atanh acoth asech acsch sinc cosc
In der folgenden Abbildung entspricht ein Winkel im Bogenmaß einem Punkt auf dem Einheitskreis, dessen Koordinaten den Sinus und Kosinus des Winkels definieren.

Beispiel
π = 3.1415926535897...
julia> sin(0)
0.0
julia> sin(pi/6)
0.49999999999999994
julia> sin(pi/4)
0.7071067811865475
julia> cos(0)
1.0
julia> cos(pi/6)
0.8660254037844387
julia> cos(pi/3)
0.5000000000000001
Alle oben bereitgestellten Funktionen sind Funktionen mit einem Argument, aber atan kann auch zwei Parameter akzeptieren, um die traditionelle atan2-Funktion darzustellen.
atan(y) atan(y, x)
Berechne den Arkustangens von y bzw. y/x.
Beispiel
2.356194490192345
julia> x,y = (cos(theta), sin(theta))
(-0.7071067811865475, 0.7071067811865476)
julia> atan(y/x)
-0.7853981633974484
julia> atan(y, x)
2.356194490192345
Darüber hinaus werden sinpi(x) und cospi(x) verwendet, um sin(pi*x) bzw. cos(pi*x) genauer zu berechnen.
Um trigonometrische Funktionen in Grad statt in Bogenmaß zu berechnen, verwenden Sie d als Suffix. Zum Beispiel berechnet sind(x) den Sinus von x, wobei x ein Winkel in Grad ist. Das Folgende ist eine vollständige Liste der trigonometrischen Funktionen für Winkelvariablen:
sind cosd tand cotd secd cscd asind acosd atand acotd asecd acscd
Beispiel
0.853220107722584
julia> cosd(56)
0.5591929034707468