Making NumPy arrays of vectors#

A NumPy array of vectors is a subclass of np.ndarray with vector properties and methods. The dtype of this array is structured to specify the coordinate names; an array with fields x and y (Cartesian) performs computations differently from an array with fields rho and phi (polar).

To create a NumPy array of vectors,

use the vector.array function (vector.arr is a synonym)
use the vector.VectorNumpy class constructor
or cast a structured NumPy array as the appropriate class, which can avoid copying data.

General constructor#

vector.array(*args: Any, **kwargs: Any) → VectorNumpy#

Constructs a NumPy array of vectors, whose type is determined by the dtype of the structured array or Pandas-style “columns” argument.

All allowed signatures for np.array can be used in this function, plus one more:

vector.array({"x": x_column, "y": y_column})

to make an array with dtype=[("x", x_column.dtype), ("y", y_column.dtype)].

The array must have structured dtype (i.e. dtype.names is not None) and the following combinations of names are allowed:

(2D) x, y
(2D) rho, phi
(3D) x, y, z
(3D) x, y, theta
(3D) x, y, eta
(3D) rho, phi, z
(3D) rho, phi, theta
(3D) rho, phi, eta
(4D) x, y, z, t
(4D) x, y, z, tau`
(4D) x, y, theta, t`
(4D) x, y, theta, tau`
(4D) x, y, eta, t`
(4D) x, y, eta, tau`
(4D) rho, phi, z, t`
(4D) rho, phi, z, tau`
(4D) rho, phi, theta, t`
(4D) rho, phi, theta, tau`
(4D) rho, phi, eta, t`
(4D) rho, phi, eta, tau`

in which

px may be substituted for x
py may be substituted for y
pt may be substituted for rho
pz may be substituted for z
E may be substituted for t
e may be substituted for t
energy may be substituted for t
M may be substituted for tau
m may be substituted for tau
mass may be substituted for tau

to make the vector a momentum vector.

class vector.VectorNumpy(*, x: float, y: float)#
class vector.VectorNumpy(*, rho: float, phi: float)
class vector.VectorNumpy(*, x: float, y: float, z: float)
class vector.VectorNumpy(*, x: float, y: float, eta: float)
class vector.VectorNumpy(*, x: float, y: float, theta: float)
class vector.VectorNumpy(*, rho: float, phi: float, z: float)
class vector.VectorNumpy(*, rho: float, phi: float, eta: float)
class vector.VectorNumpy(*, rho: float, phi: float, theta: float)
class vector.VectorNumpy(*, px: float, py: float)
class vector.VectorNumpy(*, x: float, py: float)
class vector.VectorNumpy(*, px: float, y: float)
class vector.VectorNumpy(*, pt: float, phi: float)
class vector.VectorNumpy(*, x: float, y: float, pz: float)
class vector.VectorNumpy(*, x: float, py: float, z: float)
class vector.VectorNumpy(*, x: float, py: float, pz: float)
class vector.VectorNumpy(*, px: float, y: float, z: float)
class vector.VectorNumpy(*, px: float, y: float, pz: float)
class vector.VectorNumpy(*, px: float, py: float, z: float)
class vector.VectorNumpy(*, px: float, py: float, pz: float)
class vector.VectorNumpy(*, rho: float, phi: float, pz: float)
class vector.VectorNumpy(*, pt: float, phi: float, z: float)
class vector.VectorNumpy(*, pt: float, phi: float, pz: float)
class vector.VectorNumpy(*, x: float, py: float, theta: float)
class vector.VectorNumpy(*, px: float, y: float, theta: float)
class vector.VectorNumpy(*, px: float, py: float, theta: float)
class vector.VectorNumpy(*, pt: float, phi: float, theta: float)
class vector.VectorNumpy(*, x: float, py: float, eta: float)
class vector.VectorNumpy(*, px: float, y: float, eta: float)
class vector.VectorNumpy(*, px: float, py: float, eta: float)
class vector.VectorNumpy(*, pt: float, phi: float, eta: float)
class vector.VectorNumpy(*, x: float, y: float, z: float, t: float)
class vector.VectorNumpy(*, x: float, y: float, pz: float, t: float)
class vector.VectorNumpy(*, x: float, py: float, z: float, t: float)
class vector.VectorNumpy(*, x: float, py: float, pz: float, t: float)
class vector.VectorNumpy(*, px: float, y: float, z: float, t: float)
class vector.VectorNumpy(*, px: float, y: float, pz: float, t: float)
class vector.VectorNumpy(*, px: float, py: float, z: float, t: float)
class vector.VectorNumpy(*, px: float, py: float, pz: float, t: float)
class vector.VectorNumpy(*, rho: float, phi: float, z: float, t: float)
class vector.VectorNumpy(*, rho: float, phi: float, pz: float, t: float)
class vector.VectorNumpy(*, pt: float, phi: float, z: float, t: float)
class vector.VectorNumpy(*, pt: float, phi: float, pz: float, t: float)
class vector.VectorNumpy(*, x: float, y: float, theta: float, t: float)
class vector.VectorNumpy(*, x: float, py: float, theta: float, t: float)
class vector.VectorNumpy(*, px: float, y: float, theta: float, t: float)
class vector.VectorNumpy(*, px: float, py: float, theta: float, t: float)
class vector.VectorNumpy(*, rho: float, phi: float, theta: float, t: float)
class vector.VectorNumpy(*, pt: float, phi: float, theta: float, t: float)
class vector.VectorNumpy(*, x: float, y: float, eta: float, t: float)
class vector.VectorNumpy(*, x: float, py: float, eta: float, t: float)
class vector.VectorNumpy(*, px: float, y: float, eta: float, t: float)
class vector.VectorNumpy(*, px: float, py: float, eta: float, t: float)
class vector.VectorNumpy(*, rho: float, phi: float, eta: float, t: float)
class vector.VectorNumpy(*, pt: float, phi: float, eta: float, t: float)
class vector.VectorNumpy(*, x: float, y: float, z: float, tau: float)
class vector.VectorNumpy(*, x: float, y: float, pz: float, tau: float)
class vector.VectorNumpy(*, x: float, py: float, z: float, tau: float)
class vector.VectorNumpy(*, x: float, py: float, pz: float, tau: float)
class vector.VectorNumpy(*, px: float, y: float, z: float, tau: float)
class vector.VectorNumpy(*, px: float, y: float, pz: float, tau: float)
class vector.VectorNumpy(*, px: float, py: float, z: float, tau: float)
class vector.VectorNumpy(*, px: float, py: float, pz: float, tau: float)
class vector.VectorNumpy(*, rho: float, phi: float, z: float, tau: float)
class vector.VectorNumpy(*, rho: float, phi: float, pz: float, tau: float)
class vector.VectorNumpy(*, ptau: float, phi: float, z: float, tau: float)
class vector.VectorNumpy(*, ptau: float, phi: float, pz: float, tau: float)
class vector.VectorNumpy(*, x: float, y: float, theta: float, tau: float)
class vector.VectorNumpy(*, x: float, py: float, theta: float, tau: float)
class vector.VectorNumpy(*, px: float, y: float, theta: float, tau: float)
class vector.VectorNumpy(*, px: float, py: float, theta: float, tau: float)
class vector.VectorNumpy(*, rho: float, phi: float, theta: float, tau: float)
class vector.VectorNumpy(*, ptau: float, phi: float, theta: float, tau: float)
class vector.VectorNumpy(*, x: float, y: float, eta: float, tau: float)
class vector.VectorNumpy(*, x: float, py: float, eta: float, tau: float)
class vector.VectorNumpy(*, px: float, y: float, eta: float, tau: float)
class vector.VectorNumpy(*, px: float, py: float, eta: float, tau: float)
class vector.VectorNumpy(*, rho: float, phi: float, eta: float, tau: float)
class vector.VectorNumpy(*, ptau: float, phi: float, eta: float, tau: float)
class vector.VectorNumpy(*, x: float, y: float, z: float, E: float)
class vector.VectorNumpy(*, x: float, y: float, pz: float, E: float)
class vector.VectorNumpy(*, x: float, py: float, z: float, E: float)
class vector.VectorNumpy(*, x: float, py: float, pz: float, E: float)
class vector.VectorNumpy(*, px: float, y: float, z: float, E: float)
class vector.VectorNumpy(*, px: float, y: float, pz: float, E: float)
class vector.VectorNumpy(*, px: float, py: float, z: float, E: float)
class vector.VectorNumpy(*, px: float, py: float, pz: float, E: float)
class vector.VectorNumpy(*, rho: float, phi: float, z: float, E: float)
class vector.VectorNumpy(*, rho: float, phi: float, pz: float, E: float)
class vector.VectorNumpy(*, pE: float, phi: float, z: float, E: float)
class vector.VectorNumpy(*, pE: float, phi: float, pz: float, E: float)
class vector.VectorNumpy(*, x: float, y: float, theta: float, E: float)
class vector.VectorNumpy(*, x: float, py: float, theta: float, E: float)
class vector.VectorNumpy(*, px: float, y: float, theta: float, E: float)
class vector.VectorNumpy(*, px: float, py: float, theta: float, E: float)
class vector.VectorNumpy(*, rho: float, phi: float, theta: float, E: float)
class vector.VectorNumpy(*, pE: float, phi: float, theta: float, E: float)
class vector.VectorNumpy(*, x: float, y: float, eta: float, E: float)
class vector.VectorNumpy(*, x: float, py: float, eta: float, E: float)
class vector.VectorNumpy(*, px: float, y: float, eta: float, E: float)
class vector.VectorNumpy(*, px: float, py: float, eta: float, E: float)
class vector.VectorNumpy(*, rho: float, phi: float, eta: float, E: float)
class vector.VectorNumpy(*, pE: float, phi: float, eta: float, E: float)
class vector.VectorNumpy(*, x: float, y: float, z: float, e: float)
class vector.VectorNumpy(*, x: float, y: float, pz: float, e: float)
class vector.VectorNumpy(*, x: float, py: float, z: float, e: float)
class vector.VectorNumpy(*, x: float, py: float, pz: float, e: float)
class vector.VectorNumpy(*, px: float, y: float, z: float, e: float)
class vector.VectorNumpy(*, px: float, y: float, pz: float, e: float)
class vector.VectorNumpy(*, px: float, py: float, z: float, e: float)
class vector.VectorNumpy(*, px: float, py: float, pz: float, e: float)
class vector.VectorNumpy(*, rho: float, phi: float, z: float, e: float)
class vector.VectorNumpy(*, rho: float, phi: float, pz: float, e: float)
class vector.VectorNumpy(*, pe: float, phi: float, z: float, e: float)
class vector.VectorNumpy(*, pe: float, phi: float, pz: float, e: float)
class vector.VectorNumpy(*, x: float, y: float, theta: float, e: float)
class vector.VectorNumpy(*, x: float, py: float, theta: float, e: float)
class vector.VectorNumpy(*, px: float, y: float, theta: float, e: float)
class vector.VectorNumpy(*, px: float, py: float, theta: float, e: float)
class vector.VectorNumpy(*, rho: float, phi: float, theta: float, e: float)
class vector.VectorNumpy(*, pe: float, phi: float, theta: float, e: float)
class vector.VectorNumpy(*, x: float, y: float, eta: float, e: float)
class vector.VectorNumpy(*, x: float, py: float, eta: float, e: float)
class vector.VectorNumpy(*, px: float, y: float, eta: float, e: float)
class vector.VectorNumpy(*, px: float, py: float, eta: float, e: float)
class vector.VectorNumpy(*, rho: float, phi: float, eta: float, e: float)
class vector.VectorNumpy(*, pe: float, phi: float, eta: float, e: float)
class vector.VectorNumpy(*, x: float, y: float, z: float, energy: float)
class vector.VectorNumpy(*, x: float, y: float, pz: float, energy: float)
class vector.VectorNumpy(*, x: float, py: float, z: float, energy: float)
class vector.VectorNumpy(*, x: float, py: float, pz: float, energy: float)
class vector.VectorNumpy(*, px: float, y: float, z: float, energy: float)
class vector.VectorNumpy(*, px: float, y: float, pz: float, energy: float)
class vector.VectorNumpy(*, px: float, py: float, z: float, energy: float)
class vector.VectorNumpy(*, px: float, py: float, pz: float, energy: float)
class vector.VectorNumpy(*, rho: float, phi: float, z: float, energy: float)
class vector.VectorNumpy(*, rho: float, phi: float, pz: float, energy: float)
class vector.VectorNumpy(*, pt: float, phi: float, z: float, energy: float)
class vector.VectorNumpy(*, pt: float, phi: float, pz: float, energy: float)
class vector.VectorNumpy(*, x: float, y: float, theta: float, energy: float)
class vector.VectorNumpy(*, x: float, py: float, theta: float, energy: float)
class vector.VectorNumpy(*, px: float, y: float, theta: float, energy: float)
class vector.VectorNumpy(*, px: float, py: float, theta: float, energy: float)
class vector.VectorNumpy(*, rho: float, phi: float, theta: float, energy: float)
class vector.VectorNumpy(*, pt: float, phi: float, theta: float, energy: float)
class vector.VectorNumpy(*, x: float, y: float, eta: float, energy: float)
class vector.VectorNumpy(*, x: float, py: float, eta: float, energy: float)
class vector.VectorNumpy(*, px: float, y: float, eta: float, energy: float)
class vector.VectorNumpy(*, px: float, py: float, eta: float, energy: float)
class vector.VectorNumpy(*, rho: float, phi: float, eta: float, energy: float)
class vector.VectorNumpy(*, pt: float, phi: float, eta: float, energy: float)
class vector.VectorNumpy(*, x: float, y: float, z: float, M: float)
class vector.VectorNumpy(*, x: float, y: float, pz: float, M: float)
class vector.VectorNumpy(*, x: float, py: float, z: float, M: float)
class vector.VectorNumpy(*, x: float, py: float, pz: float, M: float)
class vector.VectorNumpy(*, px: float, y: float, z: float, M: float)
class vector.VectorNumpy(*, px: float, y: float, pz: float, M: float)
class vector.VectorNumpy(*, px: float, py: float, z: float, M: float)
class vector.VectorNumpy(*, px: float, py: float, pz: float, M: float)
class vector.VectorNumpy(*, rho: float, phi: float, z: float, M: float)
class vector.VectorNumpy(*, rho: float, phi: float, pz: float, M: float)
class vector.VectorNumpy(*, pM: float, phi: float, z: float, M: float)
class vector.VectorNumpy(*, pM: float, phi: float, pz: float, M: float)
class vector.VectorNumpy(*, x: float, y: float, theta: float, M: float)
class vector.VectorNumpy(*, x: float, py: float, theta: float, M: float)
class vector.VectorNumpy(*, px: float, y: float, theta: float, M: float)
class vector.VectorNumpy(*, px: float, py: float, theta: float, M: float)
class vector.VectorNumpy(*, rho: float, phi: float, theta: float, M: float)
class vector.VectorNumpy(*, pM: float, phi: float, theta: float, M: float)
class vector.VectorNumpy(*, x: float, y: float, eta: float, M: float)
class vector.VectorNumpy(*, x: float, py: float, eta: float, M: float)
class vector.VectorNumpy(*, px: float, y: float, eta: float, M: float)
class vector.VectorNumpy(*, px: float, py: float, eta: float, M: float)
class vector.VectorNumpy(*, rho: float, phi: float, eta: float, M: float)
class vector.VectorNumpy(*, pM: float, phi: float, eta: float, M: float)
class vector.VectorNumpy(*, x: float, y: float, z: float, m: float)
class vector.VectorNumpy(*, x: float, y: float, pz: float, m: float)
class vector.VectorNumpy(*, x: float, py: float, z: float, m: float)
class vector.VectorNumpy(*, x: float, py: float, pz: float, m: float)
class vector.VectorNumpy(*, px: float, y: float, z: float, m: float)
class vector.VectorNumpy(*, px: float, y: float, pz: float, m: float)
class vector.VectorNumpy(*, px: float, py: float, z: float, m: float)
class vector.VectorNumpy(*, px: float, py: float, pz: float, m: float)
class vector.VectorNumpy(*, rho: float, phi: float, z: float, m: float)
class vector.VectorNumpy(*, rho: float, phi: float, pz: float, m: float)
class vector.VectorNumpy(*, pm: float, phi: float, z: float, m: float)
class vector.VectorNumpy(*, pm: float, phi: float, pz: float, m: float)
class vector.VectorNumpy(*, x: float, y: float, theta: float, m: float)
class vector.VectorNumpy(*, x: float, py: float, theta: float, m: float)
class vector.VectorNumpy(*, px: float, y: float, theta: float, m: float)
class vector.VectorNumpy(*, px: float, py: float, theta: float, m: float)
class vector.VectorNumpy(*, rho: float, phi: float, theta: float, m: float)
class vector.VectorNumpy(*, pm: float, phi: float, theta: float, m: float)
class vector.VectorNumpy(*, x: float, y: float, eta: float, m: float)
class vector.VectorNumpy(*, x: float, py: float, eta: float, m: float)
class vector.VectorNumpy(*, px: float, y: float, eta: float, m: float)
class vector.VectorNumpy(*, px: float, py: float, eta: float, m: float)
class vector.VectorNumpy(*, rho: float, phi: float, eta: float, m: float)
class vector.VectorNumpy(*, pm: float, phi: float, eta: float, m: float)
class vector.VectorNumpy(*, x: float, y: float, z: float, mass: float)
class vector.VectorNumpy(*, x: float, y: float, pz: float, mass: float)
class vector.VectorNumpy(*, x: float, py: float, z: float, mass: float)
class vector.VectorNumpy(*, x: float, py: float, pz: float, mass: float)
class vector.VectorNumpy(*, px: float, y: float, z: float, mass: float)
class vector.VectorNumpy(*, px: float, y: float, pz: float, mass: float)
class vector.VectorNumpy(*, px: float, py: float, z: float, mass: float)
class vector.VectorNumpy(*, px: float, py: float, pz: float, mass: float)
class vector.VectorNumpy(*, rho: float, phi: float, z: float, mass: float)
class vector.VectorNumpy(*, rho: float, phi: float, pz: float, mass: float)
class vector.VectorNumpy(*, pt: float, phi: float, z: float, mass: float)
class vector.VectorNumpy(*, pt: float, phi: float, pz: float, mass: float)
class vector.VectorNumpy(*, x: float, y: float, theta: float, mass: float)
class vector.VectorNumpy(*, x: float, py: float, theta: float, mass: float)
class vector.VectorNumpy(*, px: float, y: float, theta: float, mass: float)
class vector.VectorNumpy(*, px: float, py: float, theta: float, mass: float)
class vector.VectorNumpy(*, rho: float, phi: float, theta: float, mass: float)
class vector.VectorNumpy(*, pt: float, phi: float, theta: float, mass: float)
class vector.VectorNumpy(*, x: float, y: float, eta: float, mass: float)
class vector.VectorNumpy(*, x: float, py: float, eta: float, mass: float)
class vector.VectorNumpy(*, px: float, y: float, eta: float, mass: float)
class vector.VectorNumpy(*, px: float, py: float, eta: float, mass: float)
class vector.VectorNumpy(*, rho: float, phi: float, eta: float, mass: float)
class vector.VectorNumpy(*, pt: float, phi: float, eta: float, mass: float)
class vector.VectorNumpy(__azimuthal: Azimuthal)
class vector.VectorNumpy(__azimuthal: Azimuthal, __longitudinal: Longitudinal)
class vector.VectorNumpy(__azimuthal: Azimuthal, __longitudinal: Longitudinal, __temporal: Temporal): Mixin class for NumPy vectors.

Casting structured arrays#

NumPy structured arrays with appropriately named fields (see above) can be cast as arrays of vectors using np.ndarray.view. Use the NumPy array subclass with the appropriate dimension below.

class vector.VectorNumpy2D(*args: Any, **kwargs: Any)#

Two dimensional vector class for the NumPy backend. This class can be directly used to construct two dimensional NumPy vectors. For two dimensional Momentum NumPy vectors see vector.backends.numpy.MomentumNumpy2D.

Examples

>>> import vector
>>> vec = vector.VectorNumpy2D([(1.1, 2.1), (1.2, 2.2), (1.3, 2.3), (1.4, 2.4), (1.5, 2.5)],
...               dtype=[('x', float), ('y', float)])
>>> vec
VectorNumpy2D([(1.1, 2.1), (1.2, 2.2), (1.3, 2.3), (1.4, 2.4), (1.5, 2.5)],
              dtype=[('x', '<f8'), ('y', '<f8')])

>>> import numpy as np
>>> import vector
>>> arr = np.array([(1.1, 2.1), (1.2, 2.2), (1.3, 2.3), (1.4, 2.4), (1.5, 2.5)],
...               dtype=[('x', float), ('y', float)])
>>> arr.view(vector.VectorNumpy2D)
VectorNumpy2D([(1.1, 2.1), (1.2, 2.2), (1.3, 2.3), (1.4, 2.4), (1.5, 2.5)],
              dtype=[('x', '<f8'), ('y', '<f8')])

class vector.MomentumNumpy2D(*args: Any, **kwargs: Any)#

Two dimensional momentum vector class for the NumPy backend. This class can be directly used to construct two dimensional NumPy momentum vectors. For two dimensional NumPy vectors see vector.backends.numpy.VectorNumpy2D.

Examples

>>> import vector
>>> vec = vector.MomentumNumpy2D([(1.1, 2.1), (1.2, 2.2), (1.3, 2.3), (1.4, 2.4), (1.5, 2.5)],
...               dtype=[('px', float), ('py', float)])
>>> vec
MomentumNumpy2D([(1.1, 2.1), (1.2, 2.2), (1.3, 2.3), (1.4, 2.4), (1.5, 2.5)],
                dtype=[('x', '<f8'), ('y', '<f8')])

>>> import numpy as np
>>> import vector
>>> arr = np.array([(1.1, 2.1), (1.2, 2.2), (1.3, 2.3), (1.4, 2.4), (1.5, 2.5)],
...               dtype=[('px', float), ('py', float)])
>>> arr.view(vector.MomentumNumpy2D)
MomentumNumpy2D([(1.1, 2.1), (1.2, 2.2), (1.3, 2.3), (1.4, 2.4), (1.5, 2.5)],
                dtype=[('x', '<f8'), ('y', '<f8')])

class vector.VectorNumpy3D(*args: Any, **kwargs: Any)#

Three dimensional vector class for the NumPy backend. This class can be directly used to construct three dimensional NumPy vectors. For three dimensional Momentum NumPy vectors see vector.backends.numpy.MomentumNumpy3D.

Examples

>>> import vector
>>> vec = vector.VectorNumpy3D([(1.1, 2.1, 3.1), (1.2, 2.2, 3.2), (1.3, 2.3, 3.3), (1.4, 2.4, 3.4), (1.5, 2.5, 3.5)],
...               dtype=[('x', float), ('y', float), ('z', float)])
>>> vec
VectorNumpy3D([(1.1, 2.1, 3.1), (1.2, 2.2, 3.2), (1.3, 2.3, 3.3), (1.4, 2.4, 3.4),
               (1.5, 2.5, 3.5)], dtype=[('x', '<f8'), ('y', '<f8'), ('z', '<f8')])

>>> import numpy as np
>>> import vector
>>> arr = np.array([(1.1, 2.1, 3.1), (1.2, 2.2, 3.2), (1.3, 2.3, 3.3), (1.4, 2.4, 3.4), (1.5, 2.5, 3.5)],
...               dtype=[('x', float), ('y', float), ('z', float)])
>>> arr.view(vector.VectorNumpy3D)
VectorNumpy3D([(1.1, 2.1, 3.1), (1.2, 2.2, 3.2), (1.3, 2.3, 3.3), (1.4, 2.4, 3.4),
               (1.5, 2.5, 3.5)], dtype=[('x', '<f8'), ('y', '<f8'), ('z', '<f8')])

class vector.MomentumNumpy3D(*args: Any, **kwargs: Any)#

Three dimensional momentum vector class for the NumPy backend. This class can be directly used to construct three dimensional NumPy momentum vectors. For three dimensional NumPy vectors see vector.backends.numpy.VectorNumpy3D.

Examples

>>> import vector
>>> vec = vector.MomentumNumpy3D([(1.1, 2.1, 3.1), (1.2, 2.2, 3.2), (1.3, 2.3, 3.3), (1.4, 2.4, 3.4), (1.5, 2.5, 3.5)],
...               dtype=[('px', float), ('py', float), ('pz', float)])
>>> vec
MomentumNumpy3D([(1.1, 2.1, 3.1), (1.2, 2.2, 3.2), (1.3, 2.3, 3.3), (1.4, 2.4, 3.4),
                 (1.5, 2.5, 3.5)], dtype=[('x', '<f8'), ('y', '<f8'), ('z', '<f8')])

>>> import numpy as np
>>> import vector
>>> arr = np.array([(1.1, 2.1, 3.1), (1.2, 2.2, 3.2), (1.3, 2.3, 3.3), (1.4, 2.4, 3.4), (1.5, 2.5, 3.5)],
...               dtype=[('px', float), ('py', float), ('pz', float)])
>>> arr.view(vector.MomentumNumpy3D)
MomentumNumpy3D([(1.1, 2.1, 3.1), (1.2, 2.2, 3.2), (1.3, 2.3, 3.3), (1.4, 2.4, 3.4),
                 (1.5, 2.5, 3.5)], dtype=[('x', '<f8'), ('y', '<f8'), ('z', '<f8')])

class vector.VectorNumpy4D(*args: Any, **kwargs: Any)#

Four dimensional vector class for the NumPy backend. This class can be directly used to construct four dimensional NumPy vectors. For four dimensional Momentum NumPy vectors see vector.backends.numpy.MomentumNumpy4D.

Examples

>>> import vector
>>> vec = vector.VectorNumpy4D([(1.1, 2.1, 3.1, 4.1), (1.2, 2.2, 3.2, 4.2), (1.3, 2.3, 3.3, 4.3), (1.4, 2.4, 3.4, 4.4), (1.5, 2.5, 3.5, 4.5)],
...               dtype=[('x', float), ('y', float), ('z', float), ('t', float)])
>>> vec
VectorNumpy4D([(1.1, 2.1, 3.1, 4.1), (1.2, 2.2, 3.2, 4.2), (1.3, 2.3, 3.3, 4.3),
               (1.4, 2.4, 3.4, 4.4), (1.5, 2.5, 3.5, 4.5)],
              dtype=[('x', '<f8'), ('y', '<f8'), ('z', '<f8'), ('t', '<f8')])

>>> import numpy as np
>>> import vector
>>> arr = np.array([(1.1, 2.1, 3.1, 4.1), (1.2, 2.2, 3.2, 4.2), (1.3, 2.3, 3.3, 4.3), (1.4, 2.4, 3.4, 4.4), (1.5, 2.5, 3.5, 4.5)],
...               dtype=[('x', float), ('y', float), ('z', float), ('t', float)])
>>> arr.view(vector.VectorNumpy4D)
VectorNumpy4D([(1.1, 2.1, 3.1, 4.1), (1.2, 2.2, 3.2, 4.2), (1.3, 2.3, 3.3, 4.3),
               (1.4, 2.4, 3.4, 4.4), (1.5, 2.5, 3.5, 4.5)],
              dtype=[('x', '<f8'), ('y', '<f8'), ('z', '<f8'), ('t', '<f8')])

class vector.MomentumNumpy4D(*args: Any, **kwargs: Any)#

Four dimensional momentum vector class for the NumPy backend. This class can be directly used to construct four dimensional NumPy momentum vectors. For three dimensional NumPy vectors see vector.backends.numpy.VectorNumpy4D.

Examples

>>> import vector
>>> vec = vector.MomentumNumpy4D([(1.1, 2.1, 3.1, 4.1), (1.2, 2.2, 3.2, 4.2), (1.3, 2.3, 3.3, 4.3), (1.4, 2.4, 3.4, 4.4), (1.5, 2.5, 3.5, 4.5)],
...               dtype=[('px', float), ('py', float), ('pz', float), ('t', float)])
>>> vec
MomentumNumpy4D([(1.1, 2.1, 3.1, 4.1), (1.2, 2.2, 3.2, 4.2), (1.3, 2.3, 3.3, 4.3),
                 (1.4, 2.4, 3.4, 4.4), (1.5, 2.5, 3.5, 4.5)],
                dtype=[('x', '<f8'), ('y', '<f8'), ('z', '<f8'), ('t', '<f8')])

>>> import numpy as np
>>> import vector
>>> arr = np.array([(1.1, 2.1, 3.1, 4.1), (1.2, 2.2, 3.2, 4.2), (1.3, 2.3, 3.3, 4.3), (1.4, 2.4, 3.4, 4.4), (1.5, 2.5, 3.5, 4.5)],
...               dtype=[('px', float), ('py', float), ('pz', float), ('t', float)])
>>> arr.view(vector.MomentumNumpy4D)
MomentumNumpy4D([(1.1, 2.1, 3.1, 4.1), (1.2, 2.2, 3.2, 4.2), (1.3, 2.3, 3.3, 4.3),
                 (1.4, 2.4, 3.4, 4.4), (1.5, 2.5, 3.5, 4.5)],
                dtype=[('x', '<f8'), ('y', '<f8'), ('z', '<f8'), ('t', '<f8')])

Making NumPy arrays of vectors

Contents

Making NumPy arrays of vectors#

General constructor#

Casting structured arrays#