Julia-Datentypen
In Programmiersprachen gibt es grundlegende mathematische Operationen und wissenschaftliche Berechnungen. Ihre häufig verwendeten Datentypen sindGanzzahlenundGleitkomma-Zahlen.Darüber hinaus gibt es auch einen"Literal"-Begriff. Ein Literal ist eine Notation, die verwendet wird, um einen festen Wert im Quellcode auszudrücken. Ganzzahlen, Gleitkommazahlen, Zeichenketten usw. sind alle Literale.
Zum Beispiel:
a=1 // a ist eine Variable, 1 ist ein Ganzzahlliteral b=1.0 // b ist eine Variable, 1.0 ist ein GleitkommaliteralJulia bietet einen reichhaltigen Satz primitiver numerischer Typen und definiert darauf basierend einen vollständigen Satz arithmetischer Operationen. Darüber hinaus bietet es auch bitweise Operatoren und einige mathematische Standardfunktionen.
Ganzzahltypen
Die folgende Tabelle listet die von Julia unterstützten Ganzzahltypen auf:
| Type | Vorzeichenbehaftet? | Anzahl der Bits | Minimaler Wert | Maximaler Wert |
|---|---|---|---|---|
| Int8 | ✓ | 8 | -2^7 | 2^7 – 1 |
| UInt8 | 8 | 0 | 2^8 – 1 | |
| Int16 | ✓ | 16 | -2^15 | 2^15 – 1 |
| UInt16 | 16 | 0 | 2^16 – 1 | |
| Int32 | ✓ | 32 | -2^31 | 2^31 – 1 |
| UInt32 | 32 | 0 | 2^32 – 1 | |
| Int64 | ✓ | 64 | -2^63 | 2^63 – 1 |
| UInt64 | 64 | 0 | 2^64 – 1 | |
| Int128 | ✓ | 128 | -2^127 | 2^127 – 1 |
| UInt128 | 128 | 0 | 2^128 – 1 | |
| Bool | N/A | 8 | false (0) | true (1) |
Formen von Ganzzahlliteralen:
Beispiel
1
julia> 1234
1234
Der Standardtyp eines Ganzzahlliterals hängt davon ab, ob das Zielsystem eine 32-Bit- oder 64-Bit-Architektur ist (die meisten Systeme sind heute 64-Bit):
Beispiel
julia> typeof(1)
Int32
# 64-Bit-System:
julia> typeof(1)
Int64
Julias eingebaute VariableSys.WORD_SIZEgibt an, ob das Zielsystem eine 32-Bit- oder 64-Bit-Architektur ist:
Beispiel
julia> Sys.WORD_SIZE
32
# 64-Bit-System:
julia> Sys.WORD_SIZE
64
Julia definiert außerdem die Typen Int und UInt, die Aliase für die vorzeichenbehafteten bzw. vorzeichenlosen nativen Ganzzahltypen des Systems sind.
Beispiel
julia> Int
Int32
julia> UInt
UInt32
# 64-Bit-System:
julia> Int
Int64
julia> UInt
UInt64
Überlaufverhalten
In Julia führt das Überschreiten des maximalen Werts, der durch einen Typ darstellbar ist, zu einem Wraparound-Verhalten:
Beispiel
9223372036854775807
julia> x + 1
-9223372036854775808
julia> x + 1 == typemin(Int64)
wahr
Daher ist Julias Ganzzahlarithmetik tatsächlich eine Form der modularen Arithmetik, was die Art und Weise widerspiegelt, wie moderne Computer Low-Level-Arithmetik implementieren. In Programmen, in denen ein Überlauf auftreten kann, sind explizite Prüfungen auf Wraparound an den Grenzen der Extremwerte erforderlich. Andernfalls wird der BigInt-Typ aus der Arithmetik mit beliebiger Genauigkeit als Alternative empfohlen.
Nachfolgend ein Beispiel für Überlaufverhalten und wie man einen Überlauf behebt:
Beispiel
-8446744073709551616
julia> big(10)^19
10000000000000000000
Divisionsfehler
Die Ganzzahldivision löst in den folgenden zwei Ausnahmefällen einen DivideError aus:- Division durch null
- Division durch die kleinste negative Zahl
remDie Restfunktion undmoddie Modulusfunktion lösen beim Teilen durch null einen DivideError aus. Hier ist ein Beispiel:
Beispiel
ERROR: DivideError: Fehler bei ganzzahliger Division
Stacktrace:
[1] div bei .\int.jl:260 [inlined]
[2] div bei .\div.jl:217 [inlined]
[3] div bei .\div.jl:262 [inlined]
[4] fld bei .\div.jl:228 [inlined]
[5] mod(::Int64, ::Int64) bei .\int.jl:252
[6] Top-Level-Scope bei REPL[52]:1
julia> rem(1, 0)
ERROR: DivideError: Fehler bei ganzzahliger Division
Stacktrace:
[1] rem(::Int64, ::Int64) bei .\int.jl:261
[2] Top-Level-Scope bei REPL[54]:1
Gleitkommatypen
Die folgende Tabelle listet die von Julia unterstützten Gleitkommatypen auf:
| Type | Precision | Anzahl der Bits |
|---|---|---|
| Float16 | Halbe Genauigkeit | 16 |
| Float32 | Einfache Genauigkeit | 32 |
| Float64 | Doppelte Genauigkeit | 64 |
Darüber hinaus wird die vollständige Unterstützung für komplexe und rationale Zahlen auf diesen primitiven Datentypen aufgebaut.
Das Format von Gleitkommaliteralen ist unten dargestellt. Bei Bedarf können SieEverwenden, um es auszudrücken.
Beispiel
1.0
julia> 1.
1.0
julia> 0.5
0.5
julia> .5
0.5
julia> -1.23
-1.23
julia> 1e10
1.0e10
julia> 2.5e-4
0.00025
Hinweis:
In wissenschaftlicher Notation kann zur Vereinfachung von Formeln das Format mitEzur Darstellung verwendet werden. Zum Beispiel kann 1.03 mal 10 hoch 8 als "1.03E+08" abgekürzt werden, wobei "E" die Abkürzung für Exponent ist.
Die obigen Ergebnisse sind alle Float64-Werte. Die Verwendung von f anstelle von e ergibt Float32-Literale:
Beispiel
0.5f0
julia> typeof(x)
Float32
julia> 2.5f-4
0.00025f0
Zahlen können einfach in denFloat32Typ konvertiert werden:
julia> x = Float32(-1.5)
-1.5f0
julia> typeof(x)
Float32
Es gibt auch hexadezimale Gleitkomma-Literale, aber sie gelten nur für Werte des Typs Float64. Sie werden im Allgemeinen mit dem Präfix p und einem Exponenten zur Basis 2 dargestellt:
Beispiel
1.0
julia> 0x1.8p3
12.0
julia> x = 0x.4p-1
0.125
julia> typeof(x)
Float64
Julia unterstützt auch Gleitkommazahlen mit halber Genauigkeit (Float16), aber sie sindFloat32durch Softwareemulation implementiert.
julia> sizeof(Float16(4.))
2
julia> 2*Float16(4.)
Float16(8.0)
Unterstrich_kann als Zifferntrennzeichen verwendet werden:
Beispiel
(10000, 5.0e-9, 0xdeadbeef, 0xb2)
Null in Gleitkommazahlen
Gleitkommazahlen haben zwei Arten von Nullen: positive Null und negative Null. Sie sind gleich, haben aber unterschiedliche binäre Darstellungen, die mit der Funktion bitstring angezeigt werden können:
Beispiel
wahr
julia> bitstring(0.0)
"0000000000000000000000000000000000000000000000000000000000000000"
julia> bitstring(-0.0)
"1000000000000000000000000000000000000000000000000000000000000000"
Spezielle Gleitkommawerte
Es gibt drei bestimmte Standard-Gleitkommawerte, die keinem Punkt auf der reellen Zahlengeraden entsprechen:
| Float16 | Float32 | Float64 | Name | Beschreibung |
|---|---|---|---|---|
| Inf16 | Inf32 | Inf | Positive Unendlichkeit | Eine Zahl, die größer als alle endlichen Gleitkommazahlen ist |
| -Inf16 | -Inf32 | -Inf | Negative Unendlichkeit | Eine Zahl, die kleiner als alle endlichen Gleitkommazahlen ist |
| NaN16 | NaN32 | NaN | Keine Zahl | Ein Wert, der nicht gleich (==) irgendeinem Gleitkommawert ist (einschließlich sich selbst) |
Im Folgenden sind einige Beispiele für Operationen mit Gleitkommazahlen aufgeführt:
Beispiel
0.0
julia> 1/0
Inf
julia> -5/0
-Inf
julia> 0.000001/0
Inf
julia> 0/0
NaN
julia> 500 + Inf
Inf
julia> 500 - Inf
-Inf
julia> Inf + Inf
Inf
julia> Inf - Inf
NaN
julia> Inf * Inf
Inf
julia> Inf / Inf
NaN
julia> 0 * Inf
NaN
julia> NaN == NaN
false
julia> NaN != NaN
wahr
julia> NaN < NaN
false
julia> NaN > NaN
false
Wir können auch die Funktionen typemin und typemax verwenden:
Beispiel
(-Inf16, Inf16)
julia> (typemin(Float32),typemax(Float32))
(-Inf32, Inf32)
julia> (typemin(Float64),typemax(Float64))
(-Inf, Inf)
Maschinengenauigkeit
Die meisten reellen Zahlen können nicht exakt durch Gleitkommazahlen dargestellt werden, daher ist es notwendig, den Abstand zwischen zwei benachbarten darstellbaren Gleitkommazahlen zu kennen, der üblicherweise als Maschinengenauigkeit bezeichnet wird.
Julia stellt dieeps-Funktion bereit, die die Differenz zwischen 1.0 und der nächsten Gleitkommazahl angibt, die Julia darstellen kann:
Beispiel
1.1920929f-7
julia> eps(Float64)
2.220446049250313e-16
julia> eps() # Entspricht eps(Float64)
2.220446049250313e-16
Diese Werte sind 2.0^-23 in Float32 und 2.0^-52 in Float64. Die Funktion eps kann auch einen Gleitkommawert als Argument annehmen und die absolute Differenz zwischen diesem Wert und dem nächsten darstellbaren Gleitkommawert zurückgeben. Das heißt, eps(x) liefert einen Wert desselben Typs wie x, und x + eps(x) ist genau der nächste darstellbare Gleitkommawert, der größer als x ist:
Beispiel
2.220446049250313e-16
julia> eps(1000.)
1.1368683772161603e-13
julia> eps(1e-27)
1.793662034335766e-43
julia> eps(0.0)
5.0e-324
Der Abstand zwischen zwei benachbarten darstellbaren Gleitkommazahlen ist nicht konstant: Je kleiner die Zahl, desto kleiner die Lücke; je größer die Zahl, desto größer die Lücke. Mit anderen Worten: Darstellbare Gleitkommazahlen sind in der Nähe von Null auf der reellen Zahlengeraden am dichtesten und werden exponentiell immer spärlicher, je weiter sie sich von Null entfernen. Per Definition ist eps(1.0) gleich eps(Float64), weil 1.0 ein 64-Bit-Gleitkommawert ist.
Julia bietet außerdem zwei Funktionen, nextfloat und prevfloat, die abhängig vom Argument jeweils die nächste größere bzw. kleinere darstellbare Gleitkommazahl zurückgeben:
Beispiel
1.25f0
julia> nextfloat(x)
1.2500001f0
julia> prevfloat(x)
1.2499999f0
julia> bitstring(prevfloat(x))
"00111111100111111111111111111111"
julia> bitstring(x)
"00111111101000000000000000000000"
julia> bitstring(nextfloat(x))
"00111111101000000000000000000001"
Dieses Beispiel veranschaulicht das allgemeine Prinzip, dass benachbarte darstellbare Gleitkommazahlen auch benachbarte binäre Ganzzahldarstellungen haben.
Rundungsmodi
Wenn eine Zahl keine exakte Gleitkommadarstellung hat, muss sie auf einen geeigneten darstellbaren Wert gerundet werden.
Der standardmäßig von Julia verwendete Modus ist immerRoundNearest, was bedeutet, auf den nächstgelegenen darstellbaren Wert zu runden, und der gerundete Wert verwendet so wenige signifikante Stellen wie möglich.
Beispiel
1.5
julia> BigFloat("1.550564889",2,RoundNearest)
1.5
julia> BigFloat("1.560564889",2,RoundNearest)
1.5
Null- und Eins-Literale
Julia stellt Literalfunktionen für 0 und 1 bereit, die das Literal eines bestimmten Typs oder den Typ einer gegebenen Variable zurückgeben können.
| Funktion | Beschreibung |
|---|---|
| zero(x) | Null-Literal vom Typ x oder vom Typ der Variable x |
| one(x) | Eins-Literal vom Typ x oder vom Typ der Variable x |
Diese Funktionen können in numerischen Vergleichen verwendet werden, um den Aufwand unnötiger Typkonvertierungen zu vermeiden.
Zum Beispiel:
Beispiel
0.0f0
julia> zero(1.0)
0.0
julia> one(Int32)
1
julia> one(BigFloat)
1.0
Typkonvertierung
Typkonvertierung ist der Prozess, bei dem eine Variable von einem Typ in einen anderen Datentyp umgewandelt wird. Wenn Sie beispielsweise einen Gleitkommawert in einem einfachen Integer speichern möchten, müssen Sie den Gleitkommatyp in einen int-Typ umwandeln. Sie können den Cast-Operator verwenden, um einen Wert explizit von einem Typ in einen anderen zu konvertieren, wie unten gezeigt:
Julia unterstützt drei Arten der numerischen Konvertierung, die sich darin unterscheiden, wie sie mit ungenauen Konvertierungen umgehen.Die erste Art:
T(x) 或 convert(T,x)
Alle oben genannten konvertieren x in den Typ T.
- Wenn T ein Gleitkommatyp ist, ist das Ergebnis der am nächsten darstellbare Wert, der positiv oder negativ unendlich sein kann.
- Wenn T ein Ganzzahltyp ist, wird ein InexactError ausgelöst, wenn x nicht durch den Typ T dargestellt werden kann.
Die zweite Art:
x % TEs ist auch möglich, eine Ganzzahl x in einen Ganzzahltyp T zu konvertieren, konsistent mit dem Ergebnis von x modulo 2^n, wobei n die Anzahl der Bits in T ist.
Die dritte Art:
Die Rundungsfunktionen akzeptieren ein optionales Argument vom Typ T. Zum Beispiel ist round(Int,x) die abgekürzte Form vonInt(round(x)).
Beispiel
127
julia> Int8(128)
ERROR: InexactError: trunc(Int8, 128)
Stacktrace:
[...]
julia> Int8(127.0)
127
julia> Int8(3.14)
ERROR: InexactError: Int8(3.14)
Stacktrace:
[...]
julia> Int8(128.0)
ERROR: InexactError: Int8(128.0)
Stacktrace:
[...]
julia> 127 % Int8
127
julia> 128 % Int8
-128
julia> round(Int8,127.4)
127
julia> round(Int8,127.6)
ERROR: InexactError: trunc(Int8, 128.0)
Stacktrace:
[...]