Numbers

Zahl

Abstrakte Superklasse für alle Zahlentypen.

Real <: Number

Abstrakte Oberklasse für alle reellen Zahlen.

AbstractFloat <: Real

Abstrakte Oberklasse für alle Gleitkommazahlen.

Integer <: Real

Abstrakte Oberklasse für alle Ganzzahlen (z. B. Signed, Unsigned und Bool).

Siehe auch isinteger, trunc, div.

Beispiele

julia> 42 isa Integer
true

julia> 1.0 isa Integer
false

julia> isinteger(1.0)
true

Signed <: Integer

Abstrakte Oberklasse für alle vorzeichenbehafteten Ganzzahlen.

Unsigned <: Integer

Abstrakte Oberklasse für alle unsigned Ganzzahlen.

Eingebaute unsigned Ganzzahlen werden in hexadezimaler Form mit dem Präfix 0x ausgegeben und können auf die gleiche Weise eingegeben werden.

Beispiele

julia> typemax(UInt8)
0xff

julia> Int(0x00d)
13

julia> unsigned(true)
0x0000000000000001

AbstractIrrational <: Real

Zahlentyp, der einen exakten irrationalen Wert darstellt, der in arithmetischen Operationen mit anderen numerischen Größen automatisch auf die richtige Präzision gerundet wird.

Untertypen MyIrrational <: AbstractIrrational sollten mindestens ==(::MyIrrational, ::MyIrrational), hash(x::MyIrrational, h::UInt) und convert(::Type{F}, x::MyIrrational) where {F <: Union{BigFloat,Float32,Float64}} implementieren.

Wenn ein Untertyp verwendet wird, um Werte darzustellen, die gelegentlich rational sein können (z. B. ein Quadratwurzeltyp, der √n für ganze Zahlen n darstellt, gibt ein rationales Ergebnis zurück, wenn n eine perfekte Quadratzahl ist), sollte er auch isinteger, iszero, isone und == mit Real-Werten implementieren (da all dies standardmäßig false für AbstractIrrational-Typen ist) sowie hash definieren, um dem entsprechenden Rational zu entsprechen.

Float16 <: AbstractFloat <: Real

16-Bit-Gleitkommazahltyp (IEEE 754-Standard). Das binäre Format besteht aus 1 Vorzeichen, 5 Exponenten und 10 Bruchbits.

Float32 <: AbstractFloat <: Real

32-Bit-Gleitkommazahltyp (IEEE 754-Standard). Das binäre Format besteht aus 1 Vorzeichen, 8 Exponenten und 23 Bruchbits.

Der Exponent für die wissenschaftliche Notation sollte in Kleinbuchstaben f eingegeben werden, also 2f3 === 2.0f0 * 10^3 === Float32(2_000). Bei Array-Literalen und -Komprehensionen kann der Elementtyp vor den eckigen Klammern angegeben werden: Float32[1,4,9] == Float32[i^2 for i in 1:3].

Siehe auch Inf32, NaN32, Float16, exponent, frexp.

Float64 <: AbstractFloat <: Real

64-Bit-Gleitkommazahltyp (IEEE 754-Standard). Das binäre Format besteht aus 1 Vorzeichen, 11 Exponenten und 52 Bruchbits. Siehe bitstring, signbit, exponent, frexp und significand, um auf verschiedene Bits zuzugreifen.

Dies ist der Standard für Gleitkommaliterale, 1.0 isa Float64, und für viele Operationen wie 1/2, 2pi, log(2), range(0,90,length=4). Im Gegensatz zu Ganzzahlen ändert sich dieser Standard nicht mit Sys.WORD_SIZE.

Der Exponent für wissenschaftliche Notation kann als e oder E eingegeben werden, somit ist 2e3 === 2.0E3 === 2.0 * 10^3. Dies wird dringend gegenüber 10^n bevorzugt, da Ganzzahlen überlaufen, somit ist 2.0 * 10^19 < 0, aber 2e19 > 0.

Siehe auch Inf, NaN, floatmax, Float32, Complex.

BigFloat <: AbstractFloat

Zahlentyp mit beliebiger Präzision für Fließkommazahlen.

Bool <: Integer

Boolescher Typ, der die Werte true und false enthält.

Bool ist eine Art von Zahl: false ist numerisch gleich 0 und true ist numerisch gleich 1. Darüber hinaus wirkt false als multiplikativer "starker Null" gegen NaN und Inf:

julia> [true, false] == [1, 0]
true

julia> 42.0 + true
43.0

julia> 0 .* (NaN, Inf, -Inf)
(NaN, NaN, NaN)

julia> false .* (NaN, Inf, -Inf)
(0.0, 0.0, -0.0)

Verzweigungen über if und andere Bedingungen akzeptieren nur Bool. Es gibt keine "truthy" Werte in Julia.

Vergleiche geben typischerweise Bool zurück, und broadcastete Vergleiche können BitArray anstelle eines Array{Bool} zurückgeben.

julia> [1 2 3 4 5] .< pi
1×5 BitMatrix:
 1  1  1  0  0

julia> map(>(pi), [1 2 3 4 5])
1×5 Matrix{Bool}:
 0  0  0  1  1

Siehe auch trues, falses, ifelse.

Int8 <: Signed <: Integer

8-Bit vorzeichenbehafteter Ganzzahltyp.

Stellt Zahlen n ∈ -128:127 dar. Beachten Sie, dass solche Ganzzahlen ohne Warnung überlaufen, daher gilt typemax(Int8) + Int8(1) < 0.

Siehe auch Int, widen, BigInt.

UInt8 <: Unsigned <: Integer

8-Bit unsigned Ganzzahltyp.

Im Hexadezimalformat gedruckt, daher 0x07 == 7.

Int16 <: Signed <: Integer

16-Bit vorzeichenbehafteter Ganzzahltyp.

Stellt Zahlen n ∈ -32768:32767 dar. Beachten Sie, dass solche Ganzzahlen ohne Warnung überlaufen, daher gilt typemax(Int16) + Int16(1) < 0.

Siehe auch Int, widen, BigInt.

UInt16 <: Unsigned <: Integer

16-Bit unsigned Ganzzahltyp.

In hexadezimaler Darstellung, also 0x000f == 15.

Int32 <: Signed <: Integer

32-Bit vorzeichenbehafteter Ganzzahltyp.

Beachten Sie, dass solche Ganzzahlen ohne Warnung überlaufen, daher ist typemax(Int32) + Int32(1) < 0.

Siehe auch Int, widen, BigInt.

UInt32 <: Unsigned <: Integer

32-Bit unsigned Ganzzahltyp.

In hexadezimaler Darstellung, somit 0x0000001f == 31.

Int64 <: Signed <: Integer

64-Bit vorzeichenbehafteter Ganzzahltyp.

Beachten Sie, dass solche Ganzzahlen ohne Warnung überlaufen, daher ist typemax(Int64) + Int64(1) < 0.

Siehe auch Int, widen, BigInt.

UInt64 <: Unsigned <: Integer

64-Bit unsigned Ganzzahltyp.

In hexadezimaler Darstellung, somit 0x000000000000003f == 63.

Int128 <: Signed <: Integer

128-Bit vorzeichenbehafteter Ganzzahltyp.

Beachten Sie, dass solche Ganzzahlen ohne Warnung überlaufen, daher gilt typemax(Int128) + Int128(1) < 0.

Siehe auch Int, widen, BigInt.

UInt128 <: Unsigned <: Integer

128-Bit unsigned Ganzzahltyp.

In hexadezimaler Darstellung, somit 0x0000000000000000000000000000007f == 127.

Int

Sys.WORD_SIZE-Bit vorzeichenbehafteter Ganzzahltyp, Int <: Signed <: Integer <: Real.

Dies ist der Standardtyp der meisten Ganzzahl-Literale und ist ein Alias für entweder Int32 oder Int64, abhängig von Sys.WORD_SIZE. Es ist der Typ, der von Funktionen wie length zurückgegeben wird, und der Standardtyp für das Indizieren von Arrays.

Beachten Sie, dass Ganzzahlen ohne Warnung überlaufen, daher gilt typemax(Int) + 1 < 0 und 10^19 < 0. Überlauf kann vermieden werden, indem BigInt verwendet wird. Sehr große Ganzzahl-Literale verwenden einen breiteren Typ, zum Beispiel 10_000_000_000_000_000_000 isa Int128.

Die ganzzahlige Division ist div Alias ÷, während /, das auf Ganzzahlen wirkt, Float64 zurückgibt.

Siehe auch Int64, widen, typemax, bitstring.

UInt

Sys.WORD_SIZE-Bit unsigned Integer-Typ, UInt <: Unsigned <: Integer.

Wie Int kann das Alias UInt entweder auf UInt32 oder UInt64 verweisen, je nach dem Wert von Sys.WORD_SIZE auf einem bestimmten Computer.

Gedruckt und geparst in Hexadezimal: UInt(15) === 0x000000000000000f.

BigInt <: Signed

Ganzzahltyp mit beliebiger Präzision.

Complex{T<:Real} <: Number

Komplexe Zahlentyp mit realem und imaginärem Teil vom Typ T.

ComplexF16, ComplexF32 und ComplexF64 sind Aliase für Complex{Float16}, Complex{Float32} und Complex{Float64} jeweils.

Siehe auch: Real, complex, real.

Rational{T<:Integer} <: Real

Rationaler Zahlentyp, mit Zähler und Nenner vom Typ T. Rationale Zahlen werden auf Überlauf überprüft.

Irrational{sym} <: AbstractIrrational

Zahlentyp, der einen exakten irrationalen Wert darstellt, der durch das Symbol sym bezeichnet wird, wie z. B. π, ℯ und γ.

Siehe auch AbstractIrrational.

digits([T<:Integer], n::Integer; base::T = 10, pad::Integer = 1)

Gibt ein Array mit dem Elementtyp T (Standard Int) der Ziffern von n in der angegebenen Basis zurück, optional mit Nullen auf eine bestimmte Größe aufgefüllt. Die bedeutenderen Ziffern befinden sich an höheren Indizes, sodass n == sum(digits[k]*base^(k-1) for k in eachindex(digits)).

Siehe auch ndigits, digits! und für Basis 2 auch bitstring, count_ones.

Beispiele

julia> digits(10)
2-element Vector{Int64}:
 0
 1

julia> digits(10, base = 2)
4-element Vector{Int64}:
 0
 1
 0
 1

julia> digits(-256, base = 10, pad = 5)
5-element Vector{Int64}:
 -6
 -5
 -2
  0
  0

julia> n = rand(-999:999);

julia> n == evalpoly(13, digits(n, base = 13))
true

digits!(array, n::Integer; base::Integer = 10)

Füllt ein Array mit den Ziffern von n in der angegebenen Basis. Die bedeutenderen Ziffern befinden sich an höheren Indizes. Wenn die Array-Länge nicht ausreicht, werden die am wenigsten signifikanten Ziffern bis zur Array-Länge gefüllt. Wenn die Array-Länge übermäßig ist, wird der überschüssige Teil mit Nullen gefüllt.

Beispiele

julia> digits!([2, 2, 2, 2], 10, base = 2)
4-element Vector{Int64}:
 0
 1
 0
 1

julia> digits!([2, 2, 2, 2, 2, 2], 10, base = 2)
6-element Vector{Int64}:
 0
 1
 0
 1
 0
 0

bitstring(n)

Ein String, der die literale Bitdarstellung eines primitiven Typs angibt.

Siehe auch count_ones, count_zeros, digits.

Beispiele

julia> bitstring(Int32(4))
"00000000000000000000000000000100"

julia> bitstring(2.2)
"0100000000000001100110011001100110011001100110011001100110011010"

parse(::Type{SimpleColor}, rgb::String)

Eine Analogie zu tryparse(SimpleColor, rgb::String) (siehe dort), die einen Fehler auslöst, anstatt nichts zurückzugeben.

parse(::Type{Platform}, triplet::AbstractString)

Parst einen String-Plattformtriplet zurück in ein Platform-Objekt.

parse(type, str; base)

Analysiere einen String als eine Zahl. Für Integer-Typen kann eine Basis angegeben werden (der Standard ist 10). Für Fließkommatypen wird der String als dezimale Fließkommazahl analysiert. Complex-Typen werden aus dezimalen Strings der Form "R±Iim" als Complex(R,I) des angeforderten Typs analysiert; "i" oder "j" können auch anstelle von "im" verwendet werden, und "R" oder "Iim" sind ebenfalls zulässig. Wenn der String keine gültige Zahl enthält, wird ein Fehler ausgelöst.

Beispiele

julia> parse(Int, "1234")
1234

julia> parse(Int, "1234", base = 5)
194

julia> parse(Int, "afc", base = 16)
2812

julia> parse(Float64, "1.2e-3")
0.0012

julia> parse(Complex{Float64}, "3.2e-1 + 4.5im")
0.32 + 4.5im

tryparse(::Type{SimpleColor}, rgb::String)

Versuchen Sie, rgb als SimpleColor zu parsen. Wenn rgb mit # beginnt und eine Länge von 7 hat, wird es in einen RGBTuple-unterstützten SimpleColor umgewandelt. Wenn rgb mit a-z beginnt, wird rgb als Farbname interpretiert und in einen Symbol-unterstützten SimpleColor umgewandelt.

Andernfalls wird nothing zurückgegeben.

Beispiele

julia> tryparse(SimpleColor, "blue")
SimpleColor(blue)

julia> tryparse(SimpleColor, "#9558b2")
SimpleColor(#9558b2)

julia> tryparse(SimpleColor, "#nocolor")

tryparse(type, str; base)

Wie parse, aber gibt entweder einen Wert des angeforderten Typs zurück oder nothing, wenn der String keine gültige Zahl enthält.

big(x)

Konvertiere eine Zahl in eine Darstellung mit maximaler Präzision (typischerweise BigInt oder BigFloat). Siehe BigFloat für Informationen über einige Fallstricke bei Fließkommazahlen.

signed(T::Integer)

Konvertiert einen Ganzzahl-Bittyp in den signierten Typ derselben Größe.

Beispiele

julia> signed(UInt16)
Int16
julia> signed(UInt64)
Int64

signed(x)

Konvertiert eine Zahl in eine vorzeichenbehaftete Ganzzahl. Wenn das Argument vorzeichenlos ist, wird es ohne Überlaufprüfung als vorzeichenbehaftet interpretiert.

Siehe auch: unsigned, sign, signbit.

unsigned(T::Integer)

Konvertiert einen Ganzzahl-Bittyp in den unsigned Typ derselben Größe.

Beispiele

julia> unsigned(Int16)
UInt16
julia> unsigned(UInt64)
UInt64

float(x)

Konvertiere eine Zahl oder ein Array in einen Gleitkomma-Datentyp.

Siehe auch: complex, oftype, convert.

Beispiele

julia> float(1:1000)
1.0:1.0:1000.0

julia> float(typemax(Int32))
2.147483647e9

significand(x)

Extrahiert den Signifikanten (auch bekannt als Mantisse) einer Fließkommazahl. Wenn x eine von Null verschiedene endliche Zahl ist, dann wird das Ergebnis eine Zahl vom gleichen Typ und Vorzeichen wie x sein, deren absoluter Wert im Intervall $[1,2)$ liegt. Andernfalls wird x zurückgegeben.

Siehe auch frexp, exponent.

Beispiele

julia> significand(15.2)
1.9

julia> significand(-15.2)
-1.9

julia> significand(-15.2) * 2^3
-15.2

julia> significand(-Inf), significand(Inf), significand(NaN)
(-Inf, Inf, NaN)

exponent(x::Real) -> Int

Gibt die größte ganze Zahl y zurück, so dass 2^y ≤ abs(x).

Wirft einen DomainError, wenn x null, unendlich oder NaN ist. Für jede andere nicht-subnormale Fließkommazahl x entspricht dies den Exponentenbits von x.

Siehe auch signbit, significand, frexp, issubnormal, log2, ldexp.

Beispiele

julia> exponent(8)
3

julia> exponent(6.5)
2

julia> exponent(-1//4)
-2

julia> exponent(3.142e-4)
-12

julia> exponent(floatmin(Float32)), exponent(nextfloat(0.0f0))
(-126, -149)

julia> exponent(0.0)
ERROR: DomainError mit 0.0:
Kann nicht ±0.0 sein.
[...]

complex(r, [i])

Konvertiert reelle Zahlen oder Arrays in komplexe Zahlen. i ist standardmäßig null.

Beispiele

julia> complex(7)
7 + 0im

julia> complex([1, 2, 3])
3-element Vector{Complex{Int64}}:
 1 + 0im
 2 + 0im
 3 + 0im

bswap(n)

Kehrt die Byte-Reihenfolge von n um.

(Siehe auch ntoh und hton, um zwischen der aktuellen nativen Byte-Reihenfolge und der Big-Endian-Reihenfolge zu konvertieren.)

Beispiele

julia> a = bswap(0x10203040)
0x40302010

julia> bswap(a)
0x10203040

julia> string(1, base = 2)
"1"

julia> string(bswap(1), base = 2)
"100000000000000000000000000000000000000000000000000000000"

hex2bytes(itr)

Gibt ein iterierbares itr von ASCII-Codes für eine Sequenz von hexadezimalen Ziffern zurück, das ein Vector{UInt8} von Bytes entspricht, die der binären Darstellung entsprechen: jedes aufeinanderfolgende Paar von hexadezimalen Ziffern in itr gibt den Wert eines Bytes im Rückgabvektor an.

Die Länge von itr muss gerade sein, und das zurückgegebene Array hat die Hälfte der Länge von itr. Siehe auch hex2bytes! für eine In-Place-Version und bytes2hex für das Inverse.

Beispiele

julia> s = string(12345, base = 16)
"3039"

julia> hex2bytes(s)
2-element Vector{UInt8}:
 0x30
 0x39

julia> a = b"01abEF"
6-element Base.CodeUnits{UInt8, String}:
 0x30
 0x31
 0x61
 0x62
 0x45
 0x46

julia> hex2bytes(a)
3-element Vector{UInt8}:
 0x01
 0xab
 0xef

hex2bytes!(dest::AbstractVector{UInt8}, itr)

Konvertiere ein iterierbares itr von Bytes, das einen hexadezimalen String darstellt, in seine binäre Darstellung, ähnlich wie hex2bytes, mit dem Unterschied, dass die Ausgabe in-place in dest geschrieben wird. Die Länge von dest muss die Hälfte der Länge von itr sein.

bytes2hex(itr) -> String
bytes2hex(io::IO, itr)

Konvertiere einen Iterator itr von Bytes in seine hexadezimale String-Darstellung, entweder indem ein String über bytes2hex(itr) zurückgegeben wird oder indem der String in einen io-Stream über bytes2hex(io, itr) geschrieben wird. Die hexadezimalen Zeichen sind alle klein geschrieben.

Beispiele

julia> a = string(12345, base = 16)
"3039"

julia> b = hex2bytes(a)
2-element Vector{UInt8}:
 0x30
 0x39

julia> bytes2hex(b)
"3039"

one(x)
one(T::type)

Gibt eine multiplikative Identität für x zurück: einen Wert, so dass one(x)*x == x*one(x) == x. Alternativ kann one(T) einen Typ T annehmen, in diesem Fall gibt one eine multiplikative Identität für jedes x vom Typ T zurück.

Wenn möglich, gibt one(x) einen Wert des gleichen Typs wie x zurück, und one(T) gibt einen Wert vom Typ T zurück. Dies ist jedoch möglicherweise nicht der Fall für Typen, die dimensionale Größen darstellen (z. B. Zeit in Tagen), da die multiplikative Identität dimensionslos sein muss. In diesem Fall sollte one(x) einen Identitätswert mit der gleichen Präzision (und Form, für Matrizen) wie x zurückgeben.

Wenn Sie eine Größe möchten, die vom gleichen Typ wie x oder vom Typ T ist, selbst wenn x dimensionale Größen hat, verwenden Sie stattdessen oneunit.

Siehe auch die identity Funktion und I in LinearAlgebra für die Identitätsmatrix.

Beispiele

julia> one(3.7)
1.0

julia> one(Int)
1

julia> import Dates; one(Dates.Day(1))
1

oneunit(x::T)
oneunit(T::Type)

Gibt T(one(x)) zurück, wobei T entweder der Typ des Arguments oder (wenn ein Typ übergeben wird) das Argument ist. Dies unterscheidet sich von one für dimensionale Größen: one ist dimensionslos (eine multiplikative Identität), während oneunit dimensional ist (vom gleichen Typ wie x oder vom Typ T).

Beispiele

julia> oneunit(3.7)
1.0

julia> import Dates; oneunit(Dates.Day)
1 Tag

zero(x)
zero(::Type)

Holen Sie sich das additive Identitätselement für den Typ von x (x kann auch den Typ selbst angeben).

Siehe auch iszero, one, oneunit, oftype.

Beispiele

julia> zero(1)
0

julia> zero(big"2.0")
0.0

julia> zero(rand(2,2))
2×2 Matrix{Float64}:
 0.0  0.0
 0.0  0.0

im

Die imaginäre Einheit.

Siehe auch: imag, angle, complex.

Beispiele

julia> im * im
-1 + 0im

julia> (2.0 + 3im)^2
-5.0 + 12.0im

π
pi

Die Konstante pi.

Unicode π kann eingegeben werden, indem man \pi schreibt und dann die Tabulatortaste im Julia REPL und in vielen Editoren drückt.

Siehe auch: sinpi, sincospi, deg2rad.

Beispiele

julia> pi
π = 3.1415926535897...

julia> 1/2pi
0.15915494309189535

ℯ
e

Die Konstante ℯ.

Unicode ℯ kann eingegeben werden, indem \euler geschrieben und die Tabulatortaste im Julia REPL sowie in vielen Editoren gedrückt wird.

Siehe auch: exp, cis, cispi.

Beispiele

julia> ℯ
ℯ = 2.7182818284590...

julia> log(ℯ)
1

julia> ℯ^(im)π ≈ -1
true

katalan

Die Konstante von Katalan.

Beispiele

julia> Base.MathConstants.catalan
katalan = 0.9159655941772...

julia> sum(log(x)/(1+x^2) for x in 1:0.01:10^6) * 0.01
0.9159466120554123

γ
eulergamma

Eulersche Konstante.

Beispiele

julia> Base.MathConstants.eulergamma
γ = 0.5772156649015...

julia> dx = 10^-6;

julia> sum(-exp(-x) * log(x) for x in dx:dx:100) * dx
0.5772078382499133

φ
golden

Das goldene Verhältnis.

Beispiele

julia> Base.MathConstants.golden
φ = 1.6180339887498...

julia> (2ans - 1)^2 ≈ 5
true

Inf, Inf64

Positive Unendlichkeit vom Typ Float64.

Siehe auch: isfinite, typemax, NaN, Inf32.

Beispiele

julia> π/0
Inf

julia> +1.0 / -0.0
-Inf

julia> ℯ^-Inf
0.0

Inf, Inf64

Positive Unendlichkeit vom Typ Float64.

Siehe auch: isfinite, typemax, NaN, Inf32.

Beispiele

julia> π/0
Inf

julia> +1.0 / -0.0
-Inf

julia> ℯ^-Inf
0.0

Inf32

Positive Unendlichkeit des Typs Float32.

Inf16

Positive Unendlichkeit des Typs Float16.

NaN, NaN64

Ein nicht-ein-Zahlen-Wert vom Typ Float64.

Siehe auch: isnan, missing, NaN32, Inf.

Beispiele

julia> 0/0
NaN

julia> Inf - Inf
NaN

julia> NaN == NaN, isequal(NaN, NaN), isnan(NaN)
(false, true, true)

!!! Hinweis Verwenden Sie immer isnan oder isequal zur Überprüfung auf NaN. Die Verwendung von x === NaN kann unerwartete Ergebnisse liefern:

```julia-repl
julia> reinterpret(UInt32, NaN32)
0x7fc00000

julia> NaN32p1 = reinterpret(Float32, 0x7fc00001)
NaN32

julia> NaN32p1 === NaN32, isequal(NaN32p1, NaN32), isnan(NaN32p1)
(false, true, true)
```

NaN, NaN64

Ein nicht-ein-Zahlen-Wert vom Typ Float64.

Siehe auch: isnan, missing, NaN32, Inf.

Beispiele

julia> 0/0
NaN

julia> Inf - Inf
NaN

julia> NaN == NaN, isequal(NaN, NaN), isnan(NaN)
(false, true, true)

!!! Hinweis Verwenden Sie immer isnan oder isequal zur Überprüfung auf NaN. Die Verwendung von x === NaN kann unerwartete Ergebnisse liefern:

```julia-repl
julia> reinterpret(UInt32, NaN32)
0x7fc00000

julia> NaN32p1 = reinterpret(Float32, 0x7fc00001)
NaN32

julia> NaN32p1 === NaN32, isequal(NaN32p1, NaN32), isnan(NaN32p1)
(false, true, true)
```

NaN32

Ein Not-a-Number-Wert vom Typ Float32.

Siehe auch: NaN.

NaN16

Ein Not-a-Number-Wert vom Typ Float16.

Siehe auch: NaN.

issubnormal(f) -> Bool

Testen, ob eine Fließkommazahl subnormal ist.

Eine IEEE-Fließkommazahl ist subnormal, wenn ihre Exponentenbits null sind und ihr Signifikand nicht null ist.

Beispiele

julia> floatmin(Float32)
1.1754944f-38

julia> issubnormal(1.0f-37)
false

julia> issubnormal(1.0f-38)
true

isfinite(f) -> Bool

Überprüfen, ob eine Zahl endlich ist.

Beispiele

julia> isfinite(5)
true

julia> isfinite(NaN32)
false

isinf(f) -> Bool

Überprüfen, ob eine Zahl unendlich ist.

Siehe auch: Inf, iszero, isfinite, isnan.

isnan(f) -> Bool

Überprüfen, ob ein Zahlenwert ein NaN ist, ein unbestimmter Wert, der weder eine Unendlichkeit noch eine endliche Zahl ist ("nicht eine Zahl").

Siehe auch: iszero, isone, isinf, ismissing.

iszero(x)

Gibt true zurück, wenn x == zero(x); wenn x ein Array ist, überprüft dies, ob alle Elemente von x null sind.

Siehe auch: isone, isinteger, isfinite, isnan.

Beispiele

julia> iszero(0.0)
true

julia> iszero([1, 9, 0])
false

julia> iszero([false, 0, 0])
true

isone(x)

Gibt true zurück, wenn x == one(x); wenn x ein Array ist, überprüft dies, ob x eine Identitätsmatrix ist.

Beispiele

julia> isone(1.0)
true

julia> isone([1 0; 0 2])
false

julia> isone([1 0; 0 true])
true

nextfloat(x::AbstractFloat, n::Integer)

Das Ergebnis von n iterativen Anwendungen von nextfloat auf x, wenn n >= 0, oder -n Anwendungen von prevfloat, wenn n < 0.

nextfloat(x::AbstractFloat)

Gibt die kleinste Fließkommazahl y des gleichen Typs wie x zurück, so dass x < y. Wenn kein solches y existiert (z. B. wenn x Inf oder NaN ist), wird x zurückgegeben.

Siehe auch: prevfloat, eps, issubnormal.

prevfloat(x::AbstractFloat, n::Integer)

Das Ergebnis von n iterativen Anwendungen von prevfloat auf x, wenn n >= 0, oder -n Anwendungen von nextfloat, wenn n < 0.

prevfloat(x::AbstractFloat)

Gibt die größte Fließkommazahl y vom gleichen Typ wie x zurück, so dass y < x. Wenn kein solches y existiert (z. B. wenn x -Inf oder NaN ist), dann wird x zurückgegeben.

isinteger(x) -> Bool

Überprüfen, ob x numerisch gleich einer ganzen Zahl ist.

Beispiele

julia> isinteger(4.0)
true

isreal(x) -> Bool

Testen Sie, ob x oder alle seine Elemente numerisch gleich einer reellen Zahl sind, einschließlich Unendlichkeiten und NaNs. isreal(x) ist wahr, wenn isequal(x, real(x)) wahr ist.

Beispiele

julia> isreal(5.)
true

julia> isreal(1 - 3im)
false

julia> isreal(Inf + 0im)
true

julia> isreal([4.; complex(0,1)])
false

Float32(x [, mode::RoundingMode])

Erstellt ein Float32 aus x. Wenn x nicht genau darstellbar ist, bestimmt mode, wie x gerundet wird.

Beispiele

julia> Float32(1/3, RoundDown)
0.3333333f0

julia> Float32(1/3, RoundUp)
0.33333334f0

Siehe RoundingMode für verfügbare Rundungsmodi.

Float64(x [, mode::RoundingMode])

Erstellt ein Float64 aus x. Wenn x nicht genau darstellbar ist, bestimmt mode, wie x gerundet wird.

Beispiele

julia> Float64(pi, RoundDown)
3.141592653589793

julia> Float64(pi, RoundUp)
3.1415926535897936

Siehe RoundingMode für verfügbare Rundungsmodi.

rounding(T)

Holen Sie sich den aktuellen Gleitkomma-Rundungsmodus für den Typ T, der die Rundung grundlegender arithmetischer Funktionen (+, -, *, / und sqrt) sowie die Typumwandlung steuert.

Siehe RoundingMode für verfügbare Modi.

setrounding(T, mode)

Setzen Sie den Rundungsmodus des Fließkommatyps T, der die Rundung grundlegender arithmetischer Funktionen (+, -, *, / und sqrt) und die Typkonvertierung steuert. Andere numerische Funktionen können falsche oder ungültige Werte zurückgeben, wenn Rundungsmodi verwendet werden, die von der Standard-RoundNearest abweichen.

Bitte beachten Sie, dass dies derzeit nur für T == BigFloat unterstützt wird.

setrounding(f::Function, T, mode)

Ändert den Rundungsmodus des Fließkommatyps T für die Dauer von f. Es ist logisch äquivalent zu:

old = rounding(T)
setrounding(T, mode)
f()
setrounding(T, old)

Siehe RoundingMode für verfügbare Rundungsmodi.

get_zero_subnormals() -> Bool

Gibt false zurück, wenn Operationen mit subnormalen Gleitkommawerten ("denormals") den Regeln der IEEE-Arithmetik folgen, und true, wenn sie möglicherweise in Nullen umgewandelt werden können.

set_zero_subnormals(yes::Bool) -> Bool

Wenn yes false ist, folgen nachfolgende Gleitkommaoperationen den Regeln der IEEE-Arithmetik für subnormale Werte ("denormals"). Andernfalls ist es Gleitkommaoperationen erlaubt (aber nicht erforderlich), subnormale Eingaben oder Ausgaben in null zu konvertieren. Gibt true zurück, es sei denn, yes==true, aber die Hardware unterstützt das Nullsetzen von subnormalen Zahlen nicht.

set_zero_subnormals(true) kann einige Berechnungen auf bestimmter Hardware beschleunigen. Es kann jedoch Identitäten wie (x-y==0) == (x==y) brechen.

count_ones(x::Integer) -> Integer

Anzahl der Einsen in der binären Darstellung von x.

Beispiele

julia> count_ones(7)
3

julia> count_ones(Int32(-1))
32

count_zeros(x::Integer) -> Integer

Anzahl der Nullen in der binären Darstellung von x.

Beispiele

julia> count_zeros(Int32(2 ^ 16 - 1))
16

julia> count_zeros(-1)
0

leading_zeros(x::Integer) -> Integer

Anzahl der Nullen, die die binäre Darstellung von x führen.

Beispiele

julia> leading_zeros(Int32(1))
31

leading_ones(x::Integer) -> Integer

Anzahl der Einsen, die die binäre Darstellung von x anführen.

Beispiele

julia> leading_ones(UInt32(2 ^ 32 - 2))
31

trailing_zeros(x::Integer) -> Integer

Anzahl der Nullen am Ende der binären Darstellung von x.

Beispiele

julia> trailing_zeros(2)
1

trailing_ones(x::Integer) -> Integer

Anzahl der Einsen, die der binären Darstellung von x folgen.

Beispiele

julia> trailing_ones(3)
2

isodd(x::Number) -> Bool

Gibt true zurück, wenn x eine ungerade ganze Zahl ist (das heißt, eine ganze Zahl, die nicht durch 2 teilbar ist), und false andernfalls.

Beispiele

julia> isodd(9)
true

julia> isodd(10)
false

iseven(x::Number) -> Bool

Gibt true zurück, wenn x eine gerade ganze Zahl ist (das heißt, eine ganze Zahl, die durch 2 teilbar ist), und false andernfalls.

Beispiele

julia> iseven(9)
false

julia> iseven(10)
true

@int128_str str

Analysiere str als einen Int128. Wirf einen ArgumentError, wenn der String keine gültige Ganzzahl ist.

Beispiele

julia> int128"123456789123"
123456789123

julia> int128"123456789123.4"
ERROR: LoadError: ArgumentError: ungültige Basis-10-Ziffer '.' in "123456789123.4"
[...]

@uint128_str str

Analysiere str als ein UInt128. Wirf einen ArgumentError, wenn der String keine gültige Ganzzahl ist.

Beispiele

julia> uint128"123456789123"
0x00000000000000000000001cbe991a83

julia> uint128"-123456789123"
ERROR: LoadError: ArgumentError: ungültige Basis 10 Ziffer '-' in "-123456789123"
[...]

BigFloat(x::Union{Real, AbstractString} [, rounding::RoundingMode=rounding(BigFloat)]; [precision::Integer=precision(BigFloat)])

Erstellen Sie eine Fließkommazahl mit beliebiger Genauigkeit aus x, mit der Genauigkeit precision. Das Argument rounding gibt die Richtung an, in die das Ergebnis gerundet werden soll, wenn die Umwandlung nicht genau durchgeführt werden kann. Wenn nicht angegeben, werden diese durch die aktuellen globalen Werte festgelegt.

BigFloat(x::Real) ist dasselbe wie convert(BigFloat,x), es sei denn, x selbst ist bereits BigFloat, in diesem Fall wird ein Wert mit der Genauigkeit zurückgegeben, die auf die aktuelle globale Genauigkeit eingestellt ist; convert gibt immer x zurück.

BigFloat(x::AbstractString) ist identisch mit parse. Dies wird zur Bequemlichkeit bereitgestellt, da Dezimalliterale beim Parsen in Float64 umgewandelt werden, sodass BigFloat(2.1) möglicherweise nicht das ergibt, was Sie erwarten.

Siehe auch:

• @big_str
• rounding und setrounding
• precision und setprecision

Beispiele

julia> BigFloat(2.1) # 2.1 hier ist ein Float64
2.100000000000000088817841970012523233890533447265625

julia> BigFloat("2.1") # die nächstgelegene BigFloat zu 2.1
2.099999999999999999999999999999999999999999999999999999999999999999999999999986

julia> BigFloat("2.1", RoundUp)
2.100000000000000000000000000000000000000000000000000000000000000000000000000021

julia> BigFloat("2.1", RoundUp, precision=128)
2.100000000000000000000000000000000000007

precision(num::AbstractFloat; base::Integer=2)
precision(T::Type; base::Integer=2)

Erhalten Sie die Genauigkeit einer Fließkommazahl, wie sie durch die effektive Anzahl der Bits im Signifikand definiert ist, oder die Genauigkeit eines Fließkommatyps T (seine aktuelle Standardgenauigkeit, wenn T ein variabel präziser Typ wie BigFloat ist).

Wenn base angegeben ist, gibt es die maximale entsprechende Anzahl von Signifikand-Ziffern in dieser Basis zurück.

setprecision([T=BigFloat,] precision::Int; base=2)

Setzen Sie die Präzision (in Bits, standardmäßig) für die Verwendung in der Arithmetik von T. Wenn base angegeben ist, dann ist die Präzision das Minimum, das erforderlich ist, um mindestens precision Ziffern in der angegebenen base zu erhalten.

setprecision(f::Function, [T=BigFloat,] precision::Integer; base=2)

Ändert die arithmetische Präzision von T (in der angegebenen base) für die Dauer von f. Es ist logisch äquivalent zu:

old = precision(BigFloat)
setprecision(BigFloat, precision)
f()
setprecision(BigFloat, old)

Oft verwendet als setprecision(T, precision) do ... end

Hinweis: nextfloat(), prevfloat() verwenden nicht die von setprecision angegebene Präzision.

BigInt(x)

Erstellt eine Ganzzahl mit beliebiger Präzision. x kann ein Int (oder alles, was in ein Int umgewandelt werden kann) sein. Die üblichen mathematischen Operatoren sind für diesen Typ definiert, und die Ergebnisse werden zu einem BigInt befördert.

Instanzen können aus Zeichenfolgen über parse oder mit dem big-Zeichenfolgenliteral erstellt werden.

Beispiele

julia> parse(BigInt, "42")
42

julia> big"313"
313

julia> BigInt(10)^19
10000000000000000000

@big_str str

Analysiere einen String in eine BigInt oder BigFloat und werfe einen ArgumentError, wenn der String keine gültige Zahl ist. Für ganze Zahlen ist _ im String als Trennzeichen erlaubt.

Beispiele

julia> big"123_456"
123456

julia> big"7891.5"
7891.5

julia> big"_"
ERROR: ArgumentError: ungültiges Zahlenformat _ für BigInt oder BigFloat
[...]