Quaternion - Versionsgeschichte

Glawesome: /* Siehe auch */

2014-01-03T16:15:05Z

‎Siehe auch

Openglerf: Ausserdem -> Außerdem

2012-03-21T14:54:51Z

Ausserdem -> Außerdem

Delph: Erläuterungen

2009-06-19T09:45:48Z

Erläuterungen

DGLBot: Der Ausdruck ''(.*?)'' wurde ersetzt mit ''$1''.

2009-03-10T18:45:04Z

Der Ausdruck ''<cpp>(.*?)</cpp>'' wurde ersetzt mit ''<source lang="cpp">$1</source>''.

Nico Michaelis: /* Einige Implementationsdetails */ Ein paar kommentare

2007-07-19T05:04:57Z

‎Einige Implementationsdetails: Ein paar kommentare

Nico Michaelis: /* Einige Implementationsdetails */

2007-02-17T09:20:36Z

‎Einige Implementationsdetails

Nico Michaelis: /* Einige Implementationsdetails */ Zeilenumbrüche im Code

2007-02-17T09:18:23Z

‎Einige Implementationsdetails: Zeilenumbrüche im Code

Nico Michaelis: Implementationsdetails

2007-02-17T09:17:24Z

Implementationsdetails

Nico Michaelis: /* Isometrien auf Quaternionen */ Math. Symb

2006-10-12T12:00:27Z

‎Isometrien auf Quaternionen: Math. Symb

Nico Michaelis: Superpositionen

2006-10-12T10:55:25Z

Superpositionen

← Nächstältere Version		Version vom 3. Januar 2014, 16:15 Uhr
Zeile 206:		Zeile 206:
	* Ein Vektor (x,y,z) wird in der Quaternionenwelt zu v := 0 + xi + yj + zk. Rotationsquaternionen Q werden dann angewendet durch Qvkonj(Q). Siehe Implementationsdetails "Vertex3 Apply(Vertex3 v)".		* Ein Vektor (x,y,z) wird in der Quaternionenwelt zu v := 0 + xi + yj + zk. Rotationsquaternionen Q werden dann angewendet durch Qvkonj(Q). Siehe Implementationsdetails "Vertex3 Apply(Vertex3 v)".
	* Um Quaternionen an OpenGl zu übergeben, müssen die "Einheitsvektoren" 1i,1j,1k einzeln wie Vertices gerechnet werden, also Qikonj(Q), Qjkonj(Q), Qkkonj(Q). Wenn man dazu "Vertex3 Apply(Vertex3 v)" ein wenig abändert und wiederverwertbare Ergebnisse aufhebt, kann man viele Rechnungen sparen. Das Ergebnis setzt man dann als Spalten in die Matrix ein und kann dann übergeben werden.		* Um Quaternionen an OpenGl zu übergeben, müssen die "Einheitsvektoren" 1i,1j,1k einzeln wie Vertices gerechnet werden, also Qikonj(Q), Qjkonj(Q), Qkkonj(Q). Wenn man dazu "Vertex3 Apply(Vertex3 v)" ein wenig abändert und wiederverwertbare Ergebnisse aufhebt, kann man viele Rechnungen sparen. Das Ergebnis setzt man dann als Spalten in die Matrix ein und kann dann übergeben werden.
		+
		+	==Siehe auch==
		+	[[Dual Quaternion]]<br>
		+	[[Charakteranimation]]

@@ Zeile 121: / Zeile 121: @@
 denn d.h. der Realteil der Drehung muss auf cos(&alpha;) gesetzt werden und die Drehachse wird mit sin(&alpha;) multipliziert und in den reinen Imaginärteil gesteckt (die Komponenten i,j,k werden gerade zu x,y,z im Koordinatensystem).
-Ausserdem sollte man die wesentlichen Operationen implementeiren, etwa:
+Außerdem sollte man die wesentlichen Operationen implementeiren, etwa:
 <source lang="cpp">        public Quaternion Conjugate()
+         {

← Nächstältere Version		Version vom 19. Juni 2009, 09:45 Uhr
Zeile 186:		Zeile 186:
	return result;		return result;
	}</source>		}</source>
		+
		+	== Einsatz von Quaternionen in der 3D-Grafik ==
		+	Warum also sind Quaternionen nützlich in der 3D Grafik?
		+	* Man kann sie einsetzen, um Rotationen platzsparend zu speichern. In einigen Anwendungen werden pro Objekt eine Rotationsmatrix samt Translation gespeichert, um die Ausrichtung eines Objektes zu beschreiben. Das ergibt 16 Werte pro Objekt. Nimmt man stattdessen Quaternionen (mit Norm 1) und einen Translationsvektor, ergeben sich 4+3=7 Werte, also weniger als die Hälfte.
		+	* Multipliziert man Quaternionen mit Quaternionen, "dreht also das Objekt weiter", ergeben sich 4x4=16 Multiplikationen und Additionen. Bei Rotationsmatrizen benötigt man mind. 3x3x3=27 Multiplikationen.
		+	* Wendet man Quaternionen auf ein Vertex an (die entsprechen im obigen den Quaternionen V), dann kommt man auf 18 Multiplikationen. Bei Rotationsmatrizen sind es mind. 9.
		+	* Will man Quaternionen (Norm 1) invertieren, muss man die drei i,j,k Komponenten mit einem minus versehen. Rotationsmatrizen werden durch systematisches vertauschen von 6 Werten [[Techniken zur Matrixinversion\|invertiert]].
		+	* Will man aus einem Quaternion eine Rotationsmatrix machen, etwa um sie per [[glLoadMatrix]] and OpenGl zu übergeben, benötigt man (indem man das Quaternionen einzeln mit i,j und k multipliziert, also den Einheitsvektoren) benötigt man 3*14 Multiplikationen. Matrizen kommen ohne Bearbeitung aus.
		+	* Quaternionen beschreiben Rotationen Q = cos(α) + sin(α)*P, 0<=α<=π, P aus V, \|\|P\|\| = 1, also durch Rotationswinkel α und Drehachse P und sind damit auf einen Blick anschaulicher als eine Rotationsmatrix.
		+
		+	Quaternionen sind also insbesondere dann nützlich, wenn man viele Objekte mit wenig Speicherplatz ablegen möchte und stark rekursiv abhängige Drehungen von den Objekten untereinander hat (etwa Finger an Hand an Unterarm an Oberarm an Schulter an Körper) und man damit viel rechnen muss. Zum reinen Darstellen sind sie dagegen Kontraproduktiv, da man sie zur Übergabe an OpenGl erst umrechnen muss. Dies entfällt bei manch anderen Render-Techniken, etwa Raytracing.
		+
		+	=== Umstieg Matrizen Quaternionen ===
		+	Da OpenGl Grafiker oft bereits einges an Erfahrung mit Matrizen haben, nur ein paar kleine Anmerkungen, wie beide Welten zusammenhängen.
		+
		+	* Gespeichert werden die 4 Komponenten (a,b,c,d) des Quaternion, geschrieben immer als a + bi + cj + dk.
		+	* Die Einheitsmatrix wird durch das Einheitsquaternion 1 + 0i + 0j + 0k ausgedrückt.
		+	* Rotationen sind die Quaternionen mit Norm 1.
		+	* Ein Vektor (x,y,z) wird in der Quaternionenwelt zu v := 0 + xi + yj + zk. Rotationsquaternionen Q werden dann angewendet durch Qvkonj(Q). Siehe Implementationsdetails "Vertex3 Apply(Vertex3 v)".
		+	* Um Quaternionen an OpenGl zu übergeben, müssen die "Einheitsvektoren" 1i,1j,1k einzeln wie Vertices gerechnet werden, also Qikonj(Q), Qjkonj(Q), Qkkonj(Q). Wenn man dazu "Vertex3 Apply(Vertex3 v)" ein wenig abändert und wiederverwertbare Ergebnisse aufhebt, kann man viele Rechnungen sparen. Das Ergebnis setzt man dann als Spalten in die Matrix ein und kann dann übergeben werden.

@@ Zeile 100: / Zeile 100: @@
 == Einige Implementationsdetails ==
 Am besten speichert man ein Quaternion duch speichern der 4 Komponenten in einem Array (Reihenfolge: realteil, i, j, k - Komponente, bzw. a,b,c,d):
-<cpp>    public sealed class Quaternion : ILinearTransformation
+<source lang="cpp">    public sealed class Quaternion : ILinearTransformation
+     {
-         private double[] coords = new double[4];</cpp>
+         private double[] coords = new double[4];</source>
 Ein besonders spannender Konstruktor für Quaternion ist der, der "rotations-Quaternionen" erstellt. Übergeben wird also ein Vektor, der die Drehachse beschreibt, sowie ein passender Winkel:
-<cpp>        public Quaternion(double alpha, Vertex3 rotAxis)
+<source lang="cpp">        public Quaternion(double alpha, Vertex3 rotAxis)
+         {
              alpha = (2.0*Math.PI/(360.0*2.0))* alpha;
@@ Zeile 116: / Zeile 116: @@
              coords[0] = c; coords[1] = rotAxis[0] * s;
              coords[2] = rotAxis[1] * s; coords[3] = rotAxis[2] * s;
-         }</cpp>
+         }</source>
 Diese Funktion ergibt sich ganz einfach aus der obigen Formel:
   Q = cos(&alpha;) + sin(&alpha;)*P, 0<=&alpha;<=&pi;, P aus V, ||P|| = 1,
@@ Zeile 122: / Zeile 122: @@
 Ausserdem sollte man die wesentlichen Operationen implementeiren, etwa:
-<cpp>        public Quaternion Conjugate()
+<source lang="cpp">        public Quaternion Conjugate()
+         {
              return new Quaternion(coords[0], -coords[1], -coords[2], -coords[3]);
-         }</cpp>
+         }</source>
 Die Konjugation dreht also wie oben definiert gerade die Vorzeichen der Imaginärteile um.
 Genauso implementiert man die anderen Operationen nach:
-<cpp> ...
+<source lang="cpp"> ...
          public static Quaternion Multiply(Quaternion q1, Quaternion q2)
+         {
@@ Zeile 160: / Zeile 160: @@
              if (mag == 0.0) return null;
              return Conjugate().Scale(1.0 / mag);
-         }</cpp>
+         }</source>
 Besonders spannend ist sicherlich auch das Anwenden eines Rotations-Quaternions auf ein Vertex. Diese Funktion entsteht, wenn man die oben genannte Funktion &phi; explizit aufschreibt und ausrechnet. Es ergibt sich dabei eine wenig spannende, aber sehr ausladende Rechnung, um am Ende alles richtig ausmultipliziert und nach komponente sortiert zu haben (nicht vergessen: man darf dabei nur reele Zahlen miteinander Tauschen, sowie reele Zahlen mit i,j,k. i,j,k aber letztere nie miteinander, sonst stimmen die Vorzeichen nicht! Um ein Produkt aus i,j,k loszuwerden verwendet man die Tabelle, welche unter der Definition der Quaternionen gegeben ist -- die Multiplikation war nicht kommutativ:
-<cpp>        public Vertex3 Apply(Vertex3 v)
+<source lang="cpp">        public Vertex3 Apply(Vertex3 v)
+         {
              Vertex3 result = new Vertex3();
@@ Zeile 185: / Zeile 185: @@
                  + 2 * (a13 * v0 + a23 * v1 - a02 * v0 + a01 * v1);
              return result;
-         }</cpp>
+         }</source>

@@ Zeile 117: / Zeile 117: @@
              coords[2] = rotAxis[1] * s; coords[3] = rotAxis[2] * s;
          }</cpp>
 Ausserdem sollte man die wesentlichen Operationen implementeiren, etwa:
 <cpp>        public Quaternion Conjugate()
+         {
              return new Quaternion(coords[0], -coords[1], -coords[2], -coords[3]);
+         }</cpp>
- ...
+Die Konjugation dreht also wie oben definiert gerade die Vorzeichen der Imaginärteile um.
          public static Quaternion Multiply(Quaternion q1, Quaternion q2)
+         {
@@ Zeile 154: / Zeile 161: @@
              return Conjugate().Scale(1.0 / mag);
          }</cpp>
-Besonders spannend ist sicherlich auch das Anwenden eines Rotations-Quaternions auf ein Vertex. Diese Funktion entsteht, wenn man die oben genannte Funktion &phi; explizit aufschreibt und ausrechnet. Es ergibt sich dabei eine wenig spannende, aber sehr ausladende Rechnung, um am Ende alles richtig ausmultipliziert und nach komponente sortiert zu haben (nicht vergessen: man darf dabei nur reele Zahlen miteinander Tauschen, sowie reele Zahlen mit i,j,k. i,j,k aber nie miteinander, sonst stimmen die Vorzeichen nicht! Die Quaternion-Multiplikation war nicht kommutativ):
+Besonders spannend ist sicherlich auch das Anwenden eines Rotations-Quaternions auf ein Vertex. Diese Funktion entsteht, wenn man die oben genannte Funktion &phi; explizit aufschreibt und ausrechnet. Es ergibt sich dabei eine wenig spannende, aber sehr ausladende Rechnung, um am Ende alles richtig ausmultipliziert und nach komponente sortiert zu haben (nicht vergessen: man darf dabei nur reele Zahlen miteinander Tauschen, sowie reele Zahlen mit i,j,k. i,j,k aber letztere nie miteinander, sonst stimmen die Vorzeichen nicht! Um ein Produkt aus i,j,k loszuwerden verwendet man die Tabelle, welche unter der Definition der Quaternionen gegeben ist -- die Multiplikation war nicht kommutativ:
 <cpp>        public Vertex3 Apply(Vertex3 v)
+         {

@@ Zeile 171: / Zeile 171: @@
              double a23 = coords[2] * coords[3];
              double a33 = coords[3] * coords[3];
-             result[0] = v0 * (+a00 + a11 - a22 - a33) + 2 * (a12 * v1 + a13 * v2 + a02 * v2 - a03 * v1);
+             result[0] = v0 * (+a00 + a11 - a22 - a33)
-             result[1] = v1 * (+a00 - a11 + a22 - a33) + 2 * (a12 * v0 + a23 * v2 + a03 * v0 - a01 * v2);
+                + 2 * (a12 * v1 + a13 * v2 + a02 * v2 - a03 * v1);
-             result[2] = v2 * (+a00 - a11 - a22 + a33) + 2 * (a13 * v0 + a23 * v1 - a02 * v0 + a01 * v1);
+             result[1] = v1 * (+a00 - a11 + a22 - a33)
              return result;
          }</cpp>

← Nächstältere Version		Version vom 17. Februar 2007, 09:17 Uhr
Zeile 97:		Zeile 97:
	Q = cos(α) + sin(α)*P, 0<=α<=π, P aus V, \|\|P\|\| = 1,		Q = cos(α) + sin(α)*P, 0<=α<=π, P aus V, \|\|P\|\| = 1,
	wobei dann φ(Q,x) eine Drehung von x (man beachte, dass dabei x aus V ist) um den Winkel 2*α um die Achse P darstellt.		wobei dann φ(Q,x) eine Drehung von x (man beachte, dass dabei x aus V ist) um den Winkel 2*α um die Achse P darstellt.
		+
		+	== Einige Implementationsdetails ==
		+	Am besten speichert man ein Quaternion duch speichern der 4 Komponenten in einem Array (Reihenfolge: realteil, i, j, k - Komponente):
		+	<cpp> public sealed class Quaternion : ILinearTransformation
		+	{
		+	private double[] coords = new double[4];</cpp>
		+	Ein besonders spannender Konstruktor für Quaternion ist der, der "rotations-Quaternionen" erstellt. Übergeben wird also ein Vektor, der die Drehachse beschreibt, sowie ein passender Winkel:
		+	<cpp> public Quaternion(double alpha, Vertex3 rotAxis)
		+	{
		+	alpha = (2.0Math.PI/(360.02.0))* alpha;
		+
		+	coords[0] = 1.0;
		+	if (rotAxis.Magnitude < double.Epsilon)
		+	return;
		+
		+	rotAxis.Normalize();
		+	double c = Math.Cos(alpha), s = Math.Sin(alpha);
		+	coords[0] = c; coords[1] = rotAxis[0] * s;
		+	coords[2] = rotAxis[1] * s; coords[3] = rotAxis[2] * s;
		+	}</cpp>
		+	Ausserdem sollte man die wesentlichen Operationen implementeiren, etwa:
		+	<cpp> public Quaternion Conjugate()
		+	{
		+	return new Quaternion(coords[0], -coords[1], -coords[2], -coords[3]);
		+	}
		+	...
		+	public static Quaternion Multiply(Quaternion q1, Quaternion q2)
		+	{
		+	if (q1 == null) throw new ArgumentNullException("q1");
		+	if (q2 == null) throw new ArgumentNullException("q2");
		+	Quaternion result = new Quaternion();
		+	result.coords[0] = q1.coords[0] * q2.coords[0]
		+	- q1.coords[1] * q2.coords[1]
		+	- q1.coords[2] * q2.coords[2]
		+	- q1.coords[3] * q2.coords[3];
		+	result.coords[1] = q1.coords[0] * q2.coords[1]
		+	+ q1.coords[1] * q2.coords[0]
		+	+ q1.coords[2] * q2.coords[3]
		+	- q1.coords[3] * q2.coords[2];
		+	result.coords[2] = q1.coords[0] * q2.coords[2]
		+	- q1.coords[1] * q2.coords[3]
		+	+ q1.coords[2] * q2.coords[0]
		+	+ q1.coords[3] * q2.coords[1];
		+	result.coords[3] = q1.coords[0] * q2.coords[3]
		+	+ q1.coords[1] * q2.coords[2]
		+	- q1.coords[2] * q2.coords[1]
		+	+ q1.coords[3] * q2.coords[0];
		+	return result;
		+	}
		+	...
		+	public Quaternion Inverse()
		+	{
		+	double mag = Magnitude;
		+	mag = mag * mag;
		+	if (mag == 0.0) return null;
		+	return Conjugate().Scale(1.0 / mag);
		+	}</cpp>
		+	Besonders spannend ist sicherlich auch das Anwenden eines Rotations-Quaternions auf ein Vertex. Diese Funktion entsteht, wenn man die oben genannte Funktion φ explizit aufschreibt und ausrechnet. Es ergibt sich dabei eine wenig spannende, aber sehr ausladende Rechnung, um am Ende alles richtig ausmultipliziert und nach komponente sortiert zu haben (nicht vergessen: man darf dabei nur reele Zahlen miteinander Tauschen, sowie reele Zahlen mit i,j,k. i,j,k aber nie miteinander, sonst stimmen die Vorzeichen nicht! Die Quaternion-Multiplikation war nicht kommutativ):
		+	<cpp> public Vertex3 Apply(Vertex3 v)
		+	{
		+	Vertex3 result = new Vertex3();
		+	double v0 = v[0];
		+	double v1 = v[1];
		+	double v2 = v[2];
		+	double a00 = coords[0] * coords[0];
		+	double a01 = coords[0] * coords[1];
		+	double a02 = coords[0] * coords[2];
		+	double a03 = coords[0] * coords[3];
		+	double a11 = coords[1] * coords[1];
		+	double a12 = coords[1] * coords[2];
		+	double a13 = coords[1] * coords[3];
		+	double a22 = coords[2] * coords[2];
		+	double a23 = coords[2] * coords[3];
		+	double a33 = coords[3] * coords[3];
		+	result[0] = v0 * (+a00 + a11 - a22 - a33) + 2 * (a12 * v1 + a13 * v2 + a02 * v2 - a03 * v1);
		+	result[1] = v1 * (+a00 - a11 + a22 - a33) + 2 * (a12 * v0 + a23 * v2 + a03 * v0 - a01 * v2);
		+	result[2] = v2 * (+a00 - a11 - a22 + a33) + 2 * (a13 * v0 + a23 * v1 - a02 * v0 + a01 * v1);
		+	return result;
		+	}</cpp>

@@ Zeile 72: / Zeile 72: @@
 ==== Isometrien auf H ====
 Die Isometrien der Quaternionen auf sich selbst (also die Isometrien des 4D-Raumes) lassen sich in Quaternionen beschreiben durch zwei Quaternionen P,Q, mit ||P||=||Q|| = 1 und den Abbildungen
-  Phi(P,Q,.): H -> H,
+  &phi;(P,Q,.): H -> H,
-  x -> Phi(P,Q,x) := P*x*konj(Q) = P*x*(Q<sup>-1</sup>)
+  x -> &phi;(P,Q,x) := P*x*konj(Q) = P*x*Q<sup>-1</sup>
-  Psi(P,Q,.): H -> H
+  &psi;(P,Q,.): H -> H
-  x -> Psi(P,Q,x) := P*konj(x)*konj(Q) = P*konj(x)*(Q<sup>-1</sup>)
+  x -> &psi;(P,Q,x) := P*konj(x)*konj(Q) = P*konj(x)*Q<sup>-1</sup>
 Dabei gilt für Quaternionen P',Q' mit ||P'||=||Q'||=1:
-  Phi(P,Q,Phi(P',Q',.)) = Phi(P*P',Q*Q',.)
+  &phi;(P,Q,&phi;(P',Q',.)) = &phi;(P*P',Q*Q',.)
-  Phi(P,Q,Psi(P',Q',.)) = Psi(P*P',Q*Q',.)
+  &phi;(P,Q,&psi;(P',Q',.)) = &psi;(P*P',Q*Q',.)
-  Psi(P,Q,Psi(P',Q',.)) = Phi(P*Q',Q*P',.)
+  &psi;(P,Q,&psi;(P',Q',.)) = &phi;(P*Q',Q*P',.)
-  Psi(P,Q,Phi(P',Q',.)) = Psi(P*Q',Q*P',.),
+  &psi;(P,Q,&phi;(P',Q',.)) = &psi;(P*Q',Q*P',.),
 was man ohne weiteres ausrechnen kann.
 ==== Isometrien auf V ====
 Der Fall der Isometrien auf den reinen Quaternionen V (siehe Definition) ist der für die 3D Grafik interessante Fall. Sie stellen die Rotationen auf V dar und das in einer besonders leicht lesbaren Form. Sei also Q eine Quaternion der Norm 1, dann gehört dazu eine Isometrie auf V:
-  Phi(Q,.): V -> V
+  &phi;(Q,.): V -> V
-  x -> Phi(Q,x) := Phi(Q,Q,x) = Q*x*konj(Q) = Q*x*Q<sup>-1</sup>,
+  x -> &phi;(Q,x) := &phi;(Q,Q,x) = Q*x*konj(Q) = Q*x*Q<sup>-1</sup>,
-wobei offensichtlich Phi(-Q,.) = Phi(Q,.), Q und -Q beschreiben also die selbe Drehung.
+wobei offensichtlich &phi;(-Q,.) = &phi;(Q,.), Q und -Q beschreiben also die selbe Drehung.
-Und entsprechnd der Rechenregeln für Phi auf H (siehe oben) gilt mit einem Quaternion Q' mit ||Q'||=1:
+Und entsprechnd der Rechenregeln für &phi; auf H (siehe oben) gilt mit einem Quaternion Q' mit ||Q'||=1:
-  Phi(Q, Phi(Q', x)) = Q*Q'*x*konj(Q')*konj(Q) = (Q*Q')*x*konj(Q*Q') = Phi(Q*Q',x)
+  &phi;(Q, &phi;(Q', x)) = Q*Q'*x*konj(Q')*konj(Q) = (Q*Q')*x*konj(Q*Q') = &phi;(Q*Q',x)
 Man kann Q sehr leicht zerlegen in:
-  Q = cos(alpha) + sin(alpha)*P, 0<=alpha<=Pi, P aus V, ||P|| = 1,
+  Q = cos(&alpha;) + sin(&alpha;)*P, 0<=&alpha;<=&pi;, P aus V, ||P|| = 1,
-wobei dann Phi(Q,x) eine Drehung von x (man beachte, dass dabei x aus V ist) um den Winkel 2*alpha um die Achse P darstellt.
+wobei dann &phi;(Q,x) eine Drehung von x (man beachte, dass dabei x aus V ist) um den Winkel 2*&alpha; um die Achse P darstellt.

@@ Zeile 53: / Zeile 53: @@
   ||q||^2 = q * konj(q)
   <=>
-= (q * konj(q)) / ||q||^2
+= (q * konj(q)) / ||q||<sup>2</sup>
-  h := konj(q) / ||q||^2
+  h := konj(q) / ||q||<sup>2</sup>
   => 1 = q * h
 Und weil offensichtlich ||q|| = ||konj(q)|| gilt, folgt
-  ||q||^2 = ||konj(q)||^2 = konj(q)*konj(konj(q)) = konj(q)*q
+  ||q||<sup>2</sup> = ||konj(q)||<sup>2</sup> = konj(q)*konj(konj(q)) = konj(q)*q
 Und damit:
 = h * q.
-h ist also das multiplikativ invers zu q: h = q^(-1)
+h ist also das multiplikativ invers zu q: h = q<sup>-1</sup>
 === Injektion der Reelen und Komplexen Zahlen ===
@@ Zeile 73: / Zeile 73: @@
 Die Isometrien der Quaternionen auf sich selbst (also die Isometrien des 4D-Raumes) lassen sich in Quaternionen beschreiben durch zwei Quaternionen P,Q, mit ||P||=||Q|| = 1 und den Abbildungen
   Phi(P,Q,.): H -> H,
-  x -> Phi(P,Q,x) := P*x*konj(Q) = P*x*(Q^(-1))
+  x -> Phi(P,Q,x) := P*x*konj(Q) = P*x*(Q<sup>-1</sup>)
   Psi(P,Q,.): H -> H
-  x -> Psi(P,Q,x) := P*konj(x)*konj(Q) = P*konj(x)*(Q^(-1))
+  x -> Psi(P,Q,x) := P*konj(x)*konj(Q) = P*konj(x)*(Q<sup>-1</sup>)
 Dabei gilt für Quaternionen P',Q' mit ||P'||=||Q'||=1:
@@ Zeile 89: / Zeile 89: @@
 Der Fall der Isometrien auf den reinen Quaternionen V (siehe Definition) ist der für die 3D Grafik interessante Fall. Sie stellen die Rotationen auf V dar und das in einer besonders leicht lesbaren Form. Sei also Q eine Quaternion der Norm 1, dann gehört dazu eine Isometrie auf V:
   Phi(Q,.): V -> V
-  x -> Phi(Q,x) := Phi(Q,Q,x) = Q*x*konj(Q) = Q*x*Q^-1,
+  x -> Phi(Q,x) := Phi(Q,Q,x) = Q*x*konj(Q) = Q*x*Q<sup>-1</sup>,
 wobei offensichtlich Phi(-Q,.) = Phi(Q,.), Q und -Q beschreiben also die selbe Drehung.
 Und entsprechnd der Rechenregeln für Phi auf H (siehe oben) gilt mit einem Quaternion Q' mit ||Q'||=1: