Cette page a été traduite par traduction automatique. Cliquez ici pour voir la dernière version en anglais.

quaternion

Créer un tableau de quaternions

Depuis R2019b

Description

Un quaternion est un nombre hyper-complexe en quatre parties utilisé dans les rotations et orientations tridimensionnelles.

Un nombre de quaternion est représenté sous la forme $$a+b\text{i}+c\text{j}+d\text{k}$$, où a, b, c et Les parties d sont des nombres réels, et i, j et k sont les éléments de base, satisfaisant l'équation : i² = j² = k² = ijk = −1.

L'ensemble des quaternions, noté H, est défini dans un espace vectoriel à quatre dimensions sur les nombres réels, R⁴. Chaque élément de H a une représentation unique basée sur une combinaison linéaire des éléments de base i, j et k.

Toutes les rotations en 3D peuvent être décrites par un axe de rotation et un angle autour de cet axe. Un avantage des quaternions par rapport aux matrices de rotation est que l'axe et l'angle de rotation sont faciles à interpréter. Par exemple, considérons un point dans R³. Pour faire pivoter le point, vous définissez un axe de rotation et un angle de rotation.

La représentation quaternion de la rotation peut être exprimée par $$q=\cos \left(\raisebox{1ex}{$\theta $}\!\left/ \!\raisebox{-1ex}{$2$}\right.\right)+\sin \left(\raisebox{1ex}{$\theta $}\!\left/ \!\raisebox{-1ex}{$2$}\right.\right)\left(u_b\text{i}+u_c\text{j}+u_d\text{k}\right)$$, où θ est l'angle de rotation et [u_b, u_c, et u_d] est l'axe de rotation.

Création

Syntaxe

quat = quaternion()

quat = quaternion(A,B,C,D)

quat = quaternion(matrix)

quat = quaternion(RV,"rotvec")

quat = quaternion(RV,"rotvecd")

quat = quaternion(RM,"rotmat",PF)

quat = quaternion(E,"euler",RS,PF)

quat = quaternion(E,"eulerd",RS,PF)

quat = quaternion(transformation)

quat = quaternion(rotation)

Description

quat = quaternion() crée un quaternion vide.

quat = quaternion(A,B,C,D) crée un tableau de quaternions où les quatre parties de quaternions sont extraites des tableaux A, B, C et D. Toutes les entrées doivent avoir la même taille et être du même type de données.

quat = quaternion(matrix) crée un tableau de quaternions N-by-1 à partir d'une matrice N-by-4, où chaque colonne devient une partie de le quaternion.

quat = quaternion(RV,"rotvec") crée un tableau de quaternions N-par 1 à partir d'un N-par-3 matrice de vecteurs de rotation, RV. Chaque ligne de RV représente un vecteur de rotation en radians.

quat = quaternion(RV,"rotvecd") crée un tableau de quaternions N-par 1 à partir d'un N-par-3 matrice de vecteurs de rotation, RV. Chaque ligne de RV représente un vecteur de rotation en degrés.

quat = quaternion(RM,"rotmat",PF) crée un tableau de quaternions N-by-1 à partir du tableau 3-by-3-by- N de matrices de rotation, RM. PF peut être soit "point" si les angles d'Euler représentent des rotations de points, soit "frame" pour les rotations de trames.

quat = quaternion(E,"euler",RS,PF) crée un tableau de quaternions N-by-1 à partir de la matrice N-by-3, E. Chaque ligne de E représente un ensemble d'angles d'Euler en radians. Les angles dans E sont des rotations autour des axes dans la séquence RS.

quat = quaternion(E,"eulerd",RS,PF) crée un tableau de quaternions N-by-1 à partir de la matrice N-by-3, E. Chaque ligne de E représente un ensemble d'angles d'Euler en degrés. Les angles dans E sont des rotations autour des axes dans la séquence RS.

quat = quaternion(transformation) crée un tableau de quaternions à partir de la transformation SE(3) transformation.

quat = quaternion(rotation) crée un tableau de quaternions à partir de la rotation SO(3) rotation.

Arguments en entrée

A,B,C,D — Pièces de quaternion

tableaux séparés par des virgules de même taille

Parties d'un quaternion, spécifiées sous forme de quatre scalaires, matrices ou tableaux multidimensionnels de même taille, séparés par des virgules.

Exemple : quat = quaternion(1,2,3,4) crée un quaternion de la forme 1 + 2i + 3j + 4k.

Exemple : quat = quaternion([1,5],[2,6],[3,7],[4,8]) crée un tableau de quaternions 1 par 2 où quat(1,1) = 1 + 2i + 3j + 4k et quat(1,2) = 5 + 6i + 7j + 8k

Types de données : single | double

matrix — Matrice de parties de quaternions

N-matrice par 4

Matrice de parties de quaternions, spécifiée comme une matrice N-by-4. Chaque ligne représente un quaternion distinct. Chaque colonne représente une partie de quaternion distincte.

Exemple : quat = quaternion(rand(10,4)) crée un tableau de quaternions 10 par 1.

Types de données : single | double

RV — Matrice de vecteurs de rotation

N-matrice par 3

Matrice de vecteurs de rotation, spécifiée comme une matrice N-by-3. Chaque ligne de RV représente les éléments [XYZ] d'un vecteur de rotation. Un vecteur de rotation est un vecteur unitaire représentant l'axe de rotation mis à l'échelle par l'angle de rotation en radians ou en degrés.

Pour utiliser cette syntaxe, spécifiez le premier argument comme une matrice de vecteurs de rotation et le deuxième argument comme "rotvec" ou "rotvecd".

Exemple : quat = quaternion(rand(10,3),"rotvec") crée un tableau de quaternions 10 par 1.

Types de données : single | double

RM — Matrices de rotation

Matrice 3x3 | Tableau 3 par 3 par N

Tableau de matrices de rotation, spécifié par une matrice 3 par 3 ou un tableau 3 par 3 par N . Chaque page du tableau représente une matrice de rotation distincte.

Exemple : quat = quaternion(rand(3),"rotmat","point")

Exemple : quat = quaternion(rand(3),"rotmat","frame")

Types de données : single | double

PF — Type de matrice de rotation

"point" | "frame"

Type de matrice de rotation, spécifié par "point" ou "frame".

Exemple : quat = quaternion(rand(3),"rotmat","point")

Exemple : quat = quaternion(rand(3),"rotmat","frame")

Types de données : char | string

E — Matrice des angles d'Euler

N-matrice par 3

Matrice d'angles d'Euler, spécifiée par une matrice N-by-3. Si vous utilisez la syntaxe "euler" , spécifiez E en radians. Si vous utilisez la syntaxe "eulerd" , spécifiez E en degrés.

Exemple : quat = quaternion(E,"euler","YZY","point")

Exemple : quat = quaternion(E,"euler","XYZ","frame")

Types de données : single | double

RS — Séquence de rotation

vecteur de caractère | chaîne scalaire

Séquence de rotation, spécifiée comme vecteur de caractères à trois éléments :

• "YZY"

• "YXY"

• "ZYZ"

• "ZXZ"

• "XYX"

• "XZX"

• "XYZ"

• "YZX"

• "ZXY"

• "XZY"

• "ZYX"

• "YXZ"

Supposons que vous souhaitiez déterminer les nouvelles coordonnées d’un point lorsque son système de coordonnées subit une rotation à l’aide de la rotation du cadre. Le point est défini dans le système de coordonnées d'origine comme :

point = [sqrt(2)/2,sqrt(2)/2,0];

Dans cette représentation, la première colonne représente l'axe x, la deuxième colonne représente l'axe y et la troisième colonne représente l'axe z-axe.

Vous souhaitez faire pivoter le point en utilisant la représentation angulaire d'Euler [45,45,0]. Faites pivoter le point en utilisant deux séquences de rotation différentes :

• Si vous créez un rotateur de quaternion et spécifiez la séquence "ZYX", le cadre pivote d'abord de 45° autour de l'axe z, puis de 45° autour du nouveau y.-axe.

  quatRotator = quaternion([45,45,0],"eulerd","ZYX","frame");
  newPointCoordinate = rotateframe(quatRotator,point)

  newPointCoordinate =
  
      0.7071   -0.0000    0.7071

  

• Si vous créez un rotateur de quaternion et spécifiez la séquence "YZX", le cadre pivote d'abord de 45° autour de l'axe y, puis de 45° autour du nouveau z.-axe.

  quatRotator = quaternion([45,45,0],"eulerd","YZX","frame");
  newPointCoordinate = rotateframe(quatRotator,point)

  newPointCoordinate =
  
      0.8536    0.1464    0.5000

  

Types de données : char | string

transformation — Transformation homogène

se3 objet | N- tableau d'éléments d'objets se3

Transformation, spécifiée comme un objet se3 , ou comme un tableau d'éléments N d'objets se3 . N est le nombre total de transformations.

L'objet quaternion ignore la composante de translation de la transformation et convertit la sous-matrice de rotation 3 par 3 de la transformation en quaternion.

rotation — Rotation orthonormale

Objet so3 | N- tableau d'éléments d'objets so3

Rotation orthonormale, spécifiée comme un objet so3 , ou comme un tableau d'éléments N d'objets so3 . N est le nombre total de rotations.

Fonctions d'objet

angvel	Vitesse angulaire du réseau de quaternions
classUnderlying	Class of parts within quaternion
compact	Convertir le tableau de quaternions en matrice N-by-4
conj	Complex conjugate of quaternion
'	Transposition conjuguée complexe d'un tableau de quaternions
dist	Distance angulaire en radians
euler	Convertir un quaternion en angles d'Euler (radians)
eulerd	Convertir un quaternion en angles d'Euler (degrés)
exp	Exponential of quaternion array
.\,ldivide	Element-wise quaternion left division
log	Logarithme népérien du tableau de quaternions
meanrot	Rotation moyenne des quaternions
-	Soustraction de quaternions
*	Multiplication des quaternions
norm	Norme du quaternion
normalize	Normalisation des quaternions
ones	Créer un tableau de quaternions avec des parties réelles définies sur un et des parties imaginaires définies sur zéro
parts	Extraire des parties de quaternion
.^,power	Puissance des quaternions par éléments
prod	Produit d'un tableau de quaternions
randrot	Rotations aléatoires uniformément réparties
./,rdivide	Element-wise quaternion right division
rotateframe	Quaternion frame rotation
rotatepoint	Rotation des points de quaternion
rotmat	Convertir le quaternion en matrice de rotation
rotvec	Convert quaternion to rotation vector (radians)
rotvecd	Convert quaternion to rotation vector (degrees)
slerp	Interpolation linéaire sphérique
.*,times	Multiplication de quaternions par éléments
'	Transposer le tableau de quaternions
-	Quaternion unaire moins
zeros	Créer un tableau de quaternions avec toutes les parties mises à zéro

Exemples

Créer un quaternion vide

quat = quaternion()

quat = 

  0x0 empty quaternion array

Par défaut, la classe sous-jacente du quaternion est un double.

classUnderlying(quat)

ans = 
'double'

Créer un quaternion en spécifiant des parties de quaternion individuelles

Vous pouvez créer un tableau de quaternions en spécifiant les quatre parties sous forme de scalaires, de matrices ou de tableaux multidimensionnels séparés par des virgules de même taille.

Définissez les parties de quaternion comme des scalaires.

A = 1.1;
B = 2.1;
C = 3.1;
D = 4.1;
quatScalar = quaternion(A,B,C,D)

quatScalar = quaternion
     1.1 + 2.1i + 3.1j + 4.1k

Définissez les parties de quaternion en tant que vecteurs de colonnes.

A = [1.1;1.2];
B = [2.1;2.2];
C = [3.1;3.2];
D = [4.1;4.2];
quatVector = quaternion(A,B,C,D)

quatVector = 2x1 quaternion array
     1.1 + 2.1i + 3.1j + 4.1k
     1.2 + 2.2i + 3.2j + 4.2k

Définissez les parties de quaternion sous forme de matrices.

A = [1.1,1.3; ...
     1.2,1.4];
B = [2.1,2.3; ...
     2.2,2.4];
C = [3.1,3.3; ...
     3.2,3.4];
D = [4.1,4.3; ...
     4.2,4.4];
quatMatrix = quaternion(A,B,C,D)

quatMatrix = 2x2 quaternion array
     1.1 + 2.1i + 3.1j + 4.1k     1.3 + 2.3i + 3.3j + 4.3k
     1.2 + 2.2i + 3.2j + 4.2k     1.4 + 2.4i + 3.4j + 4.4k

Définissez les parties de quaternion sous forme de tableaux tridimensionnels.

A = randn(2,2,2);
B = zeros(2,2,2);
C = zeros(2,2,2);
D = zeros(2,2,2);
quatMultiDimArray = quaternion(A,B,C,D)

quatMultiDimArray = 2x2x2 quaternion array
quatMultiDimArray(:,:,1) = 

     0.53767 +       0i +       0j +       0k     -2.2588 +       0i +       0j +       0k
      1.8339 +       0i +       0j +       0k     0.86217 +       0i +       0j +       0k


quatMultiDimArray(:,:,2) = 

     0.31877 +       0i +       0j +       0k    -0.43359 +       0i +       0j +       0k
     -1.3077 +       0i +       0j +       0k     0.34262 +       0i +       0j +       0k

Créer un quaternion en spécifiant une matrice de parties de quaternion

Vous pouvez créer un vecteur scalaire ou colonne de quaternions en spécifiant une matrice N par 4 de parties de quaternions, où les colonnes correspondent aux parties de quaternions A, B, C et D.

Créez un vecteur colonne de quaternions aléatoires.

quatParts = rand(3,4)

quatParts = 3×4

    0.8147    0.9134    0.2785    0.9649
    0.9058    0.6324    0.5469    0.1576
    0.1270    0.0975    0.9575    0.9706

quat = quaternion(quatParts)

quat = 3x1 quaternion array
     0.81472 + 0.91338i +  0.2785j + 0.96489k
     0.90579 + 0.63236i + 0.54688j + 0.15761k
     0.12699 + 0.09754i + 0.95751j + 0.97059k

Pour récupérer la matrice quatParts à partir de la représentation quaternion, utilisez compact.

retrievedquatParts = compact(quat)

retrievedquatParts = 3×4

    0.8147    0.9134    0.2785    0.9649
    0.9058    0.6324    0.5469    0.1576
    0.1270    0.0975    0.9575    0.9706

Créer un quaternion en spécifiant des vecteurs de rotation

Vous pouvez créer un tableau de quaternions N par 1 en spécifiant une matrice N par 3 de vecteurs de rotation en radians ou en degrés. Les vecteurs de rotation sont des représentations spatiales compactes qui ont une relation biunivoque avec les quaternions normalisés.

Vecteurs de rotation en radians

Créez un quaternion scalaire à l'aide d'un vecteur de rotation et vérifiez que le quaternion résultant est normalisé.

rotationVector = [0.3491,0.6283,0.3491];
quat = quaternion(rotationVector,"rotvec")

quat = quaternion
     0.92124 + 0.16994i + 0.30586j + 0.16994k

norm(quat)

ans = 1.0000

Vous pouvez convertir des quaternions en vecteurs de rotation en radians à l'aide de la fonction rotvec . Récupérez le rotationVector du quaternion, quat.

rotvec(quat)

ans = 1×3

    0.3491    0.6283    0.3491

Vecteurs de rotation en degrés

Créez un quaternion scalaire à l'aide d'un vecteur de rotation et vérifiez que le quaternion résultant est normalisé.

rotationVector = [20,36,20];
quat = quaternion(rotationVector,"rotvecd")

quat = quaternion
     0.92125 + 0.16993i + 0.30587j + 0.16993k

norm(quat)

ans = 1

Vous pouvez convertir des quaternions en vecteurs de rotation en degrés à l'aide de la fonction rotvecd . Récupérez le rotationVector du quaternion, quat.

rotvecd(quat)

ans = 1×3

   20.0000   36.0000   20.0000

Créer un quaternion en spécifiant des matrices de rotation

Vous pouvez créer un tableau de quaternions N par 1 en spécifiant un tableau de matrices de rotation 3 par 3 par N. Chaque page du tableau matriciel de rotation correspond à un élément du tableau des quaternions.

Créez un quaternion scalaire à l'aide d'une matrice de rotation 3 par 3. Spécifiez si la matrice de rotation doit être interprétée comme une rotation de cadre ou de point.

rotationMatrix = [1 0         0; ...
                  0 sqrt(3)/2 0.5; ...
                  0 -0.5      sqrt(3)/2];
quat = quaternion(rotationMatrix,"rotmat","frame")

quat = quaternion
     0.96593 + 0.25882i +       0j +       0k

Vous pouvez convertir des quaternions en matrices de rotation à l'aide de la fonction rotmat . Récupérez le rotationMatrix du quaternion, quat.

rotmat(quat,"frame")

ans = 3×3

    1.0000         0         0
         0    0.8660    0.5000
         0   -0.5000    0.8660

Créer un quaternion en spécifiant les angles d'Euler

Vous pouvez créer un tableau de quaternions N par 1 en spécifiant un tableau N par 3 d'angles d'Euler en radians ou en degrés.

Angles d'Euler en radians

Utilisez la syntaxe euler pour créer un quaternion scalaire en utilisant un vecteur 1 sur 3 d'angles d'Euler en radians. Spécifiez la séquence de rotation des angles d'Euler et si les angles représentent une rotation de cadre ou de point.

E = [pi/2,0,pi/4];
quat = quaternion(E,"euler","ZYX","frame")

quat = quaternion
     0.65328 +  0.2706i +  0.2706j + 0.65328k

Vous pouvez convertir des quaternions en angles d'Euler à l'aide de la fonction euler . Récupérez les angles d'Euler, E, du quaternion, quat.

euler(quat,"ZYX","frame")

ans = 1×3

    1.5708         0    0.7854

Angles d'Euler en degrés

Utilisez la syntaxe eulerd pour créer un quaternion scalaire en utilisant un vecteur 1 sur 3 d'angles d'Euler en degrés. Spécifiez la séquence de rotation des angles d'Euler et si les angles représentent une rotation de cadre ou de point.

E = [90,0,45];
quat = quaternion(E,"eulerd","ZYX","frame")

quat = quaternion
     0.65328 +  0.2706i +  0.2706j + 0.65328k

Vous pouvez convertir des quaternions en angles d'Euler en degrés à l'aide de la fonction eulerd . Récupérez les angles d'Euler, E, du quaternion, quat.

eulerd(quat,"ZYX","frame")

ans = 1×3

   90.0000         0   45.0000

Algèbre du quaternion

Les quaternions forment une algèbre associative non commutative sur les nombres réels. Cet exemple illustre les règles de l'algèbre des quaternions.

Addition et soustraction

L'addition et la soustraction de quaternions se produisent partie par partie et sont commutatives :

Q1 = quaternion(1,2,3,4)

Q1 = quaternion
     1 + 2i + 3j + 4k

Q2 = quaternion(9,8,7,6)

Q2 = quaternion
     9 + 8i + 7j + 6k

Q1plusQ2 = Q1 + Q2

Q1plusQ2 = quaternion
     10 + 10i + 10j + 10k

Q2plusQ1 = Q2 + Q1

Q2plusQ1 = quaternion
     10 + 10i + 10j + 10k

Q1minusQ2 = Q1 - Q2

Q1minusQ2 = quaternion
    -8 - 6i - 4j - 2k

Q2minusQ1 = Q2 - Q1

Q2minusQ1 = quaternion
     8 + 6i + 4j + 2k

Vous pouvez également effectuer des additions et des soustractions de nombres réels et de quaternions. La première partie d'un quaternion est appelée la partie réelle , tandis que les deuxième, troisième et quatrième parties sont appelées le vecteur . L'addition et la soustraction avec des nombres réels n'affectent que la partie réelle du quaternion.

Q1plusRealNumber = Q1 + 5

Q1plusRealNumber = quaternion
     6 + 2i + 3j + 4k

Q1minusRealNumber = Q1 - 5

Q1minusRealNumber = quaternion
    -4 + 2i + 3j + 4k

Multiplication

La multiplication des quaternions est déterminée par les produits des éléments de base et de la loi distributive. Rappelons que la multiplication des éléments de base i, j et k n'est pas commutative, et donc la multiplication des quaternions n'est pas commutative.

Q1timesQ2 = Q1 * Q2

Q1timesQ2 = quaternion
    -52 + 16i + 54j + 32k

Q2timesQ1 = Q2 * Q1

Q2timesQ1 = quaternion
    -52 + 36i + 14j + 52k

isequal(Q1timesQ2,Q2timesQ1)

ans = logical
   0

Vous pouvez également multiplier un quaternion par un nombre réel. Si vous multipliez un quaternion par un nombre réel, chaque partie du quaternion est multipliée individuellement par le nombre réel :

Q1times5 = Q1*5

Q1times5 = quaternion
      5 + 10i + 15j + 20k

La multiplication d'un quaternion par un nombre réel est commutative.

isequal(Q1*5,5*Q1)

ans = logical
   1

Conjugaison

Le conjugué complexe d'un quaternion est défini de telle sorte que chaque élément de la partie vectorielle du quaternion est nié.

Q1

Q1 = quaternion
     1 + 2i + 3j + 4k

conj(Q1)

ans = quaternion
     1 - 2i - 3j - 4k

La multiplication entre un quaternion et son conjugué est commutative :

isequal(Q1*conj(Q1),conj(Q1)*Q1)

ans = logical
   1

Manipulation des réseaux de quaternions

Vous pouvez organiser les quaternions en vecteurs, matrices et tableaux multidimensionnels. Les fonctions MATLAB® intégrées ont été améliorées pour fonctionner avec les quaternions.

Enchaîner

Les quaternions sont traités comme des objets individuels lors de la concaténation et suivent les règles MATLAB pour la manipulation des tableaux.

Q1 = quaternion(1,2,3,4);
Q2 = quaternion(9,8,7,6);

qVector = [Q1,Q2]

qVector = 1x2 quaternion array
     1 + 2i + 3j + 4k     9 + 8i + 7j + 6k

Q3 = quaternion(-1,-2,-3,-4);
Q4 = quaternion(-9,-8,-7,-6);

qMatrix = [qVector;Q3,Q4]

qMatrix = 2x2 quaternion array
     1 + 2i + 3j + 4k     9 + 8i + 7j + 6k
    -1 - 2i - 3j - 4k    -9 - 8i - 7j - 6k

qMultiDimensionalArray(:,:,1) = qMatrix;
qMultiDimensionalArray(:,:,2) = qMatrix

qMultiDimensionalArray = 2x2x2 quaternion array
qMultiDimensionalArray(:,:,1) = 

     1 + 2i + 3j + 4k     9 + 8i + 7j + 6k
    -1 - 2i - 3j - 4k    -9 - 8i - 7j - 6k


qMultiDimensionalArray(:,:,2) = 

     1 + 2i + 3j + 4k     9 + 8i + 7j + 6k
    -1 - 2i - 3j - 4k    -9 - 8i - 7j - 6k

Indexage

Pour accéder ou attribuer des éléments dans un tableau de quaternions, utilisez l'indexation.

qLoc2 = qMultiDimensionalArray(2)

qLoc2 = quaternion
    -1 - 2i - 3j - 4k

Remplacez le quaternion à l'index deux par un quaternion.

qMultiDimensionalArray(2) = ones("quaternion")

qMultiDimensionalArray = 2x2x2 quaternion array
qMultiDimensionalArray(:,:,1) = 

     1 + 2i + 3j + 4k     9 + 8i + 7j + 6k
     1 + 0i + 0j + 0k    -9 - 8i - 7j - 6k


qMultiDimensionalArray(:,:,2) = 

     1 + 2i + 3j + 4k     9 + 8i + 7j + 6k
    -1 - 2i - 3j - 4k    -9 - 8i - 7j - 6k

Remodeler

Pour remodeler les tableaux de quaternions, utilisez la fonction reshape .

qMatReshaped = reshape(qMatrix,4,1)

qMatReshaped = 4x1 quaternion array
     1 + 2i + 3j + 4k
    -1 - 2i - 3j - 4k
     9 + 8i + 7j + 6k
    -9 - 8i - 7j - 6k

Transposer

Pour transposer des vecteurs et des matrices de quaternions, utilisez la fonction transpose .

qMatTransposed = transpose(qMatrix)

qMatTransposed = 2x2 quaternion array
     1 + 2i + 3j + 4k    -1 - 2i - 3j - 4k
     9 + 8i + 7j + 6k    -9 - 8i - 7j - 6k

Permuter

Pour permuter les vecteurs quaternions, les matrices et les tableaux multidimensionnels, utilisez la fonction permute .

qMultiDimensionalArray

qMultiDimensionalArray = 2x2x2 quaternion array
qMultiDimensionalArray(:,:,1) = 

     1 + 2i + 3j + 4k     9 + 8i + 7j + 6k
     1 + 0i + 0j + 0k    -9 - 8i - 7j - 6k


qMultiDimensionalArray(:,:,2) = 

     1 + 2i + 3j + 4k     9 + 8i + 7j + 6k
    -1 - 2i - 3j - 4k    -9 - 8i - 7j - 6k

qMatPermute = permute(qMultiDimensionalArray,[3,1,2])

qMatPermute = 2x2x2 quaternion array
qMatPermute(:,:,1) = 

     1 + 2i + 3j + 4k     1 + 0i + 0j + 0k
     1 + 2i + 3j + 4k    -1 - 2i - 3j - 4k


qMatPermute(:,:,2) = 

     9 + 8i + 7j + 6k    -9 - 8i - 7j - 6k
     9 + 8i + 7j + 6k    -9 - 8i - 7j - 6k

Capacités étendues

Génération de code C/C++
Générez du code C et C++ avec MATLAB® Coder™.

Historique des versions

Introduit dans R2019b

Voir aussi

se3 | so3

Rubriques

• Rotations, Orientation, and Quaternions
• Lowpass Filter Orientation Using Quaternion SLERP