Quaternion

class Quaternion(s=None, v=None, check=True)[source]

Bases: BasePoseList

Quaternion class

A quaternion can be considered an ordered pair \((s, \vec{v})\) where \(s \in \mathbb{R}\) is the scalar part and \(\vec{v} = (v_x, v_y, v_z) \in \mathbb{R}^3\) is the vector part and is often written as

\[\q = s \langle v_x, v_y, v_z \rangle\]
Inheritance diagram of spatialmath.quaternion.Quaternion
classmethod Alloc(n=1)

Construct an instance with N default values (BasePoseList superclass method)

Parameters:

n (int, optional) – Number of values, defaults to 1

Return type:

Self

Returns:

pose instance with n default values

X.Alloc(N) creates an instance of the pose class X with N default values, ie. len(X) will be N.

X can be considered a vector of pose objects, and those elements can be referenced X[i] or assigned to X[i] = ....

Note

The default value depends on the pose class and is the result of the empty constructor. For SO2, SE2, SO3, SE3 it is an identity matrix, for a twist class Twist2 or Twist3 it is a zero vector, for a UnitQuaternion or Quaternion it is a zero vector.

Example:

>>> x = X.Alloc(10)
>>> len(x)
10

where X is any of the SMTB classes.

classmethod Empty()

Construct an empty instance (BasePoseList superclass method)

Return type:

Self

Returns:

pose instance with zero values

Example:

>>> x = X.Empty()
>>> len(x)
0

where X is any of the SMTB classes.

classmethod Pure(v)[source]

Construct a pure quaternion from a vector

Parameters:

v (3-element array_like) – vector

Return type:

Quaternion

Quaternion.Pure(v) is a Quaternion with a zero scalar part and the vector part set to v, ie. \(q = 0 \langle v_x, v_y, v_z \rangle\)

Example:

>>> from spatialmath import Quaternion
>>> print(Quaternion.Pure([1,2,3]))
 0.0000 <  1.0000,  2.0000,  3.0000 >
__add__(right)[source]

Overloaded + operator

Returns:

sum

Return type:

Quaternion, UnitQuaternion

Raises:

ValueError

Operands

Sum

left

right

type

result

Quaternion

Quaternion

Quaternion

elementwise sum

Quaternion

UnitQuaternion

Quaternion

elementwise sum

Quaternion

scalar

Quaternion

add to each element

UnitQuaternion

Quaternion

Quaternion

elementwise sum

UnitQuaternion

UnitQuaternion

Quaternion

elementwise sum

UnitQuaternion

scalar

Quaternion

add to each element

Any other input combinations result in a ValueError.

Note that left and right can have a length greater than 1 in which case:

left

right

len

operation

1

1

1

sum = left + right

1

N

N

sum[i] = left + right[i]

N

1

N

sum[i] = left[i] + right

N

N

N

sum[i] = left[i] + right[i]

N

M

ValueError

A scalar of length N is a list, tuple or numpy array. A 3-vector of length N is a 3xN numpy array, where each column is a 3-vector.

Example:

>>> from spatialmath import Quaternion
>>> Quaternion([1,2,3,4]) + Quaternion([5,6,7,8])
Quaternion(array([ 6,  8, 10, 12]))
>>> Quaternion([np.r_[1,2,3,4], np.r_[5,6,7,8]]) + Quaternion([1,2,3,4])
Quaternion([
  array([2, 4, 6, 8]),
  array([ 6,  8, 10, 12]) ])
>>> Quaternion([np.r_[1,2,3,4], np.r_[5,6,7,8]]) + Quaternion([np.r_[1,2,3,4], np.r_[5,6,7,8]])
Quaternion([
  array([2, 4, 6, 8]),
  array([10, 12, 14, 16]) ])
__eq__(right)[source]

Overloaded == operator

Returns:

Equality of two operands

Return type:

bool or list of bool

q1 == q2 is True if q1` is elementwise equal to ``q2.

Example:

>>> from spatialmath import Quaternion
>>> q1 = Quaternion([1,2,3,4])
>>> q2 = Quaternion([5,6,7,8])
>>> q1 == q1
True
>>> q1 == q2
False
>>> Quaternion([np.r_[1,2,3,4], np.r_[5,6,7,8]]) == q1
[True, False]
>>> Quaternion([np.r_[1,2,3,4], np.r_[5,6,7,8]]) == q2
[False, True]
>>> Quaternion([np.r_[1,2,3,4], np.r_[5,6,7,8]]) == Quaternion([np.r_[1,2,3,4], np.r_[5,6,7,8]])
[True, True]
Seealso:

__ne__() qisequal()

__init__(s=None, v=None, check=True)[source]

Construct a new quaternion

Parameters:

  • s (float or ndarray(N)) – scalar part

  • v (ndarray(3), ndarray(Nx3)) – vector part

  • Quaternion() constructs a zero quaternion

  • Quaternion(s, v) construct a new quaternion from the scalar s and the vector v

  • Quaternion(q) construct a new quaternion from the 4-vector q = [s, v]

  • Quaternion([q1, q2 .. qN]) construct a new quaternion with N values where each element is a 4-vector

  • Quaternion([Q1, Q2 .. QN]) construct a new quaternion with N values where each element is a Quaternion instance

  • Quaternion(M) construct a new quaternion with N values where Q is a 4xN NumPy array.

Example:

>>> from spatialmath import Quaternion
>>> Quaternion()
Quaternion(array([0., 0., 0., 0.]))
>>> Quaternion(1, [2,3,4])
Quaternion(array([1., 2., 3., 4.]))
>>> Quaternion([1,2,3,4])
Quaternion(array([1, 2, 3, 4]))
>>> q=Quaternion([np.r_[1,2,3,4], np.r_[5,6,7,8]])
>>> len(q)
2
>>> print(q)
 1.0000 <  2.0000,  3.0000,  4.0000 >
 5.0000 <  6.0000,  7.0000,  8.0000 >
__mul__(right)[source]

Overloaded * operator

Returns:

product

Return type:

Quaternion

Raises:

ValueError

  • q1 * q2 is the Hamilton product of two quaternions

  • q * s is the scalar product, where s is a scalar

Multiplicands

Product

left

right

type

result

Quaternion

Quaternion

Quaternion

Hamilton product

Quaternion

UnitQuaternion

Quaternion

Hamilton product

Quaternion

scalar

Quaternion

scalar product

Any other input combinations result in a ValueError.

Note that left and right can have a length greater than 1 in which case:

left

right

len

operation

1

1

1

prod = left * right

1

N

N

prod[i] = left * right[i]

N

1

N

prod[i] = left[i] * right

N

N

N

prod[i] = left[i] * right[i]

N

M

ValueError

Example:

>>> from spatialmath import Quaternion
>>> Quaternion([1,2,3,4]) * Quaternion([5,6,7,8])
Quaternion(array([-60.,  12.,  30.,  24.]))
>>> Quaternion([1,2,3,4]) * 2
Quaternion(array([2, 4, 6, 8]))
>>> Quaternion([np.r_[1,2,3,4], np.r_[5,6,7,8]]) * 2
Quaternion([
  array([2, 4, 6, 8]),
  array([10, 12, 14, 16]) ])
>>> Quaternion([np.r_[1,2,3,4], np.r_[5,6,7,8]]) * Quaternion([1,2,3,4])
Quaternion([
  array([-28.,   4.,   6.,   8.]),
  array([-60.,  20.,  14.,  32.]) ])
>>> Quaternion([1,2,3,4]) * Quaternion([np.r_[1,2,3,4], np.r_[5,6,7,8]])
Quaternion([
  array([-28.,   4.,   6.,   8.]),
  array([-60.,  12.,  30.,  24.]) ])
>>> Quaternion([np.r_[1,2,3,4], np.r_[5,6,7,8]]) * Quaternion([np.r_[1,2,3,4], np.r_[5,6,7,8]])
Quaternion([
  array([-28.,   4.,   6.,   8.]),
  array([-124.,   60.,   70.,   80.]) ])
Seealso:

__rmul__() __imul__() qqmul()

__ne__(right)[source]

Overloaded != operator

Return type:

bool

q1 != q2 is True if q` is elementwise not equal to ``q2.

Example:

>>> from spatialmath import Quaternion
>>> q1 = Quaternion([1,2,3,4])
>>> q2 = Quaternion([5,6,7,8])
>>> q1 != q1
False
>>> q1 != q2
True
>>> Quaternion([np.r_[1,2,3,4], np.r_[5,6,7,8]]) != q1
[False, True]
>>> Quaternion([np.r_[1,2,3,4], np.r_[5,6,7,8]]) != q2
[True, False]
Seealso:

__ne__() qisequal()

__pow__(n)[source]

Overloaded ** operator

Return type:

Quaternion instance

q ** N computes the product of q with itself N-1 times, where N must be an integer. If ``N``<0 the result is conjugated.

Example:

>>> from spatialmath import Quaternion
>>> print(Quaternion([1,2,3,4]) ** 2)
-28.0000 <  4.0000,  6.0000,  8.0000 >
>>> print(Quaternion([1,2,3,4]) ** -1)
 1.0000 < -2.0000, -3.0000, -4.0000 >
>>> print(Quaternion([np.r_[1,2,3,4], np.r_[5,6,7,8]]) ** 2)
-28.0000 <  4.0000,  6.0000,  8.0000 >
-124.0000 <  60.0000,  70.0000,  80.0000 >
Seealso:

qpow()

__sub__(right)[source]

Overloaded - operator

Returns:

difference

Return type:

Quaternion, UnitQuaternion

Raises:

ValueError

Operands

Difference

left

right

type

result

Quaternion

Quaternion

Quaternion

elementwise sum

Quaternion

UnitQuaternion

Quaternion

elementwise sum

Quaternion

scalar

Quaternion

subtract from each element

UnitQuaternion

Quaternion

Quaternion

elementwise sum

UnitQuaternion

UnitQuaternion

Quaternion

elementwise sum

UnitQuaternion

scalar

Quaternion

subtract from each element

Any other input combinations result in a ValueError.

Note that left and right can have a length greater than 1 in which case:

left

right

len

operation

1

1

1

diff = left - right

1

N

N

diff[i] = left - right[i]

N

1

N

diff[i] = left[i] - right

N

N

N

diff[i] = left[i] - right[i]

N

M

ValueError

A scalar of length N is a list, tuple or numpy array. A 3-vector of length N is a 3xN numpy array, where each column is a 3-vector.

Example:

>>> from spatialmath import Quaternion
>>> Quaternion([1,2,3,4]) - Quaternion([5,6,7,8])
Quaternion(array([-4, -4, -4, -4]))
>>> Quaternion([np.r_[1,2,3,4], np.r_[5,6,7,8]]) - Quaternion([1,2,3,4])
Quaternion([
  array([0, 0, 0, 0]),
  array([4, 4, 4, 4]) ])
>>> Quaternion([np.r_[1,2,3,4], np.r_[5,6,7,8]]) - Quaternion([np.r_[1,2,3,4], np.r_[5,6,7,8]])
Quaternion([
  array([0, 0, 0, 0]),
  array([0, 0, 0, 0]) ])
__truediv__(other)[source]
append(item)

Append a value to an instance (BasePoseList superclass method)

Parameters:

x (Quaternion or UnitQuaternion instance) – the value to append

Raises:

ValueError – incorrect type of appended object

Return type:

None

Appends the argument to the object’s internal list of values.

Example:

>>> x = X.Alloc(10)
>>> len(x)
10
>>> x.append(X())   # append to the list
>>> len(x)
11

where X is any of the SMTB classes.

arghandler(arg, convertfrom=(), check=True)

Standard constructor support (BasePoseList superclass method)

Parameters:

  • arg (Any) – initial value

  • convertfrom (Tuple) – list of classes to accept and convert from

  • check (bool) – check value is valid, defaults to True

Type:

tuple of typles

Raises:

ValueError – bad type passed

Return type:

bool

The value arg can be any of:

  1. None, an identity value is created

  2. a numpy.ndarray of the appropriate shape and value which is valid for the subclass

  3. a list whose elements all meet the criteria above

  4. an instance of the subclass

  5. a list whose elements are all singelton instances of the subclass

For cases 2 and 3, a NumPy array or a list of NumPy array is passed. Each NumPyarray is tested for validity (if check is False a cursory check of shape is made, if check is True the numerical value is inspected) and converted to the required internal format by the _import method. The default _import method calls the isvalid method for checking. This mechanism allows equivalent forms to be passed, ie. 6x1 or 4x4 for an se(3).

If self is an instance of class A, and an instance of class B is passed and B is an element of the convertfrom argument, then B.A() will be invoked to perform the type conversion.

Examples:

SE3()
SE3(np.identity(4))
SE3([np.identity(4), np.identity(4)])
SE3(SE3())
SE3([SE3(), SE3()])
Twist3(SE3())
binop(right, op, op2=None, list1=True)

Perform binary operation

Parameters:

  • left (BasePoseList subclass) – left operand

  • right (BasePoseList subclass, scalar or array) – right operand

  • op (callable) – binary operation

  • op2 (callable) – binary operation

  • list1 (bool) – return single array as a list, default True

Raises:

ValueError – arguments are not compatible

Returns:

list of values

Return type:

list

The is a helper method for implementing binary operation with overloaded operators such as X * Y where X and Y are both subclasses of BasePoseList. Each operand has a list of one or more values and this methods computes a list of result values according to:

Inputs

Output

len(left)

len(right)

len

operation

1

1

1

ret = op(left, right)

1

M

M

ret[i] = op(left, right[i])

M

1

M

ret[i] = op(left[i], right)

M

M

M

ret[i] = op(left[i], right[i])

The arguments to op are the internal numeric values, ie. as returned by the ._A property.

The result is always a list, except for the first case above and list1 is False.

If the right operand is not a BasePoseList subclass, but is a numeric scalar or array then then op2 is invoked

For example:

X._binop(Y, lambda x, y: x + y)

Input

Output

len(left)

len

operation

1

1

ret = op2(left, right)

M

M

ret[i] = op2(left[i], right)

There is no check on the shape of right if it is an array. The result is always a list, except for the first case above and list1 is False.

clear() → None -- remove all items from S
conj()[source]

Conjugate of quaternion

Return type:

Quaternion instance

q.conj() is the quaternion q with the vector part negated, ie. \(q = s \langle -v_x, -v_y, -v_z \rangle\)

Example:

>>> from spatialmath import Quaternion
>>> print(Quaternion.Pure([1,2,3]).conj())
 0.0000 < -1.0000, -2.0000, -3.0000 >
Seealso:

qconj()

exp(tol=20)[source]

Exponential of quaternion

Parameters:

tol (float, optional) – Tolerance when checking for pure quaternion, in multiples of eps, defaults to 20

Return type:

Quaternion instance

q.exp() is the exponential of the quaternion q, ie.

\[e^s \cos \| v \|, \langle e^s \frac{\vec{v}}{\| \vec{v} \|} \sin \| \vec{v} \| \rangle\]

For a pure quaternion with vector value \(\vec{v}\) the the result is a unit quaternion equivalent to a rotation defined by \(2\vec{v}\) intepretted as an Euler vector, that is, parallel to the axis of rotation and whose norm is the magnitude of rotation.

Example:

>>> from spatialmath import Quaternion
>>> from math import pi
>>> q = Quaternion([1, 2, 3, 4])
>>> print(q.exp())
 1.6939 < -0.7896, -1.1843, -1.5791 >
>>> q = Quaternion.Pure([pi / 4, 0, 0])
>>> print(q.exp())  # result is a UnitQuaternion
 0.7071 <<  0.7071,  0.0000,  0.0000 >>
>>> print(q.exp().angvec())
(1.5707963267948963, array([1., 0., 0.]))
Reference:

Wikipedia

Seealso:

Quaternion.log() UnitQuaternion.log() UnitQuaternion.AngVec() UnitQuaternion.EulerVec()

extend(iterable)

Extend sequence of values in an instance (BasePoseList superclass method)

Parameters:

x (instance of same type) – the value to extend

Raises:

ValueError – incorrect type of appended object

Return type:

None

Appends the argument’s values to the object’s internal list of values.

Example:

>>> x = X.Alloc(10)
>>> len(x)
10
>>> x.append(X.Alloc(5))   # extend the list
>>> len(x)
15

where X is any of the SMTB classes.

inner(other)[source]

Inner product of quaternions

Return type:

float

q1.inner(q2) is the dot product of the equivalent vectors, ie. numpy.dot(q1.vec, q2.vec). The value of q.inner(q) is the same as q.norm ** 2.

Example:
Seealso:

qinner()

insert(i, item)

Insert a value to an instance (BasePoseList superclass method)

Parameters:

  • i (int) – element to insert value before

  • item (instance of same type) – the value to insert

Raises:

ValueError – incorrect type of inserted value

Return type:

None

Inserts the argument into the object’s internal list of values.

Example:

>>> x = X.Alloc(10)
>>> len(x)
10
>>> x.insert(0, X())   # insert at start of list
>>> len(x)
11
>>> x.insert(10, X())   # append to the list
>>> len(x)
11

where X is any of the SMTB classes.

Note

If i is beyond the end of the list, the item is appended to the list

static isvalid(x)[source]

Test if vector is valid quaternion

Parameters:

  • x (numpy.ndarray) – vector to test

  • check (bool) – explicitly check vector is unit length [default True]

Returns:

True if the matrix has shape (4,).

Return type:

bool

Example:

>>> from spatialmath import Quaternion
>>> import numpy as np
>>> Quaternion.isvalid(np.r_[1, 0, 0, 0])
True
>>> Quaternion.isvalid(np.r_[1, 2, 3, 4])
True
log()[source]

Logarithm of quaternion

Return type:

Quaternion instance

q.log() is the logarithm of the quaternion q, ie.

\[\ln \| q \|, \langle \frac{\vec{v}}{\| \vec{v} \|} \cos^{-1} \frac{s}{\| q \|} \rangle\]

For a UnitQuaternion the logarithm is a pure quaternion whose vector part \(\vec{v}\) and \(\vec{v}/2\) is a Euler vector: parallel to the axis of rotation and whose norm is the magnitude of rotation.

Example:

>>> from spatialmath import Quaternion, UnitQuaternion
>>> from math import pi
>>> q = Quaternion([1, 2, 3, 4])
>>> print(q.log())
 1.7006 <  0.5152,  0.7728,  1.0304 >
>>> q = UnitQuaternion.Rx(pi / 2)
>>> print(q.log())
 0.0000 <  0.7854,  0.0000,  0.0000 >
Reference:

Wikipedia

Seealso:

Quaternion.exp() Quaternion.log() UnitQuaternion.angvec()

norm()[source]

Norm of quaternion

Return type:

float

q.norm() is the norm or length of the quaternion \(\sqrt{s^2 + v_x^2 + v_y^2 + v_z^2}\)

Example:

>>> from spatialmath import Quaternion
>>> Quaternion([1,2,3,4]).norm()
5.477225575051661
>>> Quaternion([np.r_[1,2,3,4], np.r_[5,6,7,8]]).norm()
array([ 5.4772, 13.1909])
Seealso:

qnorm()

pop(i=-1)

Pop value from an instance (BasePoseList superclass method)

Parameters:

i (int) – item in the list to pop, default is last

Returns:

the popped value

Return type:

instance of same type

Raises:

IndexError – if there are no values to pop

Removes a value from the value list and returns it. The original instance is modified.

Example:

>>> x = X.Alloc(10)
>>> len(x)
10
>>> y = x.pop()  # pop the last value x[9]
>>> len(x)
9
>>> y = x.pop(0)  # pop the first value x[0]
>>> len(x)
8

where X is any of the SMTB classes.

reverse()

S.reverse() – reverse IN PLACE

unit()[source]

Unit quaternion

Return type:

UnitQuaternion instance

q.unit() is the quaternion q normalized to have a unit length.

Example:

>>> from spatialmath import Quaternion
>>> q = Quaternion([1,2,3,4])
>>> print(q)
 1.0000 <  2.0000,  3.0000,  4.0000 >
>>> print(q.unit())
 0.1826 <<  0.3651,  0.5477,  0.7303 >>
>>> print(Quaternion([np.r_[1,2,3,4], np.r_[5,6,7,8]]).unit())
 0.1826 <<  0.3651,  0.5477,  0.7303 >>
 0.3790 <<  0.4549,  0.5307,  0.6065 >>

Note that the return type is different, a UnitQuaternion, which is distinguished by the use of double angle brackets to delimit the vector part.

Seealso:

qnorm()

unop(op, matrix=False)

Perform unary operation

Parameters:

  • self (BasePoseList subclass) – operand

  • op (callable) – unnary operation

  • matrix (bool) – return array instead of list, default False

Returns:

operation results

Return type:

list or NumPy array

The is a helper method for implementing unary operations where the operand has multiple value. This method computes the value of the operation for all input values and returns the result as either a list or as a matrix which vertically stacks the results.

Input

Output

len(self)

len

operation

1

1

ret = op(self)

M

M

ret[i] = op(self[i])

M

M

ret[i,;] = op(self[i])

The result is:

  • a list of values if matrix==False, or

  • a 2D NumPy stack of values if matrix==True, it is assumed that the value is a 1D array.

property A: List[ndarray[Any, dtype[ScalarType]]] | ndarray[Any, dtype[ScalarType]]

Array value of an instance (BasePoseList superclass method)

Returns:

NumPy array value of this instance

Return type:

ndarray

  • X.A is a NumPy array that represents the value of this instance, and has a shape given by X.shape.

Note

This assumes that len(X) == 1, ie. it is a single-valued instance.

property matrix: ndarray[Any, dtype[ScalarType]]

Matrix equivalent of quaternion

Return type:

Numpy array, shape=(4,4)

q.matrix is a 4x4 matrix which encodes the arithmetic rules of Hamilton multiplication. This matrix, multiplied by the 4-vector equivalent of a second quaternion, results in the 4-vector equivalent of the Hamilton product.

Example:

>>> from spatialmath import Quaternion
>>> Quaternion([1,2,3,4]).matrix
array([[ 1., -2., -3., -4.],
       [ 2.,  1., -4.,  3.],
       [ 3.,  4.,  1., -2.],
       [ 4., -3.,  2.,  1.]])
>>> Quaternion([1,2,3,4]) * Quaternion([5,6,7,8])   # Hamilton product
Quaternion(array([-60.,  12.,  30.,  24.]))
>>> Quaternion([1,2,3,4]).matrix @ Quaternion([5,6,7,8]).vec  # matrix-vector product
array([-60.,  12.,  30.,  24.])
Seealso:

qmatrix()

property s: float

Scalar part of quaternion

Returns:

scalar part of quaternion

Return type:

float or numpy.ndarray

q.s is the scalar part. If len(q) is:

  • 1, return a scalar float

  • N>1, return a NumPy array shape=(N,) is returned.

Example:

>>> from spatialmath import Quaternion
>>> Quaternion([1,2,3,4]).s
1
>>> Quaternion([np.r_[1,2,3,4], np.r_[5,6,7,8]]).s
array([1, 5])
property shape: Tuple[int]

Shape of the object’s interal matrix representation

Returns:

(4,)

Return type:

tuple

property v: ndarray[Any, dtype[floating]]

Vector part of quaternion

Returns:

vector part of quaternion

Return type:

NumPy ndarray

q.v is the vector part. If len(q) is:

  • 1, return a NumPy array shape=(3,)

  • N>1, return a NumPy array shape=(N,3).

Example:

>>> from spatialmath import Quaternion
>>> Quaternion([1,2,3,4]).v
array([2, 3, 4])
>>> Quaternion([np.r_[1,2,3,4], np.r_[5,6,7,8]]).v
array([[2, 3, 4],
       [6, 7, 8]])
property vec: ndarray[Any, dtype[floating]]

Quaternion as a vector

Returns:

quaternion expressed as a 4-vector

Return type:

numpy ndarray, shape=(4,)

q.vec is the quaternion as a vector. If len(q) is:

  • 1, return a NumPy array shape=(4,)

  • N>1, return a NumPy array shape=(N,4).

The quaternion coefficients are in the order (s, vx, vy, vz), ie. with the scalar (real part) first.

Example:

>>> from spatialmath import Quaternion
>>> Quaternion([1,2,3,4]).vec
array([1, 2, 3, 4])
>>> Quaternion([np.r_[1,2,3,4], np.r_[5,6,7,8]]).vec
array([[1, 2, 3, 4],
       [5, 6, 7, 8]])
property vec_xyzs: ndarray[Any, dtype[floating]]

Quaternion as a vector

Returns:

quaternion expressed as a 4-vector

Return type:

numpy ndarray, shape=(4,)

q.vec_xyzs is the quaternion as a vector. If len(q) is:

  • 1, return a NumPy array shape=(4,)

  • N>1, return a NumPy array shape=(N,4).

The quaternion coefficients are in the order (vx, vy, vz, s), ie. with the scalar (real part) last. This is useful when exporting to other packages like three.js or pybullet.

Example:

>>> from spatialmath import Quaternion
>>> Quaternion([1,2,3,4]).vec_xyzs
array([2, 3, 4, 1])
>>> Quaternion([np.r_[1,2,3,4], np.r_[5,6,7,8]]).vec_xyzs
array([[2, 3, 4, 1],
       [6, 7, 8, 5]])