La traducción de esta página aún no se ha actualizado a la versión más reciente. Haga clic aquí para ver la última versión en inglés.

cuaternión

Crear un arreglo de cuaterniones

Descripción

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

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

El conjunto de cuaterniones, indicado mediante 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 en el que las cuatro partes del cuaternión 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 de N por 1 a partir de una matriz de N por 4, donde cada columna se convierte en una parte del cuaternión.

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

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

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

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

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

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

quat = quaternion(rotation) crea un arreglo de cuaterniones 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 con el formato 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

matriz de N por 4

Matriz de partes de un cuaternión, especificada como una matriz de 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

matriz de N por 3

Matriz de vectores de rotación, especificada como una matriz de N por 3. Cada fila de RV representa los elementos [X Y Z] 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 usar 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, especificado por una matriz de 3 por 3 o un arreglo 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, especificado 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

matriz de N por 3

Matriz de ángulos de Euler, especificada por una matriz de N por 3. Si usa la sintaxis 'euler', especifique E en radianes. Si usa 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.

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 se gira primero 45° alrededor del eje z y luego 45° alrededor del nuevo eje y.

  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 se gira primero 45° alrededor del eje y y luego 45° alrededor del nuevo eje z.

  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

objeto se3 | Arreglo de N elementos de objetos se3

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

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

rotation — Rotación ortonormal

objeto so3 | Arreglo de N elementos de objetos so3

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

Funciones del objeto

angvel	Angular velocity from quaternion array
classUnderlying	Class of parts within quaternion
compact	Convert quaternion array to N-by-4 matrix
conj	Complex conjugate of quaternion
'	Complex conjugate transpose of quaternion array
dist	Angular distance in radians
euler	Convierte un cuaternión en ángulos de Euler (radianes)
eulerd	Convertir un cuaternión en ángulos de Euler en grados
exp	Exponential of quaternion array
.\,ldivide	Element-wise quaternion left division
log	Natural logarithm of quaternion array
meanrot	Quaternion mean rotation
-	Quaternion subtraction
*	Quaternion multiplication
norm	Norma de un cuaternión
normalize	Normalización de un cuaternión
ones	Create quaternion array with real parts set to one and imaginary parts set to zero
parts	Extraer partes de cuaternión
.^,power	Element-wise quaternion power
prod	Product of quaternion array
randrot	Uniformly distributed random rotations
./,rdivide	Element-wise quaternion right division
rotateframe	Quaternion frame rotation
rotatepoint	Quaternion point rotation
rotmat	Convertir un cuaternión en matriz de rotación
rotvec	Convert quaternion to rotation vector (radians)
rotvecd	Convert quaternion to rotation vector (degrees)
slerp	Spherical linear interpolation
.*,times	Element-wise quaternion multiplication
'	Transpose quaternion array
-	Quaternion unary minus
zeros	Create quaternion array with all parts set to zero

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 escalar o vector columna de cuaterniones especificando una matriz de 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 de cuaterniones, 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 de N por 1 especificando una matriz de 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

Puede convertir cuaterniones en vectores de rotación en radianes usando la función rotvec. Recupere rotationVector a partir 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 cuaterniones en vectores de rotación en grados usando la función rotvecd. Recupere rotationVector a partir 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 cuaterniones en matrices de rotación usando la función rotmat. Recupere rotationMatrix a partir 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 de N por 1 especificando un arreglo de N por 3 de ángulos de Euler en radianes o grados.

Ángulos de Euler en radianes

Use la sintaxis de euler para crear un cuaternión escalar usando 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

Puede convertir cuaterniones en ángulos de Euler usando la función euler. Recupere los ángulos de Euler, E, a partir del cuaternión, quat.

euler(quat,'ZYX','frame')

ans = 1×3

    1.5708         0    0.7854

Ángulos de Euler en grados

Use la sintaxis de eulerd para crear un cuaternión escalar usando 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

Puede convertir de cuaterniones a ángulos de Euler en grados usando la función eulerd. Recupere los ángulos de Euler, E, a partir 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 el 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 básicos, i, j y k, no es conmutativa y, por lo 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 los 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, use 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, use 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 R2018a

Consulte también

se3 | so3