Mathematics

Mathematical Operators

Base.:- — Method

-(x)

Unärer Minusoperator.

Siehe auch: abs, flipsign.

Beispiele

julia> -1
-1

julia> -(2)
-2

julia> -[1 2; 3 4]
2×2 Matrix{Int64}:
 -1  -2
 -3  -4

julia> -(true)  # wird zu Int befördert
-1

julia> -(0x003)
0xfffd

source

Base.:+ — Function

dt::Date + t::Time -> DateTime

Die Addition eines Date mit einem Time ergibt ein DateTime. Die Stunden-, Minuten-, Sekunden- und Millisekundenanteile des Time werden zusammen mit dem Jahr, Monat und Tag des Date verwendet, um das neue DateTime zu erstellen. Nicht-null Mikrosekunden oder Nanosekunden im Time-Typ führen zu einem InexactError.

source

+(x, y...)

Addition Operator.

Infix x+y+z+... ruft diese Funktion mit allen Argumenten auf, d.h. +(x, y, z, ...), die standardmäßig dann (x+y) + z + ... von links nach rechts aufruft.

Beachten Sie, dass Überlauf für die meisten Ganzzahltypen, einschließlich des Standardtyps Int, möglich ist, wenn große Zahlen addiert werden.

Beispiele

julia> 1 + 20 + 4
25

julia> +(1, 20, 4)
25

julia> [1,2] + [3,4]
2-element Vector{Int64}:
 4
 6

julia> typemax(Int) + 1 < 0
true

source

Base.:- — Method

-(x, y)

Subtraktionsoperator.

Beispiele

julia> 2 - 3
-1

julia> -(2, 4.5)
-2.5

source

Base.:* — Method

*(x, y...)

Multiplikationsoperator.

Infix x*y*z*... ruft diese Funktion mit allen Argumenten auf, d.h. *(x, y, z, ...), die standardmäßig dann (x*y) * z * ... von links aus aufruft.

Juxtaposition wie 2pi ruft ebenfalls *(2, pi) auf. Beachten Sie, dass diese Operation eine höhere Priorität hat als ein literales *. Beachten Sie auch, dass die Juxtaposition "0x..." (ganzzahlig null mal eine Variable, deren Name mit x beginnt) verboten ist, da sie mit nicht signierten Ganzzahl-Literalen in Konflikt steht: 0x01 isa UInt8.

Beachten Sie, dass Überlauf für die meisten Ganzzahltypen, einschließlich des Standardtyps Int, beim Multiplizieren großer Zahlen möglich ist.

Beispiele

julia> 2 * 7 * 8
112

julia> *(2, 7, 8)
112

julia> [2 0; 0 3] * [1, 10]  # Matrix * Vektor
2-element Vector{Int64}:
  2
 30

julia> 1/2pi, 1/2*pi  # Juxtaposition hat höhere Priorität
(0.15915494309189535, 1.5707963267948966)

julia> x = [1, 2]; x'x  # adjungierter Vektor * Vektor
5

source

Base.:/ — Function

/(x, y)

Rechter Divisionsoperator: Multiplikation von x mit dem Inversen von y auf der rechten Seite.

Gibt Fließkommaergebnisse für ganzzahlige Argumente zurück. Siehe ÷ für ganzzahlige Division oder // für Rational Ergebnisse.

Beispiele

julia> 1/2
0.5

julia> 4/2
2.0

julia> 4.5/2
2.25

source

A / B

Matrix-Rechtsdivision: A / B ist äquivalent zu (B' \ A')', wobei \ der Linksdivisionsoperator ist. Für quadratische Matrizen ist das Ergebnis X so, dass A == X*B.

Siehe auch: rdiv!.

Beispiele

julia> A = Float64[1 4 5; 3 9 2]; B = Float64[1 4 2; 3 4 2; 8 7 1];

julia> X = A / B
2×3 Matrix{Float64}:
 -0.65   3.75  -1.2
  3.25  -2.75   1.0

julia> isapprox(A, X*B)
true

julia> isapprox(X, A*pinv(B))
true

source

Base.:\ — Method

\(x, y)

Linker-Operator: Multiplikation von y mit der Inversen von x von links. Gibt Fließkommaergebnisse für ganzzahlige Argumente zurück.

Beispiele

julia> 3 \ 6
2.0

julia> inv(3) * 6
2.0

julia> A = [4 3; 2 1]; x = [5, 6];

julia> A \ x
2-element Vector{Float64}:
  6.5
 -7.0

julia> inv(A) * x
2-element Vector{Float64}:
  6.5
 -7.0

source

Base.:^ — Method

^(x, y)

Exponentiationsoperator.

Wenn x und y Ganzzahlen sind, kann das Ergebnis überlaufen. Um Zahlen in wissenschaftlicher Notation einzugeben, verwenden Sie Float64 Literale wie 1.2e3 anstelle von 1.2 * 10^3.

Wenn y ein Int Literal ist (z. B. 2 in x^2 oder -3 in x^-3), wird der Julia-Code x^y vom Compiler in Base.literal_pow(^, x, Val(y)) umgewandelt, um eine Spezialisierung zur Kompilierzeit auf den Wert des Exponenten zu ermöglichen. (Als Standardfallback haben wir Base.literal_pow(^, x, Val(y)) = ^(x,y), wobei normalerweise ^ == Base.^ gilt, es sei denn, ^ wurde im aufrufenden Namensraum definiert.) Wenn y ein negatives ganzzahliges Literal ist, transformiert Base.literal_pow die Operation standardmäßig in inv(x)^-y, wobei -y positiv ist.

Siehe auch exp2, <<.

Beispiele

julia> 3^5
243

julia> 3^-1  # verwendet Base.literal_pow
0.3333333333333333

julia> p = -1;

julia> 3^p
ERROR: DomainError mit -1:
Kann eine Ganzzahl x nicht auf eine negative Potenz -1 heben.
[...]

julia> 3.0^p
0.3333333333333333

julia> 10^19 > 0  # Ganzzahlüberlauf
false

julia> big(10)^19 == 1e19
true

source

Base.fma — Function

fma(x, y, z)

Berechnet x*y+z ohne das Zwischenergebnis x*y zu runden. Auf einigen Systemen ist dies erheblich teurer als x*y+z. fma wird verwendet, um die Genauigkeit in bestimmten Algorithmen zu verbessern. Siehe muladd.

source

Base.muladd — Function

muladd(x, y, z)

Kombinierte Multiplikation-Addition: berechnet x*y+z, erlaubt jedoch, dass die Addition und Multiplikation mit einander oder mit umgebenden Operationen zur Leistungssteigerung zusammengeführt werden. Zum Beispiel kann dies als fma implementiert werden, wenn die Hardware dies effizient unterstützt. Das Ergebnis kann auf verschiedenen Maschinen unterschiedlich sein und kann auch auf derselben Maschine aufgrund von Konstantenpropagation oder anderen Optimierungen unterschiedlich sein. Siehe fma.

Beispiele

julia> muladd(3, 2, 1)
7

julia> 3 * 2 + 1
7

source

muladd(A, y, z)

Kombinierte Multiplikation-Addition, A*y .+ z, für Matrix-Matrix- oder Matrix-Vektor-Multiplikation. Das Ergebnis hat immer die gleiche Größe wie A*y, aber z kann kleiner oder ein Skalar sein.

Julia 1.6

Diese Methoden erfordern Julia 1.6 oder später.

Beispiele

julia> A=[1.0 2.0; 3.0 4.0]; B=[1.0 1.0; 1.0 1.0]; z=[0, 100];

julia> muladd(A, B, z)
2×2 Matrix{Float64}:
   3.0    3.0
 107.0  107.0

source

Base.inv — Method

inv(x)

Gibt das multiplikative Inverse von x zurück, so dass x*inv(x) oder inv(x)*x one(x) (die multiplikative Identität) bis auf Rundungsfehler ergibt.

Wenn x eine Zahl ist, ist dies im Wesentlichen dasselbe wie one(x)/x, aber für einige Typen kann inv(x) etwas effizienter sein.

Beispiele

julia> inv(2)
0.5

julia> inv(1 + 2im)
0.2 - 0.4im

julia> inv(1 + 2im) * (1 + 2im)
1.0 + 0.0im

julia> inv(2//3)
3//2

Julia 1.2

inv(::Missing) erfordert mindestens Julia 1.2.

source

Base.div — Function

div(x, y)
÷(x, y)

Der Quotient aus der euklidischen (ganzzahligen) Division. Allgemein äquivalent zu einer mathematischen Operation x/y ohne einen Bruchteil.

Siehe auch: cld, fld, rem, divrem.

Beispiele

julia> 9 ÷ 4
2

julia> -5 ÷ 3
-1

julia> 5.0 ÷ 2
2.0

julia> div.(-5:5, 3)'
1×11 adjoint(::Vector{Int64}) mit eltype Int64:
 -1  -1  -1  0  0  0  0  0  1  1  1

source

Base.div — Method

div(x, y, r::RoundingMode=RoundToZero)

Der Quotient aus der euklidischen (ganzzahligen) Division. Berechnet x / y, gerundet auf eine ganze Zahl gemäß dem Rundungsmodus r. Mit anderen Worten, die Größe

round(x / y, r)

ohne Zwischenrundung.

Julia 1.4

Die Methode mit drei Argumenten, die einen RoundingMode verwendet, erfordert Julia 1.4 oder höher.

Siehe auch fld und cld, die spezielle Fälle dieser Funktion sind.

Julia 1.9

RoundFromZero erfordert mindestens Julia 1.9.

Beispiele:

julia> div(4, 3, RoundToZero) # Entspricht div(4, 3)
1
julia> div(4, 3, RoundDown) # Entspricht fld(4, 3)
1
julia> div(4, 3, RoundUp) # Entspricht cld(4, 3)
2
julia> div(5, 2, RoundNearest)
2
julia> div(5, 2, RoundNearestTiesAway)
3
julia> div(-5, 2, RoundNearest)
-2
julia> div(-5, 2, RoundNearestTiesAway)
-3
julia> div(-5, 2, RoundNearestTiesUp)
-2
julia> div(4, 3, RoundFromZero)
2
julia> div(-4, 3, RoundFromZero)
-2

source

Base.fld — Function

fld(x, y)

Größte ganze Zahl, die kleiner oder gleich x / y ist. Entspricht div(x, y, RoundDown).

Siehe auch div, cld, fld1.

Beispiele

julia> fld(7.3, 5.5)
1.0

julia> fld.(-5:5, 3)'
1×11 adjoint(::Vector{Int64}) mit eltype Int64:
 -2  -2  -1  -1  -1  0  0  0  1  1  1

Da fld(x, y) eine streng korrekte Abrundung basierend auf dem wahren Wert von Fließkommazahlen implementiert, können unintuitive Situationen auftreten. Zum Beispiel:

julia> fld(6.0, 0.1)
59.0
julia> 6.0 / 0.1
60.0
julia> 6.0 / big(0.1)
59.99999999999999666933092612453056361837965690217069245739573412231113406246995

Was hier passiert, ist, dass der wahre Wert der Fließkommazahl, die als 0.1 geschrieben ist, leicht größer ist als der numerische Wert 1/10, während 6.0 die Zahl 6 genau darstellt. Daher ist der wahre Wert von 6.0 / 0.1 leicht kleiner als 60. Bei der Division wird dies genau auf 60.0 gerundet, aber fld(6.0, 0.1) nimmt immer die Abrundung des wahren Wertes, sodass das Ergebnis 59.0 ist.

source

Base.cld — Function

cld(x, y)

Kleinste ganze Zahl, die größer oder gleich x / y ist. Entspricht div(x, y, RoundUp).

Siehe auch div, fld.

Beispiele

julia> cld(5.5, 2.2)
3.0

julia> cld.(-5:5, 3)'
1×11 adjoint(::Vector{Int64}) mit eltype Int64:
 -1  -1  -1  0  0  0  1  1  1  2  2

source

Base.mod — Function

mod(x::Integer, r::AbstractUnitRange)

Finde y im Bereich r, so dass $x ≡ y (mod n)$, wobei n = length(r), d.h. y = mod(x - first(r), n) + first(r).

Siehe auch mod1.

Beispiele

julia> mod(0, Base.OneTo(3))  # mod1(0, 3)
3

julia> mod(3, 0:2)  # mod(3, 3)
0

Julia 1.3

Diese Methode erfordert mindestens Julia 1.3.

source

mod(x, y)
rem(x, y, RoundDown)

Die Reduktion von x modulo y, oder äquivalent, der Rest von x nach ganzzahliger Division durch y, d.h. x - y*fld(x,y), wenn ohne Zwischenrundung berechnet.

Das Ergebnis hat das gleiche Vorzeichen wie y und eine Größe, die kleiner ist als abs(y) (mit einigen Ausnahmen, siehe Hinweis unten).

!!! Hinweis Wenn mit Fließkommawerten verwendet, kann das exakte Ergebnis möglicherweise nicht durch den Typ dargestellt werden, und es kann daher zu Rundungsfehlern kommen. Insbesondere, wenn das exakte Ergebnis sehr nahe an y liegt, kann es auf y gerundet werden.

Siehe auch: rem, div, fld, mod1, invmod.

julia> mod(8, 3)
2

julia> mod(9, 3)
0

julia> mod(8.9, 3)
2.9000000000000004

julia> mod(eps(), 3)
2.220446049250313e-16

julia> mod(-eps(), 3)
3.0

julia> mod.(-5:5, 3)'
1×11 adjoint(::Vector{Int64}) mit eltype Int64:
 1  2  0  1  2  0  1  2  0  1  2

source

rem(x::Integer, T::Type{<:Integer}) -> T
mod(x::Integer, T::Type{<:Integer}) -> T
%(x::Integer, T::Type{<:Integer}) -> T

Finde y::T, so dass x ≡ y (mod n), wobei n die Anzahl der in T darstellbaren Ganzzahlen ist und y eine Ganzzahl in [typemin(T),typemax(T)] ist. Wenn T jede Ganzzahl darstellen kann (z. B. T == BigInt), entspricht diese Operation einer Umwandlung in T.

Beispiele

julia> x = 129 % Int8
-127

julia> typeof(x)
Int8

julia> x = 129 % BigInt
129

julia> typeof(x)
BigInt

source

Base.rem — Function

rem(x, y)
%(x, y)

Rest von der euklidischen Division, der einen Wert mit dem gleichen Vorzeichen wie x zurückgibt und in der Größe kleiner als y ist. Dieser Wert ist immer genau.

Siehe auch: div, mod, mod1, divrem.

Beispiele

julia> x = 15; y = 4;

julia> x % y
3

julia> x == div(x, y) * y + rem(x, y)
true

julia> rem.(-5:5, 3)'
1×11 adjoint(::Vector{Int64}) mit eltype Int64:
 -2  -1  0  -2  -1  0  1  2  0  1  2

source

Base.rem — Method

rem(x, y, r::RoundingMode=RoundToZero)

Berechne den Rest von x nach der ganzzahligen Division durch y, wobei der Quotient gemäß dem Rundungsmodus r gerundet wird. Mit anderen Worten, die Größe

x - y * round(x / y, r)

ohne Zwischenrundung.

wenn r == RoundNearest, dann ist das Ergebnis genau und im Intervall $[-|y| / 2, |y| / 2]$. Siehe auch RoundNearest.
wenn r == RoundToZero (Standard), dann ist das Ergebnis genau und im Intervall $[0, |y|)$, wenn x positiv ist, oder $(-|y|, 0]$ andernfalls. Siehe auch RoundToZero.
wenn r == RoundDown, dann liegt das Ergebnis im Intervall $[0, y)$, wenn y positiv ist, oder $(y, 0]$ andernfalls. Das Ergebnis kann ungenau sein, wenn x und y unterschiedliche Vorzeichen haben und abs(x) < abs(y). Siehe auch RoundDown.
wenn r == RoundUp, dann liegt das Ergebnis im Intervall $(-y, 0]$, wenn y positiv ist, oder $[0, -y)$ andernfalls. Das Ergebnis kann ungenau sein, wenn x und y dasselbe Vorzeichen haben und abs(x) < abs(y). Siehe auch RoundUp.
wenn r == RoundFromZero, dann liegt das Ergebnis im Intervall $(-y, 0]$, wenn y positiv ist, oder $[0, -y)$ andernfalls. Das Ergebnis kann ungenau sein, wenn x und y dasselbe Vorzeichen haben und abs(x) < abs(y). Siehe auch RoundFromZero.

Julia 1.9

RoundFromZero erfordert mindestens Julia 1.9.

Beispiele:

julia> x = 9; y = 4;

julia> x % y  # dasselbe wie rem(x, y)
1

julia> x ÷ y  # dasselbe wie div(x, y)
2

julia> x == div(x, y) * y + rem(x, y)
true

source

Base.Math.rem2pi — Function

rem2pi(x, r::RoundingMode)

Berechnet den Rest von x nach der ganzzahligen Division durch 2π, wobei der Quotient gemäß dem Rundungsmodus r gerundet wird. Mit anderen Worten, die Größe

x - 2π*round(x/(2π),r)

ohne Zwischenrundung. Dies verwendet intern eine hochpräzise Näherung von 2π und liefert daher ein genaueres Ergebnis als rem(x,2π,r)

wenn r == RoundNearest, dann liegt das Ergebnis im Intervall $[-π, π]$. Dies wird im Allgemeinen das genaueste Ergebnis sein. Siehe auch RoundNearest.
wenn r == RoundToZero, dann liegt das Ergebnis im Intervall $[0, 2π]$, wenn x positiv ist, oder $[-2π, 0]$ andernfalls. Siehe auch RoundToZero.
wenn r == RoundDown, dann liegt das Ergebnis im Intervall $[0, 2π]$. Siehe auch RoundDown.
wenn r == RoundUp, dann liegt das Ergebnis im Intervall $[-2π, 0]$. Siehe auch RoundUp.

Beispiele

julia> rem2pi(7pi/4, RoundNearest)
-0.7853981633974485

julia> rem2pi(7pi/4, RoundDown)
5.497787143782138

source

Base.Math.mod2pi — Function

mod2pi(x)

Modulus nach Division durch 2π, Rückgabe im Bereich $[0,2π)$.

Diese Funktion berechnet eine Fließkommadarstellung des Modulus nach Division durch numerisch exaktes 2π und ist daher nicht genau dasselbe wie mod(x,2π), das den Modulus von x relativ zur Division durch die Fließkommazahl 2π berechnen würde.

!!! Hinweis Abhängig vom Format des Eingabewerts kann der nächstgelegene darstellbare Wert zu 2π kleiner als 2π sein. Zum Beispiel wird der Ausdruck mod2pi(2π) nicht 0 zurückgeben, da der Zwischenwert von 2*π ein Float64 ist und 2*Float64(π) < 2*big(π). Siehe rem2pi für eine verfeinerte Kontrolle dieses Verhaltens.

Beispiele

julia> mod2pi(9*pi/4)
0.7853981633974481

source

Base.divrem — Function

divrem(x, y, r::RoundingMode=RoundToZero)

Der Quotient und der Rest aus der euklidischen Division. Entspricht (div(x, y, r), rem(x, y, r)). Entsprechend ist dieser Aufruf mit dem Standardwert von r gleichbedeutend mit (x ÷ y, x % y).

Siehe auch: fldmod, cld.

Beispiele

julia> divrem(3, 7)
(0, 3)

julia> divrem(7, 3)
(2, 1)

source

Base.fldmod — Function

fldmod(x, y)

Der abgerundete Quotient und der Modulus nach der Division. Ein praktischer Wrapper für divrem(x, y, RoundDown). Entspricht (fld(x, y), mod(x, y)).

Siehe auch: fld, cld, fldmod1.

source

Base.fld1 — Function

fld1(x, y)

Bodendivision, die einen Wert zurückgibt, der mit mod1(x,y) übereinstimmt.

Siehe auch mod1, fldmod1.

Beispiele

julia> x = 15; y = 4;

julia> fld1(x, y)
4

julia> x == fld(x, y) * y + mod(x, y)
true

julia> x == (fld1(x, y) - 1) * y + mod1(x, y)
true

source

Base.mod1 — Function

mod1(x, y)

Modulus nach ganzzahliger Division, gibt einen Wert r zurück, sodass mod(r, y) == mod(x, y) im Bereich $(0, y]$ für positives y und im Bereich $[y,0)$ für negatives y.

Bei ganzzahligen Argumenten und positivem y entspricht dies mod(x, 1:y), und ist daher natürlich für 1-basierte Indizierung. Im Vergleich dazu ist mod(x, y) == mod(x, 0:y-1) natürlich für Berechnungen mit Offsets oder Schritten.

Siehe auch mod, fld1, fldmod1.

Beispiele

julia> mod1(4, 2)
2

julia> mod1.(-5:5, 3)'
1×11 adjoint(::Vector{Int64}) mit eltype Int64:
 1  2  3  1  2  3  1  2  3  1  2

julia> mod1.([-0.1, 0, 0.1, 1, 2, 2.9, 3, 3.1]', 3)
1×8 Matrix{Float64}:
 2.9  3.0  0.1  1.0  2.0  2.9  3.0  0.1

source

Base.fldmod1 — Function

fldmod1(x, y)

Gibt (fld1(x,y), mod1(x,y)) zurück.

Siehe auch fld1, mod1.

source

Base.:// — Function

//(num, den)

Teile zwei ganze Zahlen oder rationale Zahlen, wobei ein Rational Ergebnis zurückgegeben wird. Allgemeiner kann // für die exakte rationale Division anderer numerischer Typen mit ganzzahligen oder rationalen Komponenten verwendet werden, wie z. B. komplexe Zahlen mit ganzzahligen Komponenten.

Beachte, dass Gleitkomma-(AbstractFloat) Argumente von // nicht erlaubt sind (auch wenn die Werte rational sind). Die Argumente müssen Untertypen von Integer, Rational oder deren Kombinationen sein.

Beispiele

julia> 3 // 5
3//5

julia> (3 // 5) // (2 // 1)
3//10

julia> (1+2im) // (3+4im)
11//25 + 2//25*im

julia> 1.0 // 2
ERROR: MethodError: no method matching //(::Float64, ::Int64)
[...]

source

Base.rationalize — Function

rationalize([T<:Integer=Int,] x; tol::Real=eps(x))

Näherungsweise Gleitkommazahl x als eine Rational Zahl mit Komponenten des angegebenen Ganzzahltyps. Das Ergebnis unterscheidet sich von x um nicht mehr als tol.

Beispiele

julia> rationalize(5.6)
28//5

julia> a = rationalize(BigInt, 10.3)
103//10

julia> typeof(numerator(a))
BigInt

source

Base.numerator — Function

numerator(x)

Zähler der rationalen Darstellung von x.

Beispiele

julia> numerator(2//3)
2

julia> numerator(4)
4

source

Base.denominator — Function

denominator(x)

Nenner der rationalen Darstellung von x.

Beispiele

julia> denominator(2//3)
3

julia> denominator(4)
1

source

Base.:<< — Function

<<(x, n)

Linker Bitverschiebungsoperator, x << n. Für n >= 0 ist das Ergebnis x, das um n Bits nach links verschoben wird, wobei mit 0s aufgefüllt wird. Dies entspricht x * 2^n. Für n < 0 entspricht dies x >> -n.

Beispiele

julia> Int8(3) << 2
12

julia> bitstring(Int8(3))
"00000011"

julia> bitstring(Int8(12))
"00001100"

Siehe auch >>, >>>, exp2, ldexp.

source

<<(B::BitVector, n) -> BitVector

Linker Bitverschiebungsoperator, B << n. Für n >= 0 ist das Ergebnis B mit Elementen, die um n Positionen nach hinten verschoben sind, wobei mit false-Werten aufgefüllt wird. Wenn n < 0, werden die Elemente nach vorne verschoben. Entspricht B >> -n.

Beispiele

julia> B = BitVector([true, false, true, false, false])
5-element BitVector:
 1
 0
 1
 0
 0

julia> B << 1
5-element BitVector:
 0
 1
 0
 0
 0

julia> B << -1
5-element BitVector:
 0
 1
 0
 1
 0

source

Base.:>> — Function

>>(x, n)

Rechter Bitverschiebungsoperator, x >> n. Für n >= 0 ist das Ergebnis x, das um n Bits nach rechts verschoben wird, wobei mit 0s gefüllt wird, wenn x >= 0, und mit 1s, wenn x < 0, wobei das Vorzeichen von x beibehalten wird. Dies entspricht fld(x, 2^n). Für n < 0 entspricht dies x << -n.

Beispiele

julia> Int8(13) >> 2
3

julia> bitstring(Int8(13))
"00001101"

julia> bitstring(Int8(3))
"00000011"

julia> Int8(-14) >> 2
-4

julia> bitstring(Int8(-14))
"11110010"

julia> bitstring(Int8(-4))
"11111100"

Siehe auch >>>, <<.

source

>>(B::BitVector, n) -> BitVector

Rechter Bitverschiebungsoperator, B >> n. Für n >= 0 ist das Ergebnis B mit Elementen, die um n Positionen nach vorne verschoben werden, wobei mit false-Werten aufgefüllt wird. Wenn n < 0 ist, werden die Elemente nach hinten verschoben. Entspricht B << -n.

Beispiele

julia> B = BitVector([true, false, true, false, false])
5-element BitVector:
 1
 0
 1
 0
 0

julia> B >> 1
5-element BitVector:
 0
 1
 0
 1
 0

julia> B >> -1
5-element BitVector:
 0
 1
 0
 0
 0

source

Base.:>>> — Function

>>>(x, n)

Unsignierter rechter Bitverschiebungsoperator, x >>> n. Für n >= 0 ist das Ergebnis x, das um n Bits nach rechts verschoben wird, wobei mit 0s aufgefüllt wird. Für n < 0 entspricht dies x << -n.

Für Unsigned Ganzzahltypen entspricht dies >>. Für Signed Ganzzahltypen entspricht dies signed(unsigned(x) >> n).

Beispiele

julia> Int8(-14) >>> 2
60

julia> bitstring(Int8(-14))
"11110010"

julia> bitstring(Int8(60))
"00111100"

BigInts werden behandelt, als hätten sie eine unendliche Größe, sodass kein Auffüllen erforderlich ist und dies entspricht >>.

Siehe auch >>, <<.

source

>>>(B::BitVector, n) -> BitVector

Unsignierter rechter Bitverschiebungsoperator, B >>> n. Entspricht B >> n. Siehe >> für Details und Beispiele.

source

Base.bitrotate — Function

bitrotate(x::Base.BitInteger, k::Integer)

bitrotate(x, k) implementiert eine bitweise Rotation. Es gibt den Wert von x zurück, dessen Bits k Mal nach links rotiert wurden. Ein negativer Wert von k rotiert stattdessen nach rechts.

Julia 1.5

Diese Funktion erfordert Julia 1.5 oder höher.

Siehe auch: <<, circshift, BitArray.

julia> bitrotate(UInt8(114), 2)
0xc9

julia> bitstring(bitrotate(0b01110010, 2))
"11001001"

julia> bitstring(bitrotate(0b01110010, -2))
"10011100"

julia> bitstring(bitrotate(0b01110010, 8))
"01110010"

source

Base.:: — Function

:expr

Zitiert einen Ausdruck expr und gibt den abstrakten Syntaxbaum (AST) von expr zurück. Der AST kann vom Typ Expr, Symbol oder einem literalen Wert sein. Die Syntax :identifier wertet zu einem Symbol aus.

Siehe auch: Expr, Symbol, Meta.parse

Beispiele

julia> expr = :(a = b + 2*x)
:(a = b + 2x)

julia> sym = :some_identifier
:some_identifier

julia> value = :0xff
0xff

julia> typeof((expr, sym, value))
Tuple{Expr, Symbol, UInt8}

source

Base.range — Function

range(start, stop, length)
range(start, stop; length, step)
range(start; length, stop, step)
range(;start, length, stop, step)

Konstruiere ein spezialisiertes Array mit gleichmäßig verteilten Elementen und optimierter Speicherung (ein AbstractRange) aus den Argumenten. Mathematisch wird ein Bereich eindeutig durch drei der Werte start, step, stop und length bestimmt. Gültige Aufrufe von range sind:

Rufe range mit drei der Werte start, step, stop, length auf.
Rufe range mit zwei der Werte start, stop, length auf. In diesem Fall wird step als eins angenommen. Wenn beide Argumente Ganzzahlen sind, wird ein UnitRange zurückgegeben.
Rufe range mit einem der Werte stop oder length auf. start und step werden als eins angenommen.

Siehe Erweiterte Hilfe für zusätzliche Details zum zurückgegebenen Typ. Siehe auch logrange für logarithmisch verteilte Punkte.

Beispiele

julia> range(1, length=100)
1:100

julia> range(1, stop=100)
1:100

julia> range(1, step=5, length=100)
1:5:496

julia> range(1, step=5, stop=100)
1:5:96

julia> range(1, 10, length=101)
1.0:0.09:10.0

julia> range(1, 100, step=5)
1:5:96

julia> range(stop=10, length=5)
6:10

julia> range(stop=10, step=1, length=5)
6:1:10

julia> range(start=1, step=1, stop=10)
1:1:10

julia> range(; length = 10)
Base.OneTo(10)

julia> range(; stop = 6)
Base.OneTo(6)

julia> range(; stop = 6.5)
1.0:1.0:6.0

Wenn length nicht angegeben ist und stop - start kein ganzzahliges Vielfaches von step ist, wird ein Bereich erzeugt, der vor stop endet.

julia> range(1, 3.5, step=2)
1.0:2.0:3.0

Besondere Sorgfalt wird darauf verwendet, sicherzustellen, dass Zwischenwerte rational berechnet werden. Um diesen induzierten Overhead zu vermeiden, siehe den LinRange Konstruktor.

Julia 1.1

stop als positionsgebundenes Argument erfordert mindestens Julia 1.1.

Julia 1.7

Die Versionen ohne Schlüsselwortargumente und start als Schlüsselwortargument erfordern mindestens Julia 1.7.

Julia 1.8

Die Versionen mit stop als einzigem Schlüsselwortargument oder length als einzigem Schlüsselwortargument erfordern mindestens Julia 1.8.

Erweiterte Hilfe

range erzeugt ein Base.OneTo, wenn die Argumente Ganzzahlen sind und

Nur length angegeben ist
Nur stop angegeben ist

range erzeugt einen UnitRange, wenn die Argumente Ganzzahlen sind und

Nur start und stop angegeben sind
Nur length und stop angegeben sind

Ein UnitRange wird nicht erzeugt, wenn step angegeben ist, selbst wenn es als eins angegeben ist.

source

Base.OneTo — Type

Base.OneTo(n)

Definieren Sie einen AbstractUnitRange, der sich wie 1:n verhält, mit dem zusätzlichen Unterschied, dass die Untergrenze (durch das Typsystem) garantiert 1 ist.

source

Base.StepRangeLen — Type

StepRangeLen(         ref::R, step::S, len, [offset=1]) where {  R,S}
StepRangeLen{T,R,S}(  ref::R, step::S, len, [offset=1]) where {T,R,S}
StepRangeLen{T,R,S,L}(ref::R, step::S, len, [offset=1]) where {T,R,S,L}

Ein Bereich r, bei dem r[i] Werte vom Typ T erzeugt (im ersten Fall wird T automatisch abgeleitet), parametrisiert durch einen referenzwert, einen step und die length. Standardmäßig ist ref der Startwert r[1], alternativ können Sie ihn als Wert von r[offset] für einen anderen Index 1 <= offset <= len angeben. Die Syntax a:b oder a:b:c, wobei einer von a, b oder c Fließkommazahlen sind, erstellt einen StepRangeLen.

Julia 1.7

Der 4. Typparameter L erfordert mindestens Julia 1.7.

source

Base.logrange — Function

logrange(start, stop, length)
logrange(start, stop; length)

Konstruiere ein spezialisiertes Array, dessen Elemente logarithmisch zwischen den gegebenen Endpunkten verteilt sind. Das heißt, das Verhältnis aufeinanderfolgender Elemente ist konstant und wird aus der Länge berechnet.

Dies ist ähnlich wie geomspace in Python. Im Gegensatz zu PowerRange in Mathematica gibst du die Anzahl der Elemente an, nicht das Verhältnis. Im Gegensatz zu logspace in Python und Matlab sind die start- und stop-Argumente immer die ersten und letzten Elemente des Ergebnisses, nicht Potenzen, die auf eine Basis angewendet werden.

Beispiele

julia> logrange(10, 4000, length=3)
3-element Base.LogRange{Float64, Base.TwicePrecision{Float64}}:
 10.0, 200.0, 4000.0

julia> ans[2] ≈ sqrt(10 * 4000)  # mittleres Element ist das geometrische Mittel
true

julia> range(10, 40, length=3)[2] ≈ (10 + 40)/2  # arithmetisches Mittel
true

julia> logrange(1f0, 32f0, 11)
11-element Base.LogRange{Float32, Float64}:
 1.0, 1.41421, 2.0, 2.82843, 4.0, 5.65685, 8.0, 11.3137, 16.0, 22.6274, 32.0

julia> logrange(1, 1000, length=4) ≈ 10 .^ (0:3)
true

Siehe den LogRange Typ für weitere Details.

Siehe auch range für linear verteilte Punkte.

Julia 1.11

Diese Funktion erfordert mindestens Julia 1.11.

source

Base.LogRange — Type

LogRange{T}(start, stop, len) <: AbstractVector{T}

Ein Bereich, dessen Elemente logarithmisch zwischen start und stop verteilt sind, wobei der Abstand durch len gesteuert wird. Zurückgegeben von logrange.

Wie bei LinRange werden die ersten und letzten Elemente genau die angegebenen sein, aber Zwischenwerte können kleine Gleitkommafehler aufweisen. Diese werden unter Verwendung der Logarithmen der Endpunkte berechnet, die beim Erstellen gespeichert werden, oft in höherer Präzision als T.

Beispiele

julia> logrange(1, 4, length=5)
5-element Base.LogRange{Float64, Base.TwicePrecision{Float64}}:
 1.0, 1.41421, 2.0, 2.82843, 4.0

julia> Base.LogRange{Float16}(1, 4, 5)
5-element Base.LogRange{Float16, Float64}:
 1.0, 1.414, 2.0, 2.828, 4.0

julia> logrange(1e-310, 1e-300, 11)[1:2:end]
6-element Vector{Float64}:
 1.0e-310
 9.999999999999974e-309
 9.999999999999981e-307
 9.999999999999988e-305
 9.999999999999994e-303
 1.0e-300

julia> prevfloat(1e-308, 5) == ans[2]
true

Beachten Sie, dass der ganzzahlige eltype T nicht erlaubt ist. Verwenden Sie beispielsweise round.(Int, xs) oder explizite Potenzen einer ganzzahligen Basis:

julia> xs = logrange(1, 512, 4)
4-element Base.LogRange{Float64, Base.TwicePrecision{Float64}}:
 1.0, 8.0, 64.0, 512.0

julia> 2 .^ (0:3:9) |> println
[1, 8, 64, 512]

Julia 1.11

Dieser Typ erfordert mindestens Julia 1.11.

source

Base.:== — Function

==(x, y)

Generischer Gleichheitsoperator. Fällt zurück auf ===. Sollte für alle Typen mit einem Konzept von Gleichheit implementiert werden, basierend auf dem abstrakten Wert, den eine Instanz repräsentiert. Zum Beispiel werden alle numerischen Typen nach ihrem numerischen Wert verglichen, unabhängig vom Typ. Strings werden als Zeichenfolgen verglichen, wobei die Kodierung ignoriert wird. Sammlungen desselben Typs vergleichen im Allgemeinen ihre Schlüsselsätze, und wenn diese == sind, vergleichen sie die Werte für jeden dieser Schlüssel und geben true zurück, wenn alle solchen Paare == sind. Andere Eigenschaften werden typischerweise nicht berücksichtigt (wie der genaue Typ).

Dieser Operator folgt den IEEE-Semantiken für Fließkommazahlen: 0.0 == -0.0 und NaN != NaN.

Das Ergebnis ist vom Typ Bool, es sei denn, einer der Operanden ist missing, in diesem Fall wird missing zurückgegeben (dreiwertige Logik). Sammlungen implementieren im Allgemeinen eine dreiwertige Logik ähnlich wie all, wobei missing zurückgegeben wird, wenn einer der Operanden fehlende Werte enthält und alle anderen Paare gleich sind. Verwenden Sie isequal oder ===, um immer ein Bool-Ergebnis zu erhalten.

Implementierung

Neue numerische Typen sollten diese Funktion für zwei Argumente des neuen Typs implementieren und den Vergleich mit anderen Typen, wo möglich, über Promotionsregeln handhaben.

isequal fällt auf == zurück, sodass neue Methoden von == vom Dict-Typ verwendet werden, um Schlüssel zu vergleichen. Wenn Ihr Typ als Schlüssel in einem Wörterbuch verwendet wird, sollte er daher auch hash implementieren.

Wenn ein Typ ==, isequal und isless definiert, sollte er auch < implementieren, um die Konsistenz der Vergleiche sicherzustellen.

source

Base.:!= — Function

!=(x, y)
≠(x,y)

Ungleichheitsvergleichsoperator. Gibt immer die entgegengesetzte Antwort wie == zurück.

Implementierung

Neue Typen sollten dies im Allgemeinen nicht implementieren und stattdessen auf die Fallback-Definition !=(x,y) = !(x==y) zurückgreifen.

Beispiele

julia> 3 != 2
true

julia> "foo" ≠ "foo"
false

source

!=(x)

Erstellen Sie eine Funktion, die ihr Argument mit x unter Verwendung von != vergleicht, d.h. eine Funktion, die äquivalent zu y -> y != x ist. Die zurückgegebene Funktion ist vom Typ Base.Fix2{typeof(!=)}, die verwendet werden kann, um spezialisierte Methoden zu implementieren.

Julia 1.2

Diese Funktionalität erfordert mindestens Julia 1.2.

source

Base.:!== — Function

!==(x, y)
≢(x,y)

Gibt immer die entgegengesetzte Antwort wie ===.

Beispiele

julia> a = [1, 2]; b = [1, 2];

julia> a ≢ b
true

julia> a ≢ a
false

source

Base.:< — Function

<(x, y)

Weniger-als-Vergleichsoperator. Fällt zurück auf isless. Aufgrund des Verhaltens von Gleitkomma-NaN-Werten implementiert dieser Operator eine partielle Ordnung.

Implementierung

Neue Typen mit einer kanonischen partiellen Ordnung sollten diese Funktion für zwei Argumente des neuen Typs implementieren. Typen mit einer kanonischen totalen Ordnung sollten stattdessen isless implementieren.

Siehe auch isunordered.

Beispiele

julia> 'a' < 'b'
true

julia> "abc" < "abd"
true

julia> 5 < 3
false

source

<(x)

Erstellen Sie eine Funktion, die ihr Argument mit x unter Verwendung von < vergleicht, d.h. eine Funktion, die äquivalent zu y -> y < x ist. Die zurückgegebene Funktion hat den Typ Base.Fix2{typeof(<)}, der verwendet werden kann, um spezialisierte Methoden zu implementieren.

Julia 1.2

Diese Funktionalität erfordert mindestens Julia 1.2.

source

Base.:<= — Function

<=(x, y)
≤(x,y)

Weniger-als-oder-gleich Vergleichsoperator. Fällt zurück auf (x < y) | (x == y).

Beispiele

julia> 'a' <= 'b'
true

julia> 7 ≤ 7 ≤ 9
true

julia> "abc" ≤ "abc"
true

julia> 5 <= 3
false

source

<=(x)

Erstellen Sie eine Funktion, die ihr Argument mit x unter Verwendung von <= vergleicht, d.h. eine Funktion, die äquivalent zu y -> y <= x ist. Die zurückgegebene Funktion ist vom Typ Base.Fix2{typeof(<=)}, die verwendet werden kann, um spezialisierte Methoden zu implementieren.

Julia 1.2

Diese Funktionalität erfordert mindestens Julia 1.2.

source

Base.:> — Function

>(x, y)

Größer-als-Vergleichsoperator. Fällt zurück auf y < x.

Implementierung

Im Allgemeinen sollten neue Typen < anstelle dieser Funktion implementieren und sich auf die Rückfalldefinition >(x, y) = y < x verlassen.

Beispiele

julia> 'a' > 'b'
false

julia> 7 > 3 > 1
true

julia> "abc" > "abd"
false

julia> 5 > 3
true

source

>(x)

Erstellen Sie eine Funktion, die ihr Argument mit x unter Verwendung von > vergleicht, d.h. eine Funktion, die äquivalent zu y -> y > x ist. Die zurückgegebene Funktion hat den Typ Base.Fix2{typeof(>)}, der verwendet werden kann, um spezialisierte Methoden zu implementieren.

Julia 1.2

Diese Funktionalität erfordert mindestens Julia 1.2.

source

Base.:>= — Function

>=(x, y)
≥(x,y)

Größer-als-oder-gleich Vergleichsoperator. Fällt zurück auf y <= x.

Beispiele

julia> 'a' >= 'b'
false

julia> 7 ≥ 7 ≥ 3
true

julia> "abc" ≥ "abc"
true

julia> 5 >= 3
true

source

>=(x)

Erstellen Sie eine Funktion, die ihr Argument mit x unter Verwendung von >= vergleicht, d.h. eine Funktion, die äquivalent zu y -> y >= x ist. Die zurückgegebene Funktion ist vom Typ Base.Fix2{typeof(>=)}, die verwendet werden kann, um spezialisierte Methoden zu implementieren.

Julia 1.2

Diese Funktionalität erfordert mindestens Julia 1.2.

source

Base.cmp — Function

cmp(x,y)

Gibt -1, 0 oder 1 zurück, je nachdem, ob x kleiner, gleich oder größer als y ist. Verwendet die totale Ordnung, die durch isless implementiert ist.

Beispiele

julia> cmp(1, 2)
-1

julia> cmp(2, 1)
1

julia> cmp(2+im, 3-im)
ERROR: MethodError: no method matching isless(::Complex{Int64}, ::Complex{Int64})
[...]

source

cmp(<, x, y)

Gibt -1, 0 oder 1 zurück, je nachdem, ob x kleiner, gleich oder größer als y ist. Das erste Argument gibt eine Funktion für den Vergleich "kleiner als" an, die verwendet werden soll.

source

cmp(a::AbstractString, b::AbstractString) -> Int

Vergleiche zwei Strings. Gib 0 zurück, wenn beide Strings die gleiche Länge haben und das Zeichen an jedem Index in beiden Strings gleich ist. Gib -1 zurück, wenn a ein Präfix von b ist oder wenn a alphabetisch vor b kommt. Gib 1 zurück, wenn b ein Präfix von a ist oder wenn b alphabetisch vor a kommt (technisch gesehen, lexikografische Reihenfolge nach Unicode-Codepunkten).

Beispiele

julia> cmp("abc", "abc")
0

julia> cmp("ab", "abc")
-1

julia> cmp("abc", "ab")
1

julia> cmp("ab", "ac")
-1

julia> cmp("ac", "ab")
1

julia> cmp("α", "a")
1

julia> cmp("b", "β")
-1

source

Base.:~ — Function

~(x)

Bitweises Nicht.

Siehe auch: !, &, |.

Beispiele

julia> ~4
-5

julia> ~10
-11

julia> ~true
false

source

Base.:& — Function

x & y

Bitweises und. Implementiert dreiwertige Logik, gibt missing zurück, wenn ein Operand missing ist und der andere true. Fügen Sie Klammern für die Funktionsanwendungsform hinzu: (&)(x, y).

Siehe auch: |, xor, &&.

Beispiele

julia> 4 & 10
0

julia> 4 & 12
4

julia> true & missing
missing

julia> false & missing
false

source

Base.:| — Function

x | y

Bitweises Oder. Implementiert dreiwertige Logik, gibt missing zurück, wenn ein Operand missing und der andere false ist.

Siehe auch: &, xor, ||.

Beispiele

julia> 4 | 10
14

julia> 4 | 1
5

julia> true | missing
true

julia> false | missing
missing

source

Base.xor — Function

xor(x, y)
⊻(x, y)

Bitweises exklusives Oder von x und y. Implementiert dreiwertige Logik, gibt missing zurück, wenn eines der Argumente missing ist.

Die Infix-Operation a ⊻ b ist ein Synonym für xor(a,b), und ⊻ kann durch Tab-Vervollständigung von \xor oder \veebar in der Julia REPL eingegeben werden.

Beispiele

julia> xor(true, false)
true

julia> xor(true, true)
false

julia> xor(true, missing)
missing

julia> false ⊻ false
false

julia> [true; true; false] .⊻ [true; false; false]
3-element BitVector:
 0
 1
 0

source

Base.nand — Function

nand(x, y)
⊼(x, y)

Bitweises nand (nicht und) von x und y. Implementiert dreiwertige Logik, gibt missing zurück, wenn eines der Argumente missing ist.

Die Infix-Operation a ⊼ b ist ein Synonym für nand(a,b), und ⊼ kann durch Tab-Vervollständigung von \nand oder \barwedge in der Julia REPL eingegeben werden.

Beispiele

julia> nand(true, false)
true

julia> nand(true, true)
false

julia> nand(true, missing)
missing

julia> false ⊼ false
true

julia> [true; true; false] .⊼ [true; false; false]
3-element BitVector:
 0
 1
 1

source

Base.nor — Function

nor(x, y)
⊽(x, y)

Bitweises nor (nicht oder) von x und y. Implementiert dreiwertige Logik, gibt missing zurück, wenn eines der Argumente missing ist und das andere nicht true.

Die Infix-Operation a ⊽ b ist ein Synonym für nor(a,b), und ⊽ kann durch Tab-Vervollständigung von \nor oder \barvee in der Julia REPL eingegeben werden.

Beispiele

julia> nor(true, false)
false

julia> nor(true, true)
false

julia> nor(true, missing)
false

julia> false ⊽ false
true

julia> false ⊽ missing
missing

julia> [true; true; false] .⊽ [true; false; false]
3-element BitVector:
 0
 0
 1

source

Base.:! — Function

!(x)

Boolesches Nicht. Implementiert dreiwertige Logik, gibt missing zurück, wenn x missing ist.

Siehe auch ~ für bitweises Nicht.

Beispiele

julia> !true
false

julia> !false
true

julia> !missing
missing

julia> .![true false true]
1×3 BitMatrix:
 0  1  0

source

!f::Funktion

Prädikatfunktion Negation: Wenn das Argument von ! eine Funktion ist, gibt es eine zusammengesetzte Funktion zurück, die die boolesche Negation von f berechnet.

Siehe auch ∘.

Beispiele

julia> str = "∀ ε > 0, ∃ δ > 0: |x-y| < δ ⇒ |f(x)-f(y)| < ε"
"∀ ε > 0, ∃ δ > 0: |x-y| < δ ⇒ |f(x)-f(y)| < ε"

julia> filter(isletter, str)
"εδxyδfxfyε"

julia> filter(!isletter, str)
"∀  > 0, ∃  > 0: |-| <  ⇒ |()-()| < "

Julia 1.9

Ab Julia 1.9 gibt !f eine ComposedFunction zurück, anstatt einer anonymen Funktion.

source

&& — Keyword

x && y

Kurzschluss-Boolean-UND.

Siehe auch &, den ternären Operator ? : und den Handbuchabschnitt über Kontrollfluss.

Beispiele

julia> x = 3;

julia> x > 1 && x < 10 && x isa Int
true

julia> x < 0 && error("erwartetes positives x")
false

source

|| — Keyword

x || y

Kurzschluss-Boolean-ODER.

Siehe auch: |, xor, &&.

Beispiele

julia> pi < 3 || ℯ < 3
true

julia> false || true || println("keines ist wahr!")
true

source

Mathematical Functions

Base.isapprox — Function

isapprox(x, y; atol::Real=0, rtol::Real=atol>0 ? 0 : √eps, nans::Bool=false[, norm::Function])

Ungenaue Gleichheitsvergleiche. Zwei Zahlen vergleichen sich gleich, wenn ihre relative Distanz oder ihre absolute Distanz innerhalb der Toleranzgrenzen liegt: isapprox gibt true zurück, wenn norm(x-y) <= max(atol, rtol*max(norm(x), norm(y))). Der Standardwert für atol (absolute Toleranz) ist null und der Standardwert für rtol (relative Toleranz) hängt von den Typen von x und y ab. Das Schlüsselwortargument nans bestimmt, ob NaN-Werte als gleich betrachtet werden oder nicht (Standardwert ist false).

Für reale oder komplexe Gleitkommawerte, wenn kein atol > 0 angegeben ist, ist der Standardwert für rtol die Quadratwurzel von eps des Typs von x oder y, je nachdem, welcher größer ist (am wenigsten präzise). Dies entspricht der Anforderung, dass etwa die Hälfte der signifikanten Ziffern gleich sein muss. Andernfalls, z. B. für ganzzahlige Argumente oder wenn ein atol > 0 angegeben ist, ist der Standardwert für rtol null.

Das Schlüsselwort norm hat standardmäßig abs für numerische (x,y) und LinearAlgebra.norm für Arrays (wo eine alternative norm-Wahl manchmal nützlich ist). Wenn x und y Arrays sind, fällt der Vergleich zurück auf die Überprüfung, ob alle Elemente von x und y komponentenweise ungefähr gleich sind, wennnorm(x-y)nicht endlich ist (d. h.±InfoderNaN`).

Der binäre Operator ≈ ist äquivalent zu isapprox mit den Standardargumenten, und x ≉ y ist äquivalent zu !isapprox(x,y).

Beachten Sie, dass x ≈ 0 (d. h. der Vergleich mit null unter den Standardtoleranzen) äquivalent zu x == 0 ist, da der Standardwert für atol 0 ist. In solchen Fällen sollten Sie entweder eine geeignete atol angeben (oder norm(x) ≤ atol verwenden) oder Ihren Code umstellen (z. B. x ≈ y anstelle von x - y ≈ 0 verwenden). Es ist nicht möglich, automatisch eine von null verschiedene atol auszuwählen, da sie von der gesamten Skalierung (den "Einheiten") Ihres Problems abhängt: Zum Beispiel ist in x - y ≈ 0 atol=1e-9 eine absurd kleine Toleranz, wenn x der Radius der Erde in Metern ist, aber eine absurd große Toleranz, wenn x der Radius eines Wasserstoffatoms in Metern ist.

Julia 1.6

Das Übergeben des Schlüsselwortarguments norm beim Vergleichen numerischer (nicht-array) Argumente erfordert Julia 1.6 oder höher.

Beispiele

julia> isapprox(0.1, 0.15; atol=0.05)
true

julia> isapprox(0.1, 0.15; rtol=0.34)
true

julia> isapprox(0.1, 0.15; rtol=0.33)
false

julia> 0.1 + 1e-10 ≈ 0.1
true

julia> 1e-10 ≈ 0
false

julia> isapprox(1e-10, 0, atol=1e-8)
true

julia> isapprox([10.0^9, 1.0], [10.0^9, 2.0]) # using `norm`
true

source

isapprox(x; kwargs...) / ≈(x; kwargs...)

Erstellen Sie eine Funktion, die ihr Argument mit x unter Verwendung von ≈ vergleicht, d.h. eine Funktion, die äquivalent zu y -> y ≈ x ist.

Die unterstützten Schlüsselwortargumente sind die gleichen wie die in der 2-Argumente isapprox.

Julia 1.5

Diese Methode erfordert Julia 1.5 oder später.

source

Base.sin — Method

sin(x)

Berechne den Sinus von x, wobei x in Bogenmaß ist.

Siehe auch sind, sinpi, sincos, cis, asin.

Beispiele

julia> round.(sin.(range(0, 2pi, length=9)'), digits=3)
1×9 Matrix{Float64}:
 0.0  0.707  1.0  0.707  0.0  -0.707  -1.0  -0.707  -0.0

julia> sind(45)
0.7071067811865476

julia> sinpi(1/4)
0.7071067811865475

julia> round.(sincos(pi/6), digits=3)
(0.5, 0.866)

julia> round(cis(pi/6), digits=3)
0.866 + 0.5im

julia> round(exp(im*pi/6), digits=3)
0.866 + 0.5im

source

Base.cos — Method

cos(x)

Berechne den Kosinus von x, wobei x in Bogenmaß ist.

Siehe auch cosd, cospi, sincos, cis.

source

Base.Math.sincos — Method

sincos(x)

Berechnet gleichzeitig den Sinus und Kosinus von x, wobei x in Bogenmaß ist, und gibt ein Tupel (sinus, kosinus) zurück.

Siehe auch cis, sincospi, sincosd.

source

Base.tan — Method

tan(x)

Berechne den Tangens von x, wobei x in Bogenmaß ist.

source

Base.Math.sind — Function

sind(x)

Berechne den Sinus von x, wobei x in Grad ist. Wenn x eine Matrix ist, muss x eine quadratische Matrix sein.

Julia 1.7

Matrixargumente erfordern Julia 1.7 oder höher.

source

Base.Math.cosd — Function

cosd(x)

Berechne den Kosinus von x, wobei x in Grad ist. Wenn x eine Matrix ist, muss x eine quadratische Matrix sein.

Julia 1.7

Matrixargumente erfordern Julia 1.7 oder höher.

source

Base.Math.tand — Function

tand(x)

Berechne den Tangens von x, wobei x in Grad ist. Wenn x eine Matrix ist, muss x eine quadratische Matrix sein.

Julia 1.7

Matrixargumente erfordern Julia 1.7 oder höher.

source

Base.Math.sincosd — Function

sincosd(x)

Berechne gleichzeitig den Sinus und Kosinus von x, wobei x in Grad angegeben ist.

Julia 1.3

Diese Funktion erfordert mindestens Julia 1.3.

source

Base.Math.sinpi — Function

sinpi(x)

Berechne $\sin(\pi x)$ genauer als sin(pi*x), insbesondere für große x.

Siehe auch sind, cospi, sincospi.

source

Base.Math.cospi — Function

cospi(x)

Berechne $\cos(\pi x)$ genauer als cos(pi*x), insbesondere für große x.

source

Base.Math.tanpi — Function

tanpi(x)

Berechne $\tan(\pi x)$ genauer als tan(pi*x), insbesondere für große x.

Julia 1.10

Diese Funktion erfordert mindestens Julia 1.10.

Siehe auch tand, sinpi, cospi, sincospi.

source

Base.Math.sincospi — Function

sincospi(x)

Berechnet gleichzeitig sinpi(x) und cospi(x) (den Sinus und Kosinus von π*x, wobei x in Bogenmaß ist) und gibt ein Tupel (sinus, kosinus) zurück.

Julia 1.6

Diese Funktion erfordert Julia 1.6 oder höher.

Siehe auch: cispi, sincosd, sinpi.

source

Base.sinh — Method

sinh(x)

Berechne den hyperbolischen Sinus von x.

source

Base.cosh — Method

cosh(x)

Berechne den hyperbolischen Kosinus von x.

source

Base.tanh — Method

tanh(x)

Berechne den hyperbolischen Tangens von x.

Siehe auch tan, atanh.

Beispiele

julia> tanh.(-3:3f0)  # Hier ist 3f0 ein Float32
7-element Vector{Float32}:
 -0.9950548
 -0.9640276
 -0.7615942
  0.0
  0.7615942
  0.9640276
  0.9950548

julia> tan.(im .* (1:3))
3-element Vector{ComplexF64}:
 0.0 + 0.7615941559557649im
 0.0 + 0.9640275800758169im
 0.0 + 0.9950547536867306im

source

Base.asin — Method

asin(x)

Berechne den inversen Sinus von x, wobei die Ausgabe in Bogenmaß erfolgt.

Siehe auch asind für die Ausgabe in Grad.

Beispiele

julia> asin.((0, 1/2, 1))
(0.0, 0.5235987755982989, 1.5707963267948966)

julia> asind.((0, 1/2, 1))
(0.0, 30.000000000000004, 90.0)

source

Base.acos — Method

acos(x)

Berechne den inversen Kosinus von x, wobei die Ausgabe in Bogenmaß erfolgt.

source

Base.atan — Method

atan(y)
atan(y, x)

Berechne den inversen Tangens von y oder y/x, jeweils.

Für ein reales Argument ist dies der Winkel in Bogenmaß zwischen der positiven x-Achse und dem Punkt (1, y), wobei ein Wert im Intervall $[-\pi/2, \pi/2]$ zurückgegeben wird.

Für zwei Argumente ist dies der Winkel in Bogenmaß zwischen der positiven x-Achse und dem Punkt (x, y), wobei ein Wert im Intervall $[-\pi, \pi]$ zurückgegeben wird. Dies entspricht einer standardmäßigen atan2 Funktion. Beachte, dass konventionell atan(0.0,x) als $\pi$ definiert ist und atan(-0.0,x) als $-\pi$, wenn x < 0.

Siehe auch atand für Grad.

Beispiele

julia> rad2deg(atan(-1/√3))
-30.000000000000004

julia> rad2deg(atan(-1, √3))
-30.000000000000004

julia> rad2deg(atan(1, -√3))
150.0

source

Base.Math.asind — Function

asind(x)

Berechne den inversen Sinus von x, wobei die Ausgabe in Grad erfolgt. Wenn x eine Matrix ist, muss x eine quadratische Matrix sein.

Julia 1.7

Matrixargumente erfordern Julia 1.7 oder höher.

source

Base.Math.acosd — Function

acosd(x)

Berechne den inversen Kosinus von x, wobei die Ausgabe in Grad erfolgt. Wenn x eine Matrix ist, muss x eine quadratische Matrix sein.

Julia 1.7

Matrixargumente erfordern Julia 1.7 oder höher.

source

Base.Math.atand — Function

atand(y)
atand(y,x)

Berechne den inversen Tangens von y oder y/x, jeweils, wobei die Ausgabe in Grad erfolgt.

Julia 1.7

Die Methode mit einem Argument unterstützt ab Julia 1.7 quadratische Matrixargumente.

source

Base.Math.sec — Method

sec(x)

Berechne die Sekante von x, wobei x in Bogenmaß ist.

source

Base.Math.csc — Method

csc(x)

Berechne die Kosekans von x, wobei x in Bogenmaß ist.

source

Base.Math.cot — Method

cot(x)

Berechne den Kotangens von x, wobei x in Bogenmaß ist.

source

Base.Math.secd — Function

secd(x)

Berechne die Sekante von x, wobei x in Grad ist.

source

Base.Math.cscd — Function

cscd(x)

Berechne die Kosekans von x, wobei x in Grad ist.

source

Base.Math.cotd — Function

cotd(x)

Berechne den Kotangens von x, wobei x in Grad ist.

source

Base.Math.asec — Method

asec(x)

Berechne den inversen Sekanten von x, wobei die Ausgabe in Bogenmaß erfolgt.

source

Base.Math.acsc — Method

acsc(x)

Berechne den inversen Kosekans von x, wobei die Ausgabe in Bogenmaß erfolgt.

source

Base.Math.acot — Method

acot(x)

Berechne den inversen Kotangens von x, wobei die Ausgabe in Bogenmaß erfolgt.

source

Base.Math.asecd — Function

asecd(x)

Berechne den inversen Sekanten von x, wobei die Ausgabe in Grad erfolgt. Wenn x eine Matrix ist, muss x eine quadratische Matrix sein.

Julia 1.7

Matrixargumente erfordern Julia 1.7 oder höher.

source

Base.Math.acscd — Function

acscd(x)

Berechne den inversen Kosekans von x, wobei die Ausgabe in Grad erfolgt. Wenn x eine Matrix ist, muss x eine quadratische Matrix sein.

Julia 1.7

Matrixargumente erfordern Julia 1.7 oder höher.

source

Base.Math.acotd — Function

acotd(x)

Berechne den inversen Kotangens von x, wobei die Ausgabe in Grad erfolgt. Wenn x eine Matrix ist, muss x eine quadratische Matrix sein.

Julia 1.7

Matrixargumente erfordern Julia 1.7 oder höher.

source

Base.Math.sech — Method

sech(x)

Berechne die hyperbolische Sekante von x.

source

Base.Math.csch — Method

csch(x)

Berechne die hyperbolische Kosekans von x.

source

Base.Math.coth — Method

coth(x)

Berechne den hyperbolischen Kotangens von x.

source

Base.asinh — Method

asinh(x)

Berechne den inversen hyperbolischen Sinus von x.

source

Base.acosh — Method

acosh(x)

Berechne den inversen hyperbolischen Kosinus von x.

source

Base.atanh — Method

atanh(x)

Berechne den inversen hyperbolischen Tangens von x.

source

Base.Math.asech — Method

asech(x)

Berechne den inversen hyperbolischen Sekanten von x.

source

Base.Math.acsch — Method

acsch(x)

Berechne den inversen hyperbolischen Kosekans von x.

source

Base.Math.acoth — Method

acoth(x)

Berechne den inversen hyperbolischen Kotangens von x.

source

Base.Math.sinc — Function

sinc(x)

Berechne die normalisierte Sinc-Funktion $\operatorname{sinc}(x) = \sin(\pi x) / (\pi x)$, wenn $x \neq 0$, und $1$, wenn $x = 0$.

Siehe auch cosc, ihre Ableitung.

source

Base.Math.cosc — Function

cosc(x)

Berechne $\cos(\pi x) / x - \sin(\pi x) / (\pi x^2)$, wenn $x \neq 0$, und $0$, wenn $x = 0$. Dies ist die Ableitung von sinc(x).

Siehe auch sinc.

source

Base.Math.deg2rad — Function

deg2rad(x)

Konvertiere x von Grad in Bogenmaß.

Siehe auch rad2deg, sind, pi.

Beispiele

julia> deg2rad(90)
1.5707963267948966

source

Base.Math.rad2deg — Function

rad2deg(x)

Konvertiere x von Bogenmaß in Grad.

Siehe auch deg2rad.

Beispiele

julia> rad2deg(pi)
180.0

source

Base.Math.hypot — Function

hypot(x, y)

Berechne die Hypotenuse $\sqrt{|x|^2+|y|^2}$ und vermeide Überlauf und Unterlauf.

Dieser Code ist eine Implementierung des Algorithmus, der in: An Improved Algorithm for hypot(a,b) von Carlos F. Borges beschrieben ist. Der Artikel ist online auf arXiv unter dem Link https://arxiv.org/abs/1904.09481 verfügbar.

hypot(x...)

Berechne die Hypotenuse $\sqrt{\sum |x_i|^2}$ und vermeide Überlauf und Unterlauf.

Siehe auch norm in der LinearAlgebra Standardbibliothek.

Beispiele

julia> a = Int64(10)^10;

julia> hypot(a, a)
1.4142135623730951e10

julia> √(a^2 + a^2) # a^2 überläuft
ERROR: DomainError with -2.914184810805068e18:
sqrt wurde mit einem negativen reellen Argument aufgerufen, gibt aber nur ein komplexes Ergebnis zurück, wenn es mit einem komplexen Argument aufgerufen wird. Versuche sqrt(Complex(x)).
Stacktrace:
[...]

julia> hypot(3, 4im)
5.0

julia> hypot(-5.7)
5.7

julia> hypot(3, 4im, 12.0)
13.0

julia> using LinearAlgebra

julia> norm([a, a, a, a]) == hypot(a, a, a, a)
true

source

Base.log — Method

log(x)

Berechnet den natürlichen Logarithmus von x.

Wirft DomainError für negative Real Argumente. Verwenden Sie komplexe Argumente, um komplexe Ergebnisse zu erhalten. Hat einen Astschnitt entlang der negativen reellen Achse, für den -0.0im als unterhalb der Achse betrachtet wird.

Siehe auch ℯ, log1p, log2, log10.

Beispiele

julia> log(2)
0.6931471805599453

julia> log(-3)
ERROR: DomainError with -3.0:
log wurde mit einem negativen reellen Argument aufgerufen, gibt jedoch nur ein komplexes Ergebnis zurück, wenn es mit einem komplexen Argument aufgerufen wird. Versuchen Sie log(Complex(x)).
Stacktrace:
 [1] throw_complex_domainerror(::Symbol, ::Float64) at ./math.jl:31
[...]

julia> log(-3 + 0im)
1.0986122886681098 + 3.141592653589793im

julia> log(-3 - 0.0im)
1.0986122886681098 - 3.141592653589793im

julia> log.(exp.(-1:1))
3-element Vector{Float64}:
 -1.0
  0.0
  1.0

source

Base.log — Method

log(b,x)

Berechnet den Logarithmus von x zur Basis b. Wirft DomainError für negative Real Argumente.

Beispiele

julia> log(4,8)
1.5

julia> log(4,2)
0.5

julia> log(-2, 3)
ERROR: DomainError mit -2.0:
log wurde mit einem negativen reellen Argument aufgerufen, gibt jedoch nur ein komplexes Ergebnis zurück, wenn es mit einem komplexen Argument aufgerufen wird. Versuchen Sie log(Complex(x)).
Stacktrace:
 [1] throw_complex_domainerror(::Symbol, ::Float64) at ./math.jl:31
[...]

julia> log(2, -3)
ERROR: DomainError mit -3.0:
log wurde mit einem negativen reellen Argument aufgerufen, gibt jedoch nur ein komplexes Ergebnis zurück, wenn es mit einem komplexen Argument aufgerufen wird. Versuchen Sie log(Complex(x)).
Stacktrace:
 [1] throw_complex_domainerror(::Symbol, ::Float64) at ./math.jl:31
[...]

Note

Wenn b eine Potenz von 2 oder 10 ist, sollten log2 oder log10 verwendet werden, da diese typischerweise schneller und genauer sind. Zum Beispiel,

julia> log(100,1000000)
2.9999999999999996

julia> log10(1000000)/2
3.0

source

Base.log2 — Function

log2(x)

Berechnet den Logarithmus von x zur Basis 2. Wirft DomainError für negative Real Argumente.

Siehe auch: exp2, ldexp, ispow2.

Beispiele

julia> log2(4)
2.0

julia> log2(10)
3.321928094887362

julia> log2(-2)
ERROR: DomainError mit -2.0:
log2 wurde mit einem negativen reellen Argument aufgerufen, gibt aber nur ein komplexes Ergebnis zurück, wenn es mit einem komplexen Argument aufgerufen wird. Versuchen Sie log2(Complex(x)).
Stacktrace:
 [1] throw_complex_domainerror(f::Symbol, x::Float64) at ./math.jl:31
[...]

julia> log2.(2.0 .^ (-1:1))
3-element Vector{Float64}:
 -1.0
  0.0
  1.0

source

Base.log10 — Function

log10(x)

Berechne den Logarithmus von x zur Basis 10. Wirft DomainError für negative Real Argumente.

Beispiele

julia> log10(100)
2.0

julia> log10(2)
0.3010299956639812

julia> log10(-2)
ERROR: DomainError mit -2.0:
log10 wurde mit einem negativen reellen Argument aufgerufen, gibt aber nur ein komplexes Ergebnis zurück, wenn es mit einem komplexen Argument aufgerufen wird. Versuche log10(Complex(x)).
Stacktrace:
 [1] throw_complex_domainerror(f::Symbol, x::Float64) at ./math.jl:31
[...]

source

Base.log1p — Function

log1p(x)

Genauer natürlicher Logarithmus von 1+x. Wirft DomainError für Real Argumente kleiner als -1.

Beispiele

julia> log1p(-0.5)
-0.6931471805599453

julia> log1p(0)
0.0

julia> log1p(-2)
ERROR: DomainError mit -2.0:
log1p wurde mit einem reellen Argument < -1 aufgerufen, gibt aber nur ein komplexes Ergebnis zurück, wenn es mit einem komplexen Argument aufgerufen wird. Versuchen Sie log1p(Complex(x)).
Stacktrace:
 [1] throw_complex_domainerror(::Symbol, ::Float64) at ./math.jl:31
[...]

source

Base.Math.frexp — Function

frexp(val)

Gibt (x,exp) zurück, so dass x eine Größe im Intervall $[1/2, 1)$ oder 0 hat, und val gleich $x \times 2^{exp}$ ist.

Siehe auch significand, exponent, ldexp.

Beispiele

julia> frexp(6.0)
(0.75, 3)

julia> significand(6.0), exponent(6.0)  # Intervall [1, 2) stattdessen
(1.5, 2)

julia> frexp(0.0), frexp(NaN), frexp(-Inf)  # Exponent würde einen Fehler geben
((0.0, 0), (NaN, 0), (-Inf, 0))

source

Base.exp — Method

exp(x)

Berechne die natürliche Basisexponentialfunktion von x, mit anderen Worten $ℯ^x$.

Siehe auch exp2, exp10 und cis.

Beispiele

julia> exp(1.0)
2.718281828459045

julia> exp(im * pi) ≈ cis(pi)
true

source

Base.exp2 — Function

exp2(x)

Berechne die Basis-2-Exponentialfunktion von x, mit anderen Worten $2^x$.

Siehe auch ldexp, <<.

Beispiele

julia> exp2(5)
32.0

julia> 2^5
32

julia> exp2(63) > typemax(Int)
true

source

Base.exp10 — Function

exp10(x)

Berechne die Basis 10 Exponentialfunktion von x, mit anderen Worten $10^x$.

Beispiele

julia> exp10(2)
100.0

julia> 10^2
100

source

Base.Math.ldexp — Function

ldexp(x, n)

Berechne $x \times 2^n$.

Siehe auch frexp, exponent.

Beispiele

julia> ldexp(5.0, 2)
20.0

source

Base.Math.modf — Function

modf(x)

Gibt ein Tupel (fpart, ipart) der Bruch- und Ganzzahlteile einer Zahl zurück. Beide Teile haben das gleiche Vorzeichen wie das Argument.

Beispiele

julia> modf(3.5)
(0.5, 3.0)

julia> modf(-3.5)
(-0.5, -3.0)

source

Base.expm1 — Function

expm1(x)

Berechnet genau $e^x-1$. Es vermeidet den Verlust an Präzision, der bei der direkten Auswertung von exp(x)-1 für kleine Werte von x auftritt.

Beispiele

julia> expm1(1e-16)
1.0e-16

julia> exp(1e-16) - 1
0.0

source

Base.round — Function

round([T,] x, [r::RoundingMode])
round(x, [r::RoundingMode]; digits::Integer=0, base = 10)
round(x, [r::RoundingMode]; sigdigits::Integer, base = 10)

Rundet die Zahl x.

Ohne Schlüsselwortargumente wird x auf einen ganzzahligen Wert gerundet, wobei ein Wert vom Typ T zurückgegeben wird, oder vom gleichen Typ wie x, wenn kein T angegeben ist. Ein InexactError wird ausgelöst, wenn der Wert nicht durch T darstellbar ist, ähnlich wie bei convert.

Wenn das Schlüsselwortargument digits angegeben ist, wird auf die angegebene Anzahl von Ziffern nach dem Dezimalpunkt (oder davor, wenn negativ) in der Basis base gerundet.

Wenn das Schlüsselwortargument sigdigits angegeben ist, wird auf die angegebene Anzahl von signifikanten Ziffern in der Basis base gerundet.

Der RoundingMode r steuert die Richtung des Rundens; der Standard ist RoundNearest, das auf die nächste ganze Zahl rundet, wobei bei Gleichständen (Bruchwerte von 0.5) auf die nächste gerade ganze Zahl gerundet wird. Beachten Sie, dass round falsche Ergebnisse liefern kann, wenn der globale Rundungsmodus geändert wird (siehe rounding).

Beim Runden auf einen Fließkommatyp wird auf ganze Zahlen gerundet, die von diesem Typ (und Inf) darstellbar sind, anstatt auf echte ganze Zahlen. Inf wird als eine ulp größer als das floatmax(T) behandelt, um "nächste" zu bestimmen, ähnlich wie bei convert.

Beispiele

julia> round(1.7)
2.0

julia> round(Int, 1.7)
2

julia> round(1.5)
2.0

julia> round(2.5)
2.0

julia> round(pi; digits=2)
3.14

julia> round(pi; digits=3, base=2)
3.125

julia> round(123.456; sigdigits=2)
120.0

julia> round(357.913; sigdigits=4, base=2)
352.0

julia> round(Float16, typemax(UInt128))
Inf16

julia> floor(Float16, typemax(UInt128))
Float16(6.55e4)

!!! Hinweis Das Runden auf angegebene Ziffern in Basen, die nicht 2 sind, kann ungenau sein, wenn mit binären Fließkommazahlen gearbeitet wird. Zum Beispiel ist der Float64 Wert, der durch 1.15 dargestellt wird, tatsächlich weniger als 1.15, wird jedoch auf 1.2 gerundet. Zum Beispiel:

    julia> x = 1.15
    1.15

    julia> big(1.15)
    1.149999999999999911182158029987476766109466552734375

    julia> x < 115//100
    true

    julia> round(x, digits=1)
    1.2
    ```


# Erweiterungen

Um `round` auf neue numerische Typen zu erweitern, ist es typischerweise ausreichend, `Base.round(x::NewType, r::RoundingMode)` zu definieren.

source

Base.Rounding.RoundingMode — Type

RoundingMode

Ein Typ, der verwendet wird, um den Rundungsmodus von Gleitkommaoperationen (über die Funktionen rounding/setrounding) zu steuern, oder als optionale Argumente für das Runden auf die nächste ganze Zahl (über die Funktion round).

Derzeit unterstützte Rundungsmodi sind:

Julia 1.9

RoundFromZero erfordert mindestens Julia 1.9. Frühere Versionen unterstützen RoundFromZero nur für BigFloats.

source

Base.Rounding.RoundNearest — Constant

RoundNearest

Der Standard-Rundungsmodus. Rundet auf die nächste ganze Zahl, wobei bei Gleichständen (Bruchwerte von 0,5) auf die nächste gerade Zahl gerundet wird.

source

Base.Rounding.RoundNearestTiesAway — Constant

RoundNearestTiesAway

Rundet auf die nächste ganze Zahl, wobei bei Gleichständen von null weg gerundet wird (C/C++ round Verhalten).

source

Base.Rounding.RoundNearestTiesUp — Constant

RoundNearestTiesUp

Rundet auf die nächste ganze Zahl, wobei bei Gleichständen auf positive Unendlichkeit gerundet wird (Verhalten von Java/JavaScript round).

source

Base.Rounding.RoundToZero — Constant

RundenZuNull

round unter Verwendung dieses Rundungsmodus ist ein Alias für trunc.

source

Base.Rounding.RoundFromZero — Constant

RoundFromZero

Rundet von null weg.

Julia 1.9

RoundFromZero erfordert mindestens Julia 1.9. Frühere Versionen unterstützen RoundFromZero nur für BigFloats.

Beispiele

julia> BigFloat("1.0000000000000001", 5, RoundFromZero)
1.06

source

Base.Rounding.RoundUp — Constant

RoundUp

round unter Verwendung dieses Rundungsmodus ist ein Alias für ceil.

source

Base.Rounding.RoundDown — Constant

RundenNachUnten

round mit diesem Rundungsmodus ist ein Alias für floor.

source

Base.round — Method

round(z::Complex[, RoundingModeReal, [RoundingModeImaginary]])
round(z::Complex[, RoundingModeReal, [RoundingModeImaginary]]; digits=0, base=10)
round(z::Complex[, RoundingModeReal, [RoundingModeImaginary]]; sigdigits, base=10)

Gibt den nächstgelegenen ganzzahligen Wert des gleichen Typs wie der komplexe Wert z zurück, wobei bei Gleichständen die angegebenen RoundingModes verwendet werden. Der erste RoundingMode wird zum Runden der reellen Komponenten verwendet, während der zweite zum Runden der imaginären Komponenten verwendet wird.

RoundingModeReal und RoundingModeImaginary standardmäßig auf RoundNearest, das auf die nächste ganze Zahl rundet, wobei Gleichstände (Bruchwerte von 0,5) auf die nächste gerade ganze Zahl gerundet werden.

Beispiele

julia> round(3.14 + 4.5im)
3.0 + 4.0im

julia> round(3.14 + 4.5im, RoundUp, RoundNearestTiesUp)
4.0 + 5.0im

julia> round(3.14159 + 4.512im; digits = 1)
3.1 + 4.5im

julia> round(3.14159 + 4.512im; sigdigits = 3)
3.14 + 4.51im

source

Base.ceil — Function

ceil([T,] x)
ceil(x; digits::Integer= [, basis = 10])
ceil(x; sigdigits::Integer= [, basis = 10])

ceil(x) gibt den nächstgelegenen ganzzahligen Wert des gleichen Typs wie x zurück, der größer oder gleich x ist.

ceil(T, x) konvertiert das Ergebnis in den Typ T und wirft einen InexactError, wenn der gerundete Wert nicht als T darstellbar ist.

Die Schlüsselwörter digits, sigdigits und basis funktionieren wie bei round.

Um ceil für einen neuen Typ zu unterstützen, definiere Base.round(x::NewType, ::RoundingMode{:Up}).

source

Base.floor — Function

floor([T,] x)
floor(x; digits::Integer= [, basis = 10])
floor(x; sigdigits::Integer= [, basis = 10])

floor(x) gibt den nächstgelegenen ganzzahligen Wert des gleichen Typs wie x zurück, der kleiner oder gleich x ist.

floor(T, x) konvertiert das Ergebnis in den Typ T und wirft einen InexactError, wenn der gerundete Wert nicht als T darstellbar ist.

Die Schlüsselwörter digits, sigdigits und basis funktionieren wie bei round.

Um floor für einen neuen Typ zu unterstützen, definiere Base.round(x::NewType, ::RoundingMode{:Down}).

source

Base.trunc — Function

trunc([T,] x)
trunc(x; digits::Integer= [, basis = 10])
trunc(x; sigdigits::Integer= [, basis = 10])

trunc(x) gibt den nächstgelegenen ganzzahligen Wert des gleichen Typs wie x zurück, dessen absoluter Wert kleiner oder gleich dem absoluten Wert von x ist.

trunc(T, x) konvertiert das Ergebnis in den Typ T und wirft einen InexactError, wenn der truncierte Wert nicht als T darstellbar ist.

Die Schlüsselwörter digits, sigdigits und basis funktionieren wie bei round.

Um trunc für einen neuen Typ zu unterstützen, definiere Base.round(x::NewType, ::RoundingMode{:ToZero}).

Siehe auch: %, floor, unsigned, unsafe_trunc.

Beispiele

julia> trunc(2.22)
2.0

julia> trunc(-2.22, digits=1)
-2.2

julia> trunc(Int, -2.22)
-2

source

Base.unsafe_trunc — Function

unsafe_trunc(T, x)

Gibt den nächstgelegenen ganzzahligen Wert des Typs T zurück, dessen absoluter Wert kleiner oder gleich dem absoluten Wert von x ist. Wenn der Wert nicht durch T darstellbar ist, wird ein willkürlicher Wert zurückgegeben. Siehe auch trunc.

Beispiele

julia> unsafe_trunc(Int, -2.2)
-2

julia> unsafe_trunc(Int, NaN)
-9223372036854775808

source

Base.min — Function

min(x, y, ...)

Gibt das Minimum der Argumente zurück, bezogen auf isless. Wenn eines der Argumente missing ist, wird missing zurückgegeben. Siehe auch die Funktion minimum, um das minimale Element aus einer Sammlung zu entnehmen.

Beispiele

julia> min(2, 5, 1)
1

julia> min(4, missing, 6)
missing

source

Base.max — Function

max(x, y, ...)

Gibt das Maximum der Argumente zurück, bezogen auf isless. Wenn eines der Argumente missing ist, wird missing zurückgegeben. Siehe auch die Funktion maximum, um das maximale Element aus einer Sammlung zu entnehmen.

Beispiele

julia> max(2, 5, 1)
5

julia> max(5, missing, 6)
missing

source

Base.minmax — Function

minmax(x, y)

Gibt (min(x,y), max(x,y)) zurück.

Siehe auch extrema, das (minimum(x), maximum(x)) zurückgibt.

Beispiele

julia> minmax('c','b')
('b', 'c')

source

Base.clamp — Function

clamp(x, lo, hi)

Gibt x zurück, wenn lo <= x <= hi. Wenn x > hi, wird hi zurückgegeben. Wenn x < lo, wird lo zurückgegeben. Die Argumente werden auf einen gemeinsamen Typ befördert.

Siehe auch clamp!, min, max.

Julia 1.3

missing als erstes Argument erfordert mindestens Julia 1.3.

Beispiele

julia> clamp.([pi, 1.0, big(10)], 2.0, 9.0)
3-element Vector{BigFloat}:
 3.141592653589793238462643383279502884197169399375105820974944592307816406286198
 2.0
 9.0

julia> clamp.([11, 8, 5], 10, 6)  # ein Beispiel, bei dem lo > hi
3-element Vector{Int64}:
  6
  6
 10

source

clamp(x, T)::T

Begrenze x zwischen typemin(T) und typemax(T) und konvertiere das Ergebnis in den Typ T.

Siehe auch trunc.

Beispiele

julia> clamp(200, Int8)
127

julia> clamp(-200, Int8)
-128

julia> trunc(Int, 4pi^2)
39

source

clamp(x::Integer, r::AbstractUnitRange)

Klemme x so, dass es im Bereich r liegt.

Julia 1.6

Diese Methode erfordert mindestens Julia 1.6.

source

Base.clamp! — Function

clamp!(array::AbstractArray, lo, hi)

Werte in array auf den angegebenen Bereich beschränken, in-place. Siehe auch clamp.

Julia 1.3

missing-Einträge in array erfordern mindestens Julia 1.3.

Beispiele

julia> row = collect(-4:4)';

julia> clamp!(row, 0, Inf)
1×9 adjoint(::Vector{Int64}) mit eltype Int64:
 0  0  0  0  0  1  2  3  4

julia> clamp.((-4:4)', 0, Inf)
1×9 Matrix{Float64}:
 0.0  0.0  0.0  0.0  0.0  1.0  2.0  3.0  4.0

source

Base.abs — Function

abs(x)

Der Betrag von x.

Wenn abs auf vorzeichenbehaftete Ganzzahlen angewendet wird, kann ein Überlauf auftreten, der zur Rückgabe eines negativen Wertes führt. Dieser Überlauf tritt nur auf, wenn abs auf den minimal darstellbaren Wert einer vorzeichenbehafteten Ganzzahl angewendet wird. Das heißt, wenn x == typemin(typeof(x)), dann ist abs(x) == x < 0, nicht -x, wie man erwarten könnte.

Siehe auch: abs2, unsigned, sign.

Beispiele

julia> abs(-3)
3

julia> abs(1 + im)
1.4142135623730951

julia> abs.(Int8[-128 -127 -126 0 126 127])  # Überlauf bei typemin(Int8)
1×6 Matrix{Int8}:
 -128  127  126  0  126  127

julia> maximum(abs, [1, -2, 3, -4])
4

source

Base.Checked — Module

Überprüft

Das Überprüft-Modul bietet arithmetische Funktionen für die integrierten vorzeichenbehafteten und vorzeichenlosen Ganzzahltypen, die einen Fehler auslösen, wenn ein Überlauf auftritt. Sie sind benannt wie checked_sub, checked_div usw. Darüber hinaus geben add_with_overflow, sub_with_overflow, mul_with_overflow sowohl die nicht überprüften Ergebnisse als auch einen booleschen Wert zurück, der das Vorhandensein eines Überlaufs anzeigt.

source

Base.Checked.checked_abs — Function

Base.checked_abs(x)

Berechnet abs(x) und überprüft auf Überlauf-Fehler, wo dies zutrifft. Zum Beispiel können standardmäßige vorzeichenbehaftete Ganzzahlen im Zweierkomplement (z. B. Int) abs(typemin(Int)) nicht darstellen, was zu einem Überlauf führt.