Komplexe und rationale Zahlen in Julia

In diesem Kapitel lernen wir hauptsächlich Julias komplexe und rationale Zahlen kennen.

Die Sprache Julia enthält vordefinierte komplexe und rationale Zahlentypen und unterstützt verschiedene standardmäßige mathematische Operationen und elementare Funktionen auf ihnen.

Komplexe Zahlen

Komplexe Zahlen sind eine Erweiterung der reellen Zahlen und ermöglichen, dass jede Polynomgleichung Wurzeln besitzt.

Wir bezeichnen Zahlen der Formz=a+bi(wobei a und b beide reelle Zahlen sind) als komplexe Zahlen. Dabei wird a als Realteil, b als Imaginärteil und i als imaginäre Einheit bezeichnet, welche die Eigenschaft hat. Wenn der Imaginärteil b von z gleich 0 ist, ist z eine reelle Zahl; wenn der Imaginärteil b von z nicht gleich 0 ist und der Realteil a gleich 0 ist, wird z oft als rein imaginäre Zahl bezeichnet.

Die globale Konstante im ist an die komplexe Zahl i gebunden und stellt die Hauptquadratwurzel von -1 dar.

Da Julia numerische Literale als Koeffizienten für numerische Literale zulässt, genügt diese Bindung, um eine sehr praktische Syntax für komplexe Zahlen bereitzustellen, ähnlich der traditionellen mathematischen Notation:

Beispiele

julia> 1+2im
1 + 2im

Wir können außerdem verschiedene arithmetische Operationen mit komplexen Zahlen durchführen:

Beispiele

julia> (1 + 2im)*(2 - 3im)
8 + 1im

julia> (1 + 2im)/(1 - 2im)
-0.6 + 0.8im

julia> (1 + 2im) + (1 - 2im)
2 + 0im

julia> (-3 + 2im) - (5 - 1im)
-8 + 3im

julia> (-1 + 2im)^2
-3 - 4im

julia> (-1 + 2im)^2.5
2.729624464784009 - 6.9606644595719im

julia> (-1 + 2im)^(1 + 1im)
-0.27910381075826657 + 0.08708053414102428im

julia> 3(2 - 5im)
6 - 15im

julia> 3(2 - 5im)^2
-63 - 60im

julia> 3(2 - 5im)^-1.0
0.20689655172413796 + 0.5172413793103449im

Der Mechanismus zur Typ-Promotion stellt zudem sicher, dass du Kombinationen von Operanden unterschiedlicher Typen verwenden kannst:

Beispiele

julia> 2(1 - 1im)
2 - 2im

julia> (2 + 3im) - 1
1 + 3im

julia> (1 + 2im) + 0.5
1.5 + 2.0im

julia> (2 + 3im) - 0.5im
2.0 + 2.5im

julia> 0.75(1 + 2im)
0.75 + 1.5im

julia> (2 + 3im) / 2
1.0 + 1.5im

julia> (1 - 3im) / (2 + 2im)
-0.5 - 1.0im

julia> 2im^2
-2 + 0im

julia> 1 + 3/4im
1.0 - 0.75im

Hinweis3/4im == 3/(4*im) == -(3/4*im), weil der Koeffizient eine höhere Priorität als die Division hat.

Julia bietet einige Standardfunktionen für die Arbeit mit komplexen Zahlen:

Beispiele

julia> z = 1 + 2im
1 + 2im

julia> real(1 + 2im) # der Realteil von z
1

julia> imag(1 + 2im) # der Imaginärteil von z
2

julia> conj(1 + 2im) # die komplexe Konjugierte von z
1 - 2im

julia> abs(1 + 2im) # der Betrag von z
2.23606797749979

julia> abs2(1 + 2im) # das Betragsquadrat
5

julia> angle(1 + 2im) # der Phasenwinkel im Bogenmaß
1.1071487177940904

Vereinbarungsgemäß ist der Betrag (abs) einer komplexen Zahl ihr Abstand von null. abs2 liefert das Quadrat des Betrags, was bei komplexen Zahlen sehr nützlich ist, weil es das Ziehen einer Quadratwurzel vermeidet. angle gibt den Phasenwinkel im Bogenmaß zurück (auch als Argumentfunktion bezeichnet). Alle anderen elementaren Funktionen sind ebenfalls für komplexe Zahlen vollständig definiert:

Beispiele

julia> sqrt(1im)
0.7071067811865476 + 0.7071067811865475im

julia> sqrt(1 + 2im)
1.272019649514069 + 0.7861513777574233im

julia> cos(1 + 2im)
2.0327230070196656 - 3.0518977991517997im

julia> exp(1 + 2im)
-1.1312043837568135 + 2.4717266720048188im

julia> sinh(1 + 2im)
-0.4890562590412937 + 1.4031192506220405im

Beachten Sie, dass mathematische Funktionen normalerweise reelle Werte zurückgeben, wenn sie auf reelle Zahlen angewendet werden, und komplexe Werte zurückgeben, wenn sie auf komplexe Zahlen angewendet werden. Zum Beispiel verhält sich sqrt anders, wenn es auf -1 und -1 + 0im angewendet wird, obwohl -1 == -1 + 0im:

Beispiele

julia> sqrt(-1)
FEHLER: DomainError mit -1.0:
sqrt gibt nur dann ein komplexes Ergebnis zurück , wenn es mit einem komplexen Argument aufgerufen wird. Versuche sqrt(Complex(x)).
Stacktrace:
[...]

julia> sqrt(-1 + 0im)
0.0 + 1.0im

Beim Konstruieren komplexer Zahlen aus Variablen gilt die Notation mit numerischen Literalkoeffizienten nicht mehr. Stattdessen muss die Multiplikation explizit geschrieben werden:

Beispiele

julia> a = 1; b = 2; a + b*im
1 + 2im

Dies wird jedoch nicht empfohlen. Stattdessen sollten Sie die effizientere complex-Funktion verwenden, um direkt einen komplexen Wert aus dem Real- und dem Imaginärteil zu konstruieren:

Beispiele

julia> a = 1; b = 2; complex(a, b)
1 + 2im

Diese Konstruktion vermeidet Multiplikations- und Additionsoperationen.

Inf und NaN können in den Real- und Imaginärteilen komplexer Zahlen auftreten, wie im Abschnitt über spezielle Gleitkommawerte beschrieben:

Beispiele

julia> 1 + Inf*im
1.0 + Inf*im

julia> 1 + NaN*im
1.0 + NaN*im

Rationale Zahlen

Rationale Zahlen sind der Sammelbegriff für ganze Zahlen (positive ganze Zahlen, 0, negative ganze Zahlen) und Brüche und sind die Menge der ganzen Zahlen und Brüche.

Mathematisch werden Zahlen, die als Verhältnis zweier ganzer Zahlen (, ) ausgedrückt werden können, als rationale Zahlen definiert, zum Beispiel, 0.75 (was ausgedrückt werden kann als). Ganze Zahlen und Brüche werden zusammen als rationale Zahlen bezeichnet. Im Gegensatz zu rationalen Zahlen stehen irrationale Zahlen, wiedie nicht als Verhältnis ganzer Zahlen ausgedrückt werden können.

Julia hat einen Bruchtyp zur Darstellung exakter Verhältnisse ganzer Zahlen. Brüche werden mit dem//-Operator konstruiert:

Beispiele

julia> 2//3
2//3

Wenn Zähler und Nenner eines Bruchs gemeinsame Faktoren haben, werden sie auf die einfachste Form gekürzt und der Nenner ist nicht negativ:

Beispiele

julia> 6//9
2//3

julia> -4//8
-1//2

julia> 5//-15
-1//3

julia> -4//-12
1//3

Diese standardisierte Form ganzzahliger Verhältnisse ist eindeutig, sodass die Gleichheit von Bruchwerten geprüft werden kann, indem man prüft, dass sowohl die Zähler als auch die Nenner gleich sind. Der standardisierte Zähler und Nenner eines Bruchwerts können mit den Funktionen numerator und denominator abgerufen werden:

Beispiele

julia> numerator(2//3)
2

julia> denominator(2//3)
3

Ein direkter Vergleich von Zählern und Nennern ist normalerweise unnötig, da auch standardmäßige Arithmetik- und Vergleichsoperationen für Bruchwerte definiert sind:

Beispiele

julia> 2//3 == 6//9
wahr

julia> 2//3 == 9//27
false

julia> 3//7 < 1//2
wahr

julia> 3//4 > 2//3
wahr

julia> 2//4 + 1//6
2//3

julia> 5//12 - 1//4
1//6

julia> 5//8 * 3//12
5//32

julia> 6//5 / 10//7
21//25

Brüche können leicht in Gleitkommazahlen umgewandelt werden:

Beispiele

julia> float(3//4)
0.75

Für beliebige ganzzahlige Werte a und b (außer wenn a == 0 und b == 0) gilt für die Umwandlung von Brüchen in Gleitkommazahlen die folgende Konsistenz:

Beispiele

julia> a = 1; b = 2;

julia> isequal(float(a//b), a/b)
wahr

Julia akzeptiert die Konstruktion unendlicher Bruchwerte:

Beispiele

julia> 5//0
1//0

julia> x = -3//0
-1//0

julia> typeof(x)
Rational{Int64}

Es akzeptiert jedoch nicht den Versuch, einen NaN-Bruchwert zu konstruieren:

Beispiele

julia> 0//0
FEHLER: ArgumentError: ungültiges Rational: zero(Int64)//zero(Int64)
Stacktrace:
[...]

Wie üblich erleichtert das Typ-Promotion-System die Interaktion von Brüchen mit anderen numerischen Typen:

Beispiele

julia> 3//5 + 1
8//5

julia> 3//5 - 0.5
0.09999999999999998

julia> 2//7 * (1 + 2im)
2//7 + 4//7*im

julia> 2//7 * (1.5 + 2im)
0.42857142857142855 + 0.5714285714285714im

julia> 3//2 / (1 + 2im)
3//10 - 3//5*im

julia> 1//2 + 2im
1//2 + 2//1*im

julia> 1 + 2//3im
1//1 - 2//3*im

julia> 0.5 == 1//2
wahr

julia> 0.33 == 1//3
false

julia> 0.33 < 1//3
wahr

julia> 1//3 - 0.33
0.0033333333333332993
Andere Erweiterungen