Ctrl+K

vector.backends.numpy module

Contents

vector.backends.numpy module#

Defines behaviors for NumPy Array. New arrays created with the

vector.array(...)

function will have these behaviors built in (and will pass them to any derived arrays).

class vector.backends.numpy.AzimuthalNumpy#

Bases: CoordinatesNumpy, Azimuthal

Azimuthal class for the NumPy backend.

ObjectClass: type[AzimuthalObject]#
class vector.backends.numpy.AzimuthalNumpyRhoPhi(*args: Any, **kwargs: Any)#

Bases: AzimuthalNumpy, AzimuthalRhoPhi, GetItem, ndarray

Class for the rho and phi (azimuthal) coordinates of NumPy backend. Creates a structured NumPy array and returns it as an AzimuthalNumpyXY object.

Examples

>>> import vector
>>> vector.backends.numpy.AzimuthalNumpyRhoPhi([(1, 1), (2.1, 3.1)], dtype=[("rho", float), ("phi", float)])
AzimuthalNumpyRhoPhi([(1. , 1. ), (2.1, 3.1)],
                     dtype=[('rho', '<f8'), ('phi', '<f8')])
ObjectClass#

alias of AzimuthalObjectRhoPhi

_IS_MOMENTUM: ClassVar[bool] = False#
property elements: tuple[ndarray, ndarray]#

Azimuthal coordinates (rho and phi) as a tuple.

Each coordinate is a NumPy array of values and not a vector.

Examples

>>> import vector
>>> vec = vector.backends.numpy.AzimuthalNumpyRhoPhi([(1, 1), (2.1, 3.1)], dtype=[("rho", float), ("phi", float)])
>>> vec.elements
(array([1. , 2.1]), array([1. , 3.1]))
property phi: ndarray#

The phi coordinates.

property rho: ndarray#

The rho coordinates.

class vector.backends.numpy.AzimuthalNumpyXY(*args: Any, **kwargs: Any)#

Bases: AzimuthalNumpy, AzimuthalXY, GetItem, ndarray

Class for the x and y (azimuthal) coordinates of NumPy backend. Creates a structured NumPy array and returns it as an AzimuthalNumpyXY object.

Examples

>>> import vector
>>> vector.backends.numpy.AzimuthalNumpyXY([(1, 1), (2.1, 3.1)], dtype=[("x", float), ("y", float)])
AzimuthalNumpyXY([(1. , 1. ), (2.1, 3.1)],
                 dtype=[('x', '<f8'), ('y', '<f8')])
ObjectClass#

alias of AzimuthalObjectXY

_IS_MOMENTUM: ClassVar[bool] = False#
property elements: tuple[ndarray, ndarray]#

Azimuthal coordinates (x and y) as a tuple.

Each coordinate is a NumPy array of values and not a vector.

Examples

>>> import vector
>>> vec = vector.backends.numpy.AzimuthalNumpyXY([(1, 1), (2.1, 3.1)], dtype=[("x", float), ("y", float)])
>>> vec.elements
(array([1. , 2.1]), array([1. , 3.1]))
property x: ndarray#

The x coordinates.

property y: ndarray#

The y coordinates.

class vector.backends.numpy.CoordinatesNumpy#

Bases: object

Coordinates class for the Numpy backend.

dtype: dtype[Any]#
lib = <module 'numpy' from '/home/docs/checkouts/readthedocs.org/user_builds/vector/envs/latest/lib/python3.12/site-packages/numpy/__init__.py'>#
class vector.backends.numpy.GetItem#

Bases: object

_IS_MOMENTUM: ClassVar[bool]#
class vector.backends.numpy.LongitudinalNumpy#

Bases: CoordinatesNumpy, Longitudinal

Longitudinal class for the NumPy backend.

ObjectClass: type[LongitudinalObject]#
class vector.backends.numpy.LongitudinalNumpyEta(*args: Any, **kwargs: Any)#

Bases: LongitudinalNumpy, LongitudinalEta, GetItem, ndarray

Class for the eta (longitudinal) coordinate of NumPy backend. Creates a structured NumPy array and returns it as a LongitudinalNumpyEta object.

Examples

>>> import vector
>>> vector.backends.numpy.LongitudinalNumpyEta([(1), (2.1)], dtype=[("eta", float)])
LongitudinalNumpyEta([(1. ,), (2.1,)], dtype=[('eta', '<f8')])
ObjectClass#

alias of LongitudinalObjectEta

_IS_MOMENTUM: ClassVar[bool] = False#
property elements: tuple[ndarray]#

Longitudinal coordinates (eta) as a tuple.

Each coordinate is a NumPy array of values and not a vector.

Examples

>>> import vector
>>> vec = vector.backends.numpy.LongitudinalNumpyTheta([(1), (2.1)], dtype=[("theta", float)])
>>> vec.elements
(array([1. , 2.1]),)
property eta: ndarray#

The eta coordinates.

class vector.backends.numpy.LongitudinalNumpyTheta(*args: Any, **kwargs: Any)#

Bases: LongitudinalNumpy, LongitudinalTheta, GetItem, ndarray

Class for the theta (longitudinal) coordinate of NumPy backend. Creates a structured NumPy array and returns it as a LongitudinalNumpyTheta object.

Examples

>>> import vector
>>> vector.backends.numpy.LongitudinalNumpyTheta([(1), (2.1)], dtype=[("theta", float)])
LongitudinalNumpyTheta([(1. ,), (2.1,)], dtype=[('theta', '<f8')])
ObjectClass#

alias of LongitudinalObjectTheta

_IS_MOMENTUM: ClassVar[bool] = False#
property elements: tuple[ndarray]#

Longitudinal coordinates (theta) as a tuple.

Each coordinate is a NumPy array of values and not a vector.

Examples

>>> import vector
>>> vec = vector.backends.numpy.LongitudinalNumpyTheta([(1), (2.1)], dtype=[("theta", float)])
>>> vec.elements
(array([1. , 2.1]),)
property theta: ndarray#

The theta coordinates.

class vector.backends.numpy.LongitudinalNumpyZ(*args: Any, **kwargs: Any)#

Bases: LongitudinalNumpy, LongitudinalZ, GetItem, ndarray

Class for the z (longitudinal) coordinate of NumPy backend. Creates a structured NumPy array and returns it as a LongitudinalNumpyZ object.

Examples

>>> import vector
>>> vector.backends.numpy.LongitudinalNumpyZ([(1), (2.1)], dtype=[("z", float)])
LongitudinalNumpyZ([(1. ,), (2.1,)], dtype=[('z', '<f8')])
ObjectClass#

alias of LongitudinalObjectZ

_IS_MOMENTUM: ClassVar[bool] = False#
property elements: tuple[ndarray]#

Longitudinal coordinates (z) as a tuple.

Each coordinate is a NumPy array of values and not a vector.

Examples

>>> import vector
>>> vec = vector.backends.numpy.LongitudinalNumpyZ([(1), (2.1)], dtype=[("z", float)])
>>> vec.elements
(array([1. , 2.1]),)
property z: ndarray#

The z coordinates.

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

Bases: PlanarMomentum, VectorNumpy2D

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')])
GenericClass#

alias of VectorNumpy2D

MomentumClass#

alias of MomentumNumpy2D

ObjectClass#

alias of MomentumObject2D

ProjectionClass2D#

alias of MomentumNumpy2D

ProjectionClass3D#

alias of MomentumNumpy3D

ProjectionClass4D#

alias of MomentumNumpy4D

_IS_MOMENTUM: ClassVar[bool] = True#
class vector.backends.numpy.MomentumNumpy3D(*args: Any, **kwargs: Any)#

Bases: SpatialMomentum, VectorNumpy3D

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')])
GenericClass#

alias of VectorNumpy3D

MomentumClass#

alias of MomentumNumpy3D

ObjectClass#

alias of MomentumObject3D

ProjectionClass2D#

alias of MomentumNumpy2D

ProjectionClass3D#

alias of MomentumNumpy3D

ProjectionClass4D#

alias of MomentumNumpy4D

_IS_MOMENTUM: ClassVar[bool] = True#
class vector.backends.numpy.MomentumNumpy4D(*args: Any, **kwargs: Any)#

Bases: LorentzMomentum, VectorNumpy4D

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')])
GenericClass#

alias of VectorNumpy4D

MomentumClass#

alias of MomentumNumpy4D

ObjectClass#

alias of MomentumObject4D

ProjectionClass2D#

alias of MomentumNumpy2D

ProjectionClass3D#

alias of MomentumNumpy3D

ProjectionClass4D#

alias of MomentumNumpy4D

_IS_MOMENTUM: ClassVar[bool] = True#
class vector.backends.numpy.TemporalNumpy#

Bases: CoordinatesNumpy, Temporal

Temporal class for the NumPy backend.

ObjectClass: type[TemporalObject]#
class vector.backends.numpy.TemporalNumpyT(*args: Any, **kwargs: Any)#

Bases: TemporalNumpy, TemporalT, GetItem, ndarray

Class for the t (temporal) coordinate of NumPy backend. Creates a structured NumPy array and returns it as a TemporalNumpyT object.

Examples

>>> import vector
>>> vector.backends.numpy.TemporalNumpyT([(1), (2.1)], dtype=[("t", float)])
TemporalNumpyT([(1. ,), (2.1,)], dtype=[('t', '<f8')])
ObjectClass#

alias of TemporalObjectT

_IS_MOMENTUM: ClassVar[bool] = False#
property elements: tuple[ndarray]#

Temporal coordinates (t) as a tuple.

Each coordinate is a NumPy array of values and not a vector.

Examples

>>> import vector
>>> vec = vector.backends.numpy.TemporalNumpyT([(1), (2.1)], dtype=[("t", float)])
>>> vec.elements
(array([1. , 2.1]),)
property t: ndarray#

The t coordinates.

class vector.backends.numpy.TemporalNumpyTau(*args: Any, **kwargs: Any)#

Bases: TemporalNumpy, TemporalTau, GetItem, ndarray

Class for the tau (temporal) coordinate of NumPy backend.

ObjectClass#

alias of TemporalObjectTau

_IS_MOMENTUM: ClassVar[bool] = False#
property elements: tuple[ndarray]#

Temporal coordinates (tau) as a tuple.

Each coordinate is a NumPy array of values and not a vector.

Examples

>>> import vector
>>> vec = vector.backends.numpy.TemporalNumpyTau([(1), (2.1)], dtype=[("tau", float)])
>>> vec.elements
(array([1. , 2.1]),)
property tau: ndarray#

The tau coordinates.

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

Bases: Vector, GetItem

Mixin class for NumPy vectors.

allclose(other: VectorProtocol, rtol: float | ndarray = 1e-05, atol: float | ndarray = 1e-08, equal_nan: bool | ndarray = False) → Any#

Like np.ndarray.allclose, but for VectorNumpy.

dtype: numpy.dtype[Any]#
lib = <module 'numpy' from '/home/docs/checkouts/readthedocs.org/user_builds/vector/envs/latest/lib/python3.12/site-packages/numpy/__init__.py'>#
sum(axis: int | None = None, dtype: dtype[Any] | str | None = None, out: Any | None = None, keepdims: bool = False, initial: Any = None, where: Any = None) → SameVectorNumpyType#
class vector.backends.numpy.VectorNumpy2D(*args: Any, **kwargs: Any)#

Bases: VectorNumpy, Planar, Vector2D, ndarray

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')])
GenericClass#

alias of VectorNumpy2D

MomentumClass#

alias of MomentumNumpy2D

ObjectClass#

alias of VectorObject2D

ProjectionClass2D#

alias of VectorNumpy2D

ProjectionClass3D#

alias of VectorNumpy3D

ProjectionClass4D#

alias of VectorNumpy4D

_IS_MOMENTUM: ClassVar[bool] = False#
_azimuthal_type: type[AzimuthalNumpyXY] | type[AzimuthalNumpyRhoPhi]#
_wrap_result(cls: Any, result: Any, returns: Any, num_vecargs: Any) → Any#

Wraps the raw result of a compute function as an array of scalars or an array of vectors.

Parameters:

  • result – Value or tuple of values from a compute function.

  • returns – Signature from a dispatch_map.

  • num_vecargs (int) – Number of vector arguments in the function that would be treated on an equal footing (i.e. add has two, but rotate_axis has only one: the axis is secondary).

property azimuthal: AzimuthalNumpy#

Returns the azimuthal type class for the given VectorNumpy2D object.

Examples

>>> import vector
>>> vec = vector.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)])
>>> vec.azimuthal
AzimuthalNumpyXY([(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.backends.numpy.VectorNumpy3D(*args: Any, **kwargs: Any)#

Bases: VectorNumpy, Spatial, Vector3D, ndarray

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')])
GenericClass#

alias of VectorNumpy3D

MomentumClass#

alias of MomentumNumpy3D

ObjectClass#

alias of VectorObject3D

ProjectionClass2D#

alias of VectorNumpy2D

ProjectionClass3D#

alias of VectorNumpy3D

ProjectionClass4D#

alias of VectorNumpy4D

_IS_MOMENTUM: ClassVar[bool] = False#
_azimuthal_type: type[AzimuthalNumpyXY] | type[AzimuthalNumpyRhoPhi]#
_longitudinal_type: type[LongitudinalNumpyZ] | type[LongitudinalNumpyTheta] | type[LongitudinalNumpyEta]#
_wrap_result(cls: Any, result: Any, returns: Any, num_vecargs: Any) → Any#

Wraps the raw result of a compute function as an array of scalars or an array of vectors.

Parameters:

  • result – Value or tuple of values from a compute function.

  • returns – Signature from a dispatch_map.

  • num_vecargs (int) – Number of vector arguments in the function that would be treated on an equal footing (i.e. add has two, but rotate_axis has only one: the axis is secondary).

property azimuthal: AzimuthalNumpy#

Returns the azimuthal type class for the given VectorNumpy3D object.

property longitudinal: LongitudinalNumpy#

Returns the longitudinal type class for the given VectorNumpy3D object.

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

Bases: VectorNumpy, Lorentz, Vector4D, ndarray

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')])
GenericClass#

alias of VectorNumpy4D

MomentumClass#

alias of MomentumNumpy4D

ObjectClass#

alias of VectorObject4D

ProjectionClass2D#

alias of VectorNumpy2D

ProjectionClass3D#

alias of VectorNumpy3D

ProjectionClass4D#

alias of VectorNumpy4D

_IS_MOMENTUM: ClassVar[bool] = False#
_azimuthal_type: type[AzimuthalNumpyXY] | type[AzimuthalNumpyRhoPhi]#
_longitudinal_type: type[LongitudinalNumpyZ] | type[LongitudinalNumpyTheta] | type[LongitudinalNumpyEta]#
_temporal_type: type[TemporalNumpyT] | type[TemporalNumpyTau]#
_wrap_result(cls: Any, result: Any, returns: Any, num_vecargs: Any) → Any#

Wraps the raw result of a compute function as an array of scalars or an array of vectors.

Parameters:

  • result – Value or tuple of values from a compute function.

  • returns – Signature from a dispatch_map.

  • num_vecargs (int) – Number of vector arguments in the function that would be treated on an equal footing (i.e. add has two, but rotate_axis has only one: the axis is secondary).

property azimuthal: AzimuthalNumpy#

Returns the azimuthal type class for the given VectorNumpy4D object.

property longitudinal: LongitudinalNumpy#

Returns the longitudinal type class for the given Vectornumpy4D object.

property temporal: TemporalNumpy#

Returns the azimuthal type class for the given VectorNumpy4D object.

vector.backends.numpy._array_from_columns(columns: dict[str, Any]) → Any#

Converts a dictionary (or columns) of coordinates to an array.

Parameters:

columns (dict) – The dictionary of coordinates to be converted.

Returns:

A structured array of coordinates.

Return type:

np.ndarray

Examples

>>> import vector
>>> vector.backends.numpy._array_from_columns({"x": [1, 2, 3], "y": [1, 2, 4]})
array([(1., 1.), (2., 2.), (3., 4.)], dtype=[('x', '<f8'), ('y', '<f8')])
vector.backends.numpy._array_repr(array: VectorNumpy2D | VectorNumpy3D | VectorNumpy4D, is_momentum: bool) → str#

Constructs the value for __repr__ function of the provided VectorNumpy class.

vector.backends.numpy._getitem(array: VectorNumpy2D | VectorNumpy3D | VectorNumpy4D, where: Any, is_momentum: bool) → float | ndarray#

Implementation for the __getitem__ method. See GetItem for more details.

vector.backends.numpy._has(array: VectorNumpy2D | VectorNumpy3D | VectorNumpy4D | MomentumNumpy2D | MomentumNumpy3D | MomentumNumpy4D | CoordinatesNumpy, names: tuple[str, ...]) → bool#

Checks if a NumPy vector has the provided coordinate attributes.

Parameters:

  • array (NumPy vector) – A NumPy Vector whose coordinate attributes have to be checked.

  • names (tuple) – Names of the attributes.

Returns:

If the attribute exists or not.

Return type:

bool

Examples

>>> from vector.backends.numpy import _has
>>> from vector._methods import _coordinate_class_to_names
>>> vec = vector.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)])
>>> _has(vec, ("x", "y"))
True
>>> _has(vec, _coordinate_class_to_names[vector._methods.AzimuthalXY])
True
>>> _has(vec, _coordinate_class_to_names[vector._methods.AzimuthalRhoPhi])
False
vector.backends.numpy._is_type_safe(array: VectorNumpy2D | VectorNumpy3D | VectorNumpy4D | MomentumNumpy2D | MomentumNumpy3D | MomentumNumpy4D | CoordinatesNumpy) → bool#
vector.backends.numpy._reduce_count_nonzero(a: T, axis: int | None = None, *, keepdims: bool = False) → Any#
vector.backends.numpy._reduce_sum(a: T, axis: int | None = None, dtype: Any = None, out: Any = None, keepdims: bool = False, initial: Any = None, where: Any = None) → T#
vector.backends.numpy._setitem(array: VectorNumpy2D | VectorNumpy3D | VectorNumpy4D, where: Any, what: Any, is_momentum: bool) → None#
vector.backends.numpy._shape_of(result: tuple[ndarray, ...] | Any) → tuple[int, ...]#

Calculates the shape of a tuple of ``numpy.array``s. The shape returned is the highest (numerical) value of the shapes present in the tuple.

Parameters:

result (tuple) – A tuple of ``numpy.array``s.

Returns:

The calculated shape.

Return type:

tuple

Examples

>>> from vector.backends.numpy import _shape_of
>>> import numpy as np
>>> _shape_of((np.array([1]), np.array([2])))
(1,)
>>> _shape_of((np.array([1]), np.array([2, 8]), np.array([0])))
(2,)
>>> _shape_of((np.array([1]), np.array([2, 8])))
(2,)
vector.backends.numpy._toarrays(result: tuple[Any, ...] | Any) → tuple[ndarray, ...]#

Converts a tuple of values to a tuple of ``numpy.array``s.

Parameters:

result (tuple) – A tuple of values to be converted.

Returns:

A tuple of numpy.array.

Return type:

tuple

Examples
>>> from vector.backends.numpy import _toarrays
>>> _toarrays((1, 2, 3, 4))
(array([1.]), array([2.]), array([3.]), array([4.]))
>>> _toarrays((1, 2, (1, 2, 3)))
(array([1.]), array([2.]), array([[1., 2., 3.]]))
>>> _toarrays((1, 2, (1, 2, False)))
(array([1.]), array([2.]), array([[1., 2., 0.]]))
vector.backends.numpy.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.

Contents