Esta página se ha traducido mediante traducción automática. Haga clic aquí para ver la última versión en inglés.

cuaternión

Crear arreglo de cuaterniones

Desde R2019b

Descripción

Un cuaternión es un número hipercomplejo de cuatro partes que se usa en orientaciones y rotaciones tridimensionales.

Un número de cuaternión se representa en la forma $$a+b\text{i}+c\text{j}+d\text{k}$$, donde a, b, c y d las partes son números reales, e i, j y k son los elementos base, que satisfacen la ecuación: i² = j² = k² = ijk = −1.

El conjunto de cuaterniones, denotado por H, se define dentro de un espacio vectorial de cuatro dimensiones sobre los números reales, R⁴. Cada elemento de H tiene una representación única basada en una combinación lineal de los elementos básicos, i, j y k.

Todas las rotaciones en 3D se pueden describir mediante un eje de rotación y un ángulo en torno a ese eje. Una ventaja de los cuaterniones sobre las matrices de rotación es que el eje y el ángulo de rotación son fáciles de interpretar. Por ejemplo, considere un punto en R³. Para rotar el punto, se define un eje de rotación y un ángulo de rotación.

La representación del cuaternión de la rotación se puede expresar como $$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)$$, donde θ es el ángulo de rotación y [u_b, u_c, y u_d] es el eje de rotación.

Creación

Sintaxis

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)

Descripción

quat = quaternion() crea un cuaternión vacío.

quat = quaternion(A,B,C,D) crea un arreglo de cuaterniones donde las cuatro partes de cuaterniones se toman de los arreglos A, B, C y D. Todas las entradas deben tener el mismo tamaño y ser del mismo tipo de datos.

quat = quaternion(matrix) crea un arreglo de cuaterniones N por 1 a partir de un arreglo de cuaterniones N por 4, donde cada columna se convierte en una parte de el cuaternión.

quat = quaternion(RV,"rotvec") crea un arreglo de cuaterniones N N -por-1 a partir de una matriz de vectores de rotación N -por-3, RV. Cada fila de RV representa un vector de rotación en radianes.

quat = quaternion(RV,"rotvecd") crea un arreglo de cuaterniones N -por-1 a partir de una matriz de vectores de rotación N-por-3, RV. Cada fila de RV representa un vector de rotación en grados.

quat = quaternion(RM,"rotmat",PF) crea un arreglo de cuaterniones N -por-1 a partir del arreglo de matrices de rotación N de 3 por 3 por N , RM. PF puede ser "point" si los ángulos de Euler representan rotaciones de puntos o "frame" para rotaciones de cuadros.

quat = quaternion(E,"euler",RS,PF) crea un arreglo de cuaterniones N por 1 a partir de la matriz N por 3, E. Cada fila de E representa un conjunto de ángulos de Euler en radianes. Los ángulos en E son rotaciones alrededor de los ejes en secuencia RS.

quat = quaternion(E,"eulerd",RS,PF) crea un arreglo de cuaterniones N -por-1 a partir de la matriz de cuaterniones N-por-3, E. Cada fila de E representa un conjunto de ángulos de Euler en grados. Los ángulos en E son rotaciones alrededor de los ejes en secuencia RS.

quat = quaternion(transformation) crea un arreglo de cuaterniones a partir de la transformación SE(3) transformation.

quat = quaternion(rotation) crea un arreglo de cuaterniones a partir de la rotación SO(3) rotation.

Argumentos de entrada

A,B,C,D — Partes de un cuaternión

arreglos separados por comas del mismo tamaño

Partes de un cuaternión, especificadas como cuatro escalares separados por comas, matrices o arreglos multidimensionales del mismo tamaño.

Ejemplo: quat = quaternion(1,2,3,4) crea un cuaternión de la forma 1 + 2i + 3j + 4k.

Ejemplo: quat = quaternion([1,5],[2,6],[3,7],[4,8]) crea un arreglo de cuaterniones de 1 por 2 donde quat(1,1) = 1 + 2i + 3j + 4k y quat(1,2) = 5 + 6i + 7j + 8k

Tipos de datos: single | double

matrix — Matriz de partes de un cuaternión

N-por-4 matriz

Matriz de partes de cuaterniones, especificada como una matriz N-por-4. Cada fila representa un cuaternión independiente. Cada columna representa una parte de cuaternión independiente.

Ejemplo: quat = quaternion(rand(10,4)) crea un arreglo de cuaterniones de 10 por 1.

Tipos de datos: single | double

RV — Matriz de vectores de rotación

N-por-3 matriz

Matriz de vectores de rotación, especificada como una matriz N-por-3. Cada fila de RV representa los elementos [XYZ] de un vector de rotación. Un vector de rotación es un vector unitario que representa el eje de rotación escalado por el ángulo de rotación en radianes o grados.

Para utilizar esta sintaxis, especifique el primer argumento como una matriz de vectores de rotación y el segundo argumento como "rotvec" o "rotvecd".

Ejemplo: quat = quaternion(rand(10,3),"rotvec") crea un arreglo de cuaterniones de 10 por 1.

Tipos de datos: single | double

RM — Matrices de rotación

Matriz de 3 por 3 | arreglo de 3 por 3 por N

Arreglo de matrices de rotación, especificada por una matriz de 3 por 3 o una matriz de 3 por 3 por N . Cada página del arreglo representa una matriz de rotación independiente.

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

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

Tipos de datos: single | double

PF — Tipo de matriz de rotación

"point" | "frame"

Tipo de matriz de rotación, especificada por "point" o "frame".

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

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

Tipos de datos: char | string

E — Matriz de ángulos de Euler

N-por-3 matriz

Matriz de ángulos de Euler, especificada por una matriz N-por-3. Si utiliza la sintaxis "euler" , especifique E en radianes. Si utiliza la sintaxis "eulerd" , especifique E en grados.

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

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

Tipos de datos: single | double

RS — Secuencia de rotación

vector de caracteres | cadena de escalares

Secuencia de rotación, especificada como un vector de caracteres de tres elementos:

• "YZY"

• "YXY"

• "ZYZ"

• "ZXZ"

• "XYX"

• "XZX"

• "XYZ"

• "YZX"

• "ZXY"

• "XZY"

• "ZYX"

• "YXZ"

Suponga que desea determinar las nuevas coordenadas de un punto cuando su sistema de coordenadas se gira usando la rotación de marco. El punto se define en el sistema de coordenadas original como:

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

En esta representación, la primera columna representa el eje x, la segunda columna representa el eje y y la tercera columna representa el eje z-eje.

Gire el punto usando la representación del ángulo de Euler [45,45,0]. Gire el punto usando dos secuencias de rotación diferentes:

• Si crea un rotador de cuaterniones y especifica la secuencia "ZYX", el marco primero se gira 45° alrededor del eje z, luego 45° alrededor del nuevo y-eje.

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

  newPointCoordinate =
  
      0.7071   -0.0000    0.7071

  

• Si crea un rotador de cuaterniones y especifica la secuencia "YZX", el marco primero gira 45° alrededor del eje y, luego 45° alrededor del nuevo z-eje.

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

  newPointCoordinate =
  
      0.8536    0.1464    0.5000

  

Tipos de datos: char | string

transformation — Transformación homogénea

se3 objeto | N arreglo de elementos de se3 objetos

Transformación, especificada como un objeto se3 , o como un arreglo de elementos N de objetos se3 . N es el número total de transformaciones.

El objeto quaternion ignora el componente traslacional de la transformación y convierte la submatriz rotacional de 3 por 3 de la transformación en un cuaternión.

rotation — Rotación ortonormal

so3 objeto | N arreglo de elementos de so3 objetos

Rotación ortonormal, especificada como un objeto so3 , o como un arreglo de elementos N de objetos so3 . N es el número total de rotaciones.

Funciones del objeto

angvel	Velocidad angular del arreglo de cuaterniones
classUnderlying	Clase de partes dentro del cuaternión
compact	Convertir arreglo de cuaterniones a matriz N por 4
conj	Conjugado complejo de cuaternión
'	Transpuesta conjugada compleja de arreglo de cuaterniones
dist	Distancia angular en radianes
euler	Convierte un cuaternión en ángulos de Euler (radianes)
eulerd	Convertir un cuaternión en ángulos de Euler en grados
exp	Exponencial de arreglo de cuaterniones
.\,ldivide	División izquierda del cuaternión por elementos
log	Logaritmo natural del arreglo de cuaterniones
meanrot	Rotación media del cuaternión
-	Resta de cuaterniones
*	Multiplicación de cuaterniones
norm	Norma de un cuaternión
normalize	Normalización de un cuaternión
ones	Cree un arreglo de cuaterniones con partes reales establecidas en uno y partes imaginarias establecidas en cero
parts	Extraer partes de cuaternión
.^,power	Poder de cuaternión por elementos
prod	Producto de arreglo de cuaterniones
randrot	Rotaciones aleatorias distribuidas uniformemente
./,rdivide	División derecha de cuaterniones por elementos
rotateframe	Rotación del marco del cuaternión
rotatepoint	Rotación del punto cuaternión
rotmat	Convertir un cuaternión en matriz de rotación
rotvec	Convertir cuaternión en vector de rotación (radianes)
rotvecd	Convertir cuaternión en vector de rotación (grados)
slerp	Interpolación lineal esférica
.*,times	Multiplicación de cuaterniones por elementos
'	Transponer arreglo de cuaterniones
-	Cuaternión unario menos
zeros	Cree un arreglo de cuaterniones con todas las partes establecidas en cero

Ejemplos

Crear un cuaternión vacío

quat = quaternion()

quat = 

  0x0 empty quaternion array

De forma predeterminada, la clase subyacente del cuaternión es un doble.

classUnderlying(quat)

ans = 
'double'

Crear un cuaternión especificando partes individuales del cuaternión

Puede crear un arreglo de cuaternión especificando las cuatro partes como escalares separados por comas, matrices o arreglos multidimensionales del mismo tamaño.

Definir partes del cuaternión como escalares.

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

Definir partes del cuaternión como vectores columna.

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

Definir partes del cuaternión como 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

Definir partes del cuaternión como arreglos tridimensionales.

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

Crear un cuaternión especificando una matriz de partes individuales del cuaternión

Puede crear un vector columna de cuaterniones especificando una matriz N por 4 de partes de cuaterniones, donde las columnas corresponden a las partes de cuaterniones A, B, C y D.

Cree un vector columna de cuaterniones aleatorios.

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

Para recuperar la matriz quatParts de la representación del cuaternión, use 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

Crear un cuaternión especificando vectores de rotación

Puede crear un arreglo de cuaterniones N por 1 especificando una matriz N por 3 de vectores de rotación en radianes o grados. Los vectores de rotación son representaciones espaciales compactas que tienen una relación de uno a uno con los cuaterniones normalizados.

Vectores de rotación en radianes

Cree un cuaternión escalar usando un vector de rotación y verifique que el cuaternión resultante esté normalizado.

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

Puedes convertir de cuaterniones a vectores de rotación en radianes usando la función rotvec . Recupera el rotationVector del cuaternión, quat.

rotvec(quat)

ans = 1×3

    0.3491    0.6283    0.3491

Vectores de rotación en grados

Cree un cuaternión escalar usando un vector de rotación y verifique que el cuaternión resultante esté normalizado.

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

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

norm(quat)

ans = 1

Puede convertir de cuaterniones a vectores de rotación en grados usando la función rotvecd . Recupera el rotationVector del cuaternión, quat.

rotvecd(quat)

ans = 1×3

   20.0000   36.0000   20.0000

Crear un cuaternión especificando matrices de rotación

Puede crear un arreglo de cuaterniones de N por 1 especificando un arreglo de matrices de rotación de 3 por 3 por N. Cada página del arreglo de matrices de rotación corresponde a un elemento del arreglo de cuaterniones.

Cree un cuaternión escalar usando una matriz de rotación de 3 por 3. Especifique si la matriz de rotación debe interpretarse como una rotación de marco o punto.

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

Puede convertir de cuaterniones a matrices de rotación usando la función rotmat . Recupera el rotationMatrix del cuaternión, quat.

rotmat(quat,"frame")

ans = 3×3

    1.0000         0         0
         0    0.8660    0.5000
         0   -0.5000    0.8660

Crear un cuaternión especificando ángulos de Euler

Puede crear un arreglo de cuaterniones N por 1 especificando un arreglo de Euler en radianes o grados.

Ángulos de Euler en radianes

Utilice la sintaxis euler para crear un cuaternión escalar utilizando un vector de 1 por 3 de ángulos de Euler en radianes. Especifique la secuencia de rotación de los ángulos de Euler y si los ángulos representan una rotación de marco o punto.

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

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

Puedes convertir de cuaterniones a ángulos de Euler usando la función euler . Recupera los ángulos de Euler, E, del cuaternión, quat.

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

ans = 1×3

    1.5708         0    0.7854

Ángulos de Euler en grados

Utilice la sintaxis eulerd para crear un cuaternión escalar utilizando un vector de 1 por 3 de ángulos de Euler en grados. Especifique la secuencia de rotación de los ángulos de Euler y si los ángulos representan una rotación de marco o punto.

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

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

Puedes convertir de cuaterniones a ángulos de Euler en grados usando la función eulerd . Recupera los ángulos de Euler, E, del cuaternión, quat.

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

ans = 1×3

   90.0000         0   45.0000

Álgebra de cuaterniones

Los cuaterniones forman un álgebra asociativa no conmutativa sobre los números reales. Este ejemplo ilustra las reglas del álgebra de cuaterniones.

Suma y resta

La suma y la resta de cuaterniones se realizan parte por parte y son conmutativas:

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

También puede realizar sumas y restas de números reales y cuaterniones. La primera parte de un cuaternión se denomina parte real, mientras que la segunda, tercera y cuarta parte se denominan vector. La suma y la resta con números reales solo afectan a la parte real del cuaternión.

Q1plusRealNumber = Q1 + 5

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

Q1minusRealNumber = Q1 - 5

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

Multiplicación

La multiplicación de cuaterniones está determinada por los productos de los elementos básicos y la ley distributiva. Recuerde que la multiplicación de los elementos base, i, j y k, no son conmutativas y, por tanto, la multiplicación de cuaterniones no es conmutativa.

Q1timesQ2 = Q1 * Q2

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

Q2timesQ1 = Q2 * Q1

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

isequal(Q1timesQ2,Q2timesQ1)

ans = logical
   0

También puede multiplicar un cuaternión por un número real. Si multiplica un cuaternión por un número real, cada parte del cuaternión se multiplica individualmente por el número real:

Q1times5 = Q1*5

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

La multiplicación de un cuaternión por un número real es conmutativa.

isequal(Q1*5,5*Q1)

ans = logical
   1

Conjugación

El conjugado complejo de un cuaternión se define de tal manera que se niega cada elemento de la porción vectorial del cuaternión.

Q1

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

conj(Q1)

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

La multiplicación entre un cuaternión y su conjugado es conmutativa:

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

ans = logical
   1

Manipulación de arreglos de cuaterniones

Puede organizar los cuaterniones en vectores, matrices y arreglos multidimensionales. Las funciones integradas de MATLAB® se han mejorado para trabajar con cuaterniones.

Concatenar

Los cuaterniones se tratan como objetos individuales durante la concatenación y siguen las reglas de MATLAB para la manipulación de arreglos.

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

Indexación

Para acceder o asignar elementos en un arreglo de cuaterniones, use la indexación.

qLoc2 = qMultiDimensionalArray(2)

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

Reemplace el cuaternión en el índice dos por un cuaternión uno.

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

Remodelar

Para remodelar arreglos de cuaterniones, use la función 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

Transposición

Para transponer vectores y matrices de cuaterniones, utilice la función transpose .

qMatTransposed = transpose(qMatrix)

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

Permutar

Para permutar vectores de cuaterniones, matrices y arreglos multidimensionales, utilice la función 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

Capacidades ampliadas

Generación de código C/C++
Genere código C y C++ mediante MATLAB® Coder™.

Historial de versiones

Introducido en R2019b

Consulte también

se3 | so3

Temas

• Rotaciones, orientación y cuaterniones
• Orientación del filtro de paso bajo utilizando Quaternion SLERP