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

julia> isequal(NaN, NaN)
wahr

julia> isequal([1 NaN], [1 NaN])
wahr

julia> isequal(NaN, NaN32)
wahr

isequal kann auch verwendet werden, um vorzeichenbehaftete Nullen zu unterscheiden:

Beispiel

julia> -0.0 == 0.0
wahr

julia> isequal(-0.0, 0.0)
false

Beispiele für andere Funktionen:

Beispiel

julia> isfinite(5)
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

julia> round(3.8)
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

julia> div(11, 4)
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

julia> abs(-7)
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

julia> sqrt(49)
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

julia> pi
π = 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

julia> theta = 3pi/4
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

julia> cos(56)
0.853220107722584

julia> cosd(56)
0.5591929034707468
Andere Erweiterungen