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 Gleitkommaliteral

Julia 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

julia> 1
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

# 32-Bit-System:
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

# 32-Bit-System:
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

# 32-Bit-System:
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

julia> x = typemax(Int64)
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

julia> 10^19
-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

julia> mod(1, 0)
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

julia> 1.0
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

julia> x = 0.5f0
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

julia> 0x1p0
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

julia> 10_000, 0.000_000_005, 0xdead_beef, 0b1011_0010
(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

julia> 0.0 == -0.0
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

julia> 1/Inf
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

julia> (typemin(Float16),typemax(Float16))
(-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

julia> eps(Float32)
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

julia> eps(1.0)
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

julia> x = 1.25f0
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

julia> BigFloat("1.510564889",2,RoundNearest)
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.

FunktionBeschreibung
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

julia> zero(Float32)
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

julia> Int8(127)
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:
[...]
Andere Erweiterungen