Making SymPy vector expressions

SymPy expressions are not numerical, they’re purely algebraic. However, the same Vector computations can be performed on them.

To construct a symbolic vector, first create symbols for its components and ensure that they are real-valued (not complex),

>>> import sympy
>>> x, y, z, t, px, py, pz, eta, tau = sympy.symbols(
...     "x y z t px py pz eta tau", real=True
... )

then use one of Vector’s SymPy constructors (geometric or momentum),

>>> vector.VectorSympy2D(x=x, y=y)
VectorSympy2D(x=x, y=y)
>>>
>>> vector.MomentumSympy3D(px=px, py=py, pz=pz)
MomentumSympy3D(px=px, py=py, pz=pz)
>>>
>>> vector.VectorSympy4D(x=x, y=y, eta=eta, tau=tau)
vector.VectorSympy4D(x=x, y=y, eta=eta, tau=tau)

which are documented below.

2D constructors

class vector.VectorSympy2D(*, x: float, y: float)

class vector.VectorSympy2D(*, rho: float, phi: float)

class vector.VectorSympy2D(*, x: float, y: float, z: float)

class vector.VectorSympy2D(*, x: float, y: float, eta: float)

class vector.VectorSympy2D(*, x: float, y: float, theta: float)

class vector.VectorSympy2D(*, rho: float, phi: float, z: float)

class vector.VectorSympy2D(*, rho: float, phi: float, eta: float)

class vector.VectorSympy2D(*, rho: float, phi: float, theta: float)

class vector.VectorSympy2D(*, px: float, py: float)

class vector.VectorSympy2D(*, x: float, py: float)

class vector.VectorSympy2D(*, px: float, y: float)

class vector.VectorSympy2D(*, pt: float, phi: float)

class vector.VectorSympy2D(*, x: float, y: float, pz: float)

class vector.VectorSympy2D(*, x: float, py: float, z: float)

class vector.VectorSympy2D(*, x: float, py: float, pz: float)

class vector.VectorSympy2D(*, px: float, y: float, z: float)

class vector.VectorSympy2D(*, px: float, y: float, pz: float)

class vector.VectorSympy2D(*, px: float, py: float, z: float)

class vector.VectorSympy2D(*, px: float, py: float, pz: float)

class vector.VectorSympy2D(*, rho: float, phi: float, pz: float)

class vector.VectorSympy2D(*, pt: float, phi: float, z: float)

class vector.VectorSympy2D(*, pt: float, phi: float, pz: float)

class vector.VectorSympy2D(*, x: float, py: float, theta: float)

class vector.VectorSympy2D(*, px: float, y: float, theta: float)

class vector.VectorSympy2D(*, px: float, py: float, theta: float)

class vector.VectorSympy2D(*, pt: float, phi: float, theta: float)

class vector.VectorSympy2D(*, x: float, py: float, eta: float)

class vector.VectorSympy2D(*, px: float, y: float, eta: float)

class vector.VectorSympy2D(*, px: float, py: float, eta: float)

class vector.VectorSympy2D(*, pt: float, phi: float, eta: float)

class vector.VectorSympy2D(*, x: float, y: float, z: float, t: float)

class vector.VectorSympy2D(*, x: float, y: float, pz: float, t: float)

class vector.VectorSympy2D(*, x: float, py: float, z: float, t: float)

class vector.VectorSympy2D(*, x: float, py: float, pz: float, t: float)

class vector.VectorSympy2D(*, px: float, y: float, z: float, t: float)

class vector.VectorSympy2D(*, px: float, y: float, pz: float, t: float)

class vector.VectorSympy2D(*, px: float, py: float, z: float, t: float)

class vector.VectorSympy2D(*, px: float, py: float, pz: float, t: float)

class vector.VectorSympy2D(*, rho: float, phi: float, z: float, t: float)

class vector.VectorSympy2D(*, rho: float, phi: float, pz: float, t: float)

class vector.VectorSympy2D(*, pt: float, phi: float, z: float, t: float)

class vector.VectorSympy2D(*, pt: float, phi: float, pz: float, t: float)

class vector.VectorSympy2D(*, x: float, y: float, theta: float, t: float)

class vector.VectorSympy2D(*, x: float, py: float, theta: float, t: float)

class vector.VectorSympy2D(*, px: float, y: float, theta: float, t: float)

class vector.VectorSympy2D(*, px: float, py: float, theta: float, t: float)

class vector.VectorSympy2D(*, rho: float, phi: float, theta: float, t: float)

class vector.VectorSympy2D(*, pt: float, phi: float, theta: float, t: float)

class vector.VectorSympy2D(*, x: float, y: float, eta: float, t: float)

class vector.VectorSympy2D(*, x: float, py: float, eta: float, t: float)

class vector.VectorSympy2D(*, px: float, y: float, eta: float, t: float)

class vector.VectorSympy2D(*, px: float, py: float, eta: float, t: float)

class vector.VectorSympy2D(*, rho: float, phi: float, eta: float, t: float)

class vector.VectorSympy2D(*, pt: float, phi: float, eta: float, t: float)

class vector.VectorSympy2D(*, x: float, y: float, z: float, tau: float)

class vector.VectorSympy2D(*, x: float, y: float, pz: float, tau: float)

class vector.VectorSympy2D(*, x: float, py: float, z: float, tau: float)

class vector.VectorSympy2D(*, x: float, py: float, pz: float, tau: float)

class vector.VectorSympy2D(*, px: float, y: float, z: float, tau: float)

class vector.VectorSympy2D(*, px: float, y: float, pz: float, tau: float)

class vector.VectorSympy2D(*, px: float, py: float, z: float, tau: float)

class vector.VectorSympy2D(*, px: float, py: float, pz: float, tau: float)

class vector.VectorSympy2D(*, rho: float, phi: float, z: float, tau: float)

class vector.VectorSympy2D(*, rho: float, phi: float, pz: float, tau: float)

class vector.VectorSympy2D(*, ptau: float, phi: float, z: float, tau: float)

class vector.VectorSympy2D(*, ptau: float, phi: float, pz: float, tau: float)

class vector.VectorSympy2D(*, x: float, y: float, theta: float, tau: float)

class vector.VectorSympy2D(*, x: float, py: float, theta: float, tau: float)

class vector.VectorSympy2D(*, px: float, y: float, theta: float, tau: float)

class vector.VectorSympy2D(*, px: float, py: float, theta: float, tau: float)

class vector.VectorSympy2D(*, rho: float, phi: float, theta: float, tau: float)

class vector.VectorSympy2D(*, ptau: float, phi: float, theta: float, tau: float)

class vector.VectorSympy2D(*, x: float, y: float, eta: float, tau: float)

class vector.VectorSympy2D(*, x: float, py: float, eta: float, tau: float)

class vector.VectorSympy2D(*, px: float, y: float, eta: float, tau: float)

class vector.VectorSympy2D(*, px: float, py: float, eta: float, tau: float)

class vector.VectorSympy2D(*, rho: float, phi: float, eta: float, tau: float)

class vector.VectorSympy2D(*, ptau: float, phi: float, eta: float, tau: float)

class vector.VectorSympy2D(*, x: float, y: float, z: float, E: float)

class vector.VectorSympy2D(*, x: float, y: float, pz: float, E: float)

class vector.VectorSympy2D(*, x: float, py: float, z: float, E: float)

class vector.VectorSympy2D(*, x: float, py: float, pz: float, E: float)

class vector.VectorSympy2D(*, px: float, y: float, z: float, E: float)

class vector.VectorSympy2D(*, px: float, y: float, pz: float, E: float)

class vector.VectorSympy2D(*, px: float, py: float, z: float, E: float)

class vector.VectorSympy2D(*, px: float, py: float, pz: float, E: float)

class vector.VectorSympy2D(*, rho: float, phi: float, z: float, E: float)

class vector.VectorSympy2D(*, rho: float, phi: float, pz: float, E: float)

class vector.VectorSympy2D(*, pE: float, phi: float, z: float, E: float)

class vector.VectorSympy2D(*, pE: float, phi: float, pz: float, E: float)

class vector.VectorSympy2D(*, x: float, y: float, theta: float, E: float)

class vector.VectorSympy2D(*, x: float, py: float, theta: float, E: float)

class vector.VectorSympy2D(*, px: float, y: float, theta: float, E: float)

class vector.VectorSympy2D(*, px: float, py: float, theta: float, E: float)

class vector.VectorSympy2D(*, rho: float, phi: float, theta: float, E: float)

class vector.VectorSympy2D(*, pE: float, phi: float, theta: float, E: float)

class vector.VectorSympy2D(*, x: float, y: float, eta: float, E: float)

class vector.VectorSympy2D(*, x: float, py: float, eta: float, E: float)

class vector.VectorSympy2D(*, px: float, y: float, eta: float, E: float)

class vector.VectorSympy2D(*, px: float, py: float, eta: float, E: float)

class vector.VectorSympy2D(*, rho: float, phi: float, eta: float, E: float)

class vector.VectorSympy2D(*, pE: float, phi: float, eta: float, E: float)

class vector.VectorSympy2D(*, x: float, y: float, z: float, e: float)

class vector.VectorSympy2D(*, x: float, y: float, pz: float, e: float)

class vector.VectorSympy2D(*, x: float, py: float, z: float, e: float)

class vector.VectorSympy2D(*, x: float, py: float, pz: float, e: float)

class vector.VectorSympy2D(*, px: float, y: float, z: float, e: float)

class vector.VectorSympy2D(*, px: float, y: float, pz: float, e: float)

class vector.VectorSympy2D(*, px: float, py: float, z: float, e: float)

class vector.VectorSympy2D(*, px: float, py: float, pz: float, e: float)

class vector.VectorSympy2D(*, rho: float, phi: float, z: float, e: float)

class vector.VectorSympy2D(*, rho: float, phi: float, pz: float, e: float)

class vector.VectorSympy2D(*, pe: float, phi: float, z: float, e: float)

class vector.VectorSympy2D(*, pe: float, phi: float, pz: float, e: float)

class vector.VectorSympy2D(*, x: float, y: float, theta: float, e: float)

class vector.VectorSympy2D(*, x: float, py: float, theta: float, e: float)

class vector.VectorSympy2D(*, px: float, y: float, theta: float, e: float)

class vector.VectorSympy2D(*, px: float, py: float, theta: float, e: float)

class vector.VectorSympy2D(*, rho: float, phi: float, theta: float, e: float)

class vector.VectorSympy2D(*, pe: float, phi: float, theta: float, e: float)

class vector.VectorSympy2D(*, x: float, y: float, eta: float, e: float)

class vector.VectorSympy2D(*, x: float, py: float, eta: float, e: float)

class vector.VectorSympy2D(*, px: float, y: float, eta: float, e: float)

class vector.VectorSympy2D(*, px: float, py: float, eta: float, e: float)

class vector.VectorSympy2D(*, rho: float, phi: float, eta: float, e: float)

class vector.VectorSympy2D(*, pe: float, phi: float, eta: float, e: float)

class vector.VectorSympy2D(*, x: float, y: float, z: float, energy: float)

class vector.VectorSympy2D(*, x: float, y: float, pz: float, energy: float)

class vector.VectorSympy2D(*, x: float, py: float, z: float, energy: float)

class vector.VectorSympy2D(*, x: float, py: float, pz: float, energy: float)

class vector.VectorSympy2D(*, px: float, y: float, z: float, energy: float)

class vector.VectorSympy2D(*, px: float, y: float, pz: float, energy: float)

class vector.VectorSympy2D(*, px: float, py: float, z: float, energy: float)

class vector.VectorSympy2D(*, px: float, py: float, pz: float, energy: float)

class vector.VectorSympy2D(*, rho: float, phi: float, z: float, energy: float)

class vector.VectorSympy2D(*, rho: float, phi: float, pz: float, energy: float)

class vector.VectorSympy2D(*, pt: float, phi: float, z: float, energy: float)

class vector.VectorSympy2D(*, pt: float, phi: float, pz: float, energy: float)

class vector.VectorSympy2D(*, x: float, y: float, theta: float, energy: float)

class vector.VectorSympy2D(*, x: float, py: float, theta: float, energy: float)

class vector.VectorSympy2D(*, px: float, y: float, theta: float, energy: float)

class vector.VectorSympy2D(*, px: float, py: float, theta: float, energy: float)

class vector.VectorSympy2D(*, rho: float, phi: float, theta: float, energy: float)

class vector.VectorSympy2D(*, pt: float, phi: float, theta: float, energy: float)

class vector.VectorSympy2D(*, x: float, y: float, eta: float, energy: float)

class vector.VectorSympy2D(*, x: float, py: float, eta: float, energy: float)

class vector.VectorSympy2D(*, px: float, y: float, eta: float, energy: float)

class vector.VectorSympy2D(*, px: float, py: float, eta: float, energy: float)

class vector.VectorSympy2D(*, rho: float, phi: float, eta: float, energy: float)

class vector.VectorSympy2D(*, pt: float, phi: float, eta: float, energy: float)

class vector.VectorSympy2D(*, x: float, y: float, z: float, M: float)

class vector.VectorSympy2D(*, x: float, y: float, pz: float, M: float)

class vector.VectorSympy2D(*, x: float, py: float, z: float, M: float)

class vector.VectorSympy2D(*, x: float, py: float, pz: float, M: float)

class vector.VectorSympy2D(*, px: float, y: float, z: float, M: float)

class vector.VectorSympy2D(*, px: float, y: float, pz: float, M: float)

class vector.VectorSympy2D(*, px: float, py: float, z: float, M: float)

class vector.VectorSympy2D(*, px: float, py: float, pz: float, M: float)

class vector.VectorSympy2D(*, rho: float, phi: float, z: float, M: float)

class vector.VectorSympy2D(*, rho: float, phi: float, pz: float, M: float)

class vector.VectorSympy2D(*, pM: float, phi: float, z: float, M: float)

class vector.VectorSympy2D(*, pM: float, phi: float, pz: float, M: float)

class vector.VectorSympy2D(*, x: float, y: float, theta: float, M: float)

class vector.VectorSympy2D(*, x: float, py: float, theta: float, M: float)

class vector.VectorSympy2D(*, px: float, y: float, theta: float, M: float)

class vector.VectorSympy2D(*, px: float, py: float, theta: float, M: float)

class vector.VectorSympy2D(*, rho: float, phi: float, theta: float, M: float)

class vector.VectorSympy2D(*, pM: float, phi: float, theta: float, M: float)

class vector.VectorSympy2D(*, x: float, y: float, eta: float, M: float)

class vector.VectorSympy2D(*, x: float, py: float, eta: float, M: float)

class vector.VectorSympy2D(*, px: float, y: float, eta: float, M: float)

class vector.VectorSympy2D(*, px: float, py: float, eta: float, M: float)

class vector.VectorSympy2D(*, rho: float, phi: float, eta: float, M: float)

class vector.VectorSympy2D(*, pM: float, phi: float, eta: float, M: float)

class vector.VectorSympy2D(*, x: float, y: float, z: float, m: float)

class vector.VectorSympy2D(*, x: float, y: float, pz: float, m: float)

class vector.VectorSympy2D(*, x: float, py: float, z: float, m: float)

class vector.VectorSympy2D(*, x: float, py: float, pz: float, m: float)

class vector.VectorSympy2D(*, px: float, y: float, z: float, m: float)

class vector.VectorSympy2D(*, px: float, y: float, pz: float, m: float)

class vector.VectorSympy2D(*, px: float, py: float, z: float, m: float)

class vector.VectorSympy2D(*, px: float, py: float, pz: float, m: float)

class vector.VectorSympy2D(*, rho: float, phi: float, z: float, m: float)

class vector.VectorSympy2D(*, rho: float, phi: float, pz: float, m: float)

class vector.VectorSympy2D(*, pm: float, phi: float, z: float, m: float)

class vector.VectorSympy2D(*, pm: float, phi: float, pz: float, m: float)

class vector.VectorSympy2D(*, x: float, y: float, theta: float, m: float)

class vector.VectorSympy2D(*, x: float, py: float, theta: float, m: float)

class vector.VectorSympy2D(*, px: float, y: float, theta: float, m: float)

class vector.VectorSympy2D(*, px: float, py: float, theta: float, m: float)

class vector.VectorSympy2D(*, rho: float, phi: float, theta: float, m: float)

class vector.VectorSympy2D(*, pm: float, phi: float, theta: float, m: float)

class vector.VectorSympy2D(*, x: float, y: float, eta: float, m: float)

class vector.VectorSympy2D(*, x: float, py: float, eta: float, m: float)

class vector.VectorSympy2D(*, px: float, y: float, eta: float, m: float)

class vector.VectorSympy2D(*, px: float, py: float, eta: float, m: float)

class vector.VectorSympy2D(*, rho: float, phi: float, eta: float, m: float)

class vector.VectorSympy2D(*, pm: float, phi: float, eta: float, m: float)

class vector.VectorSympy2D(*, x: float, y: float, z: float, mass: float)

class vector.VectorSympy2D(*, x: float, y: float, pz: float, mass: float)

class vector.VectorSympy2D(*, x: float, py: float, z: float, mass: float)

class vector.VectorSympy2D(*, x: float, py: float, pz: float, mass: float)

class vector.VectorSympy2D(*, px: float, y: float, z: float, mass: float)

class vector.VectorSympy2D(*, px: float, y: float, pz: float, mass: float)

class vector.VectorSympy2D(*, px: float, py: float, z: float, mass: float)

class vector.VectorSympy2D(*, px: float, py: float, pz: float, mass: float)

class vector.VectorSympy2D(*, rho: float, phi: float, z: float, mass: float)

class vector.VectorSympy2D(*, rho: float, phi: float, pz: float, mass: float)

class vector.VectorSympy2D(*, pt: float, phi: float, z: float, mass: float)

class vector.VectorSympy2D(*, pt: float, phi: float, pz: float, mass: float)

class vector.VectorSympy2D(*, x: float, y: float, theta: float, mass: float)

class vector.VectorSympy2D(*, x: float, py: float, theta: float, mass: float)

class vector.VectorSympy2D(*, px: float, y: float, theta: float, mass: float)

class vector.VectorSympy2D(*, px: float, py: float, theta: float, mass: float)

class vector.VectorSympy2D(*, rho: float, phi: float, theta: float, mass: float)

class vector.VectorSympy2D(*, pt: float, phi: float, theta: float, mass: float)

class vector.VectorSympy2D(*, x: float, y: float, eta: float, mass: float)

class vector.VectorSympy2D(*, x: float, py: float, eta: float, mass: float)

class vector.VectorSympy2D(*, px: float, y: float, eta: float, mass: float)

class vector.VectorSympy2D(*, px: float, py: float, eta: float, mass: float)

class vector.VectorSympy2D(*, rho: float, phi: float, eta: float, mass: float)

class vector.VectorSympy2D(*, pt: float, phi: float, eta: float, mass: float)

class vector.VectorSympy2D(__azimuthal: Azimuthal)

class vector.VectorSympy2D(__azimuthal: Azimuthal, __longitudinal: Longitudinal)

class vector.VectorSympy2D(__azimuthal: Azimuthal, __longitudinal: Longitudinal, __temporal: Temporal)

Two dimensional vector class for the SymPy backend.

Examples

>>> import vector; import sympy
>>> vec = vector.VectorSympy2D(x=sympy.Symbol("x"), y=sympy.Symbol("y"))
>>> vec.x, vec.y
(x, y)
>>> vec = vector.VectorSympy2D(rho=sympy.Symbol("rho"), phi=sympy.Symbol("phi"))
>>> vec.rho, vec.phi
(rho, phi)

For two dimensional momentum SymPy vectors, see vector.backends.sympy.MomentumSympy2D.

class vector.MomentumSympy2D(*, x: float, y: float)

class vector.MomentumSympy2D(*, rho: float, phi: float)

class vector.MomentumSympy2D(*, x: float, y: float, z: float)

class vector.MomentumSympy2D(*, x: float, y: float, eta: float)

class vector.MomentumSympy2D(*, x: float, y: float, theta: float)

class vector.MomentumSympy2D(*, rho: float, phi: float, z: float)

class vector.MomentumSympy2D(*, rho: float, phi: float, eta: float)

class vector.MomentumSympy2D(*, rho: float, phi: float, theta: float)

class vector.MomentumSympy2D(*, px: float, py: float)

class vector.MomentumSympy2D(*, x: float, py: float)

class vector.MomentumSympy2D(*, px: float, y: float)

class vector.MomentumSympy2D(*, pt: float, phi: float)

class vector.MomentumSympy2D(*, x: float, y: float, pz: float)

class vector.MomentumSympy2D(*, x: float, py: float, z: float)

class vector.MomentumSympy2D(*, x: float, py: float, pz: float)

class vector.MomentumSympy2D(*, px: float, y: float, z: float)

class vector.MomentumSympy2D(*, px: float, y: float, pz: float)

class vector.MomentumSympy2D(*, px: float, py: float, z: float)

class vector.MomentumSympy2D(*, px: float, py: float, pz: float)

class vector.MomentumSympy2D(*, rho: float, phi: float, pz: float)

class vector.MomentumSympy2D(*, pt: float, phi: float, z: float)

class vector.MomentumSympy2D(*, pt: float, phi: float, pz: float)

class vector.MomentumSympy2D(*, x: float, py: float, theta: float)

class vector.MomentumSympy2D(*, px: float, y: float, theta: float)

class vector.MomentumSympy2D(*, px: float, py: float, theta: float)

class vector.MomentumSympy2D(*, pt: float, phi: float, theta: float)

class vector.MomentumSympy2D(*, x: float, py: float, eta: float)

class vector.MomentumSympy2D(*, px: float, y: float, eta: float)

class vector.MomentumSympy2D(*, px: float, py: float, eta: float)

class vector.MomentumSympy2D(*, pt: float, phi: float, eta: float)

class vector.MomentumSympy2D(*, x: float, y: float, z: float, t: float)

class vector.MomentumSympy2D(*, x: float, y: float, pz: float, t: float)

class vector.MomentumSympy2D(*, x: float, py: float, z: float, t: float)

class vector.MomentumSympy2D(*, x: float, py: float, pz: float, t: float)

class vector.MomentumSympy2D(*, px: float, y: float, z: float, t: float)

class vector.MomentumSympy2D(*, px: float, y: float, pz: float, t: float)

class vector.MomentumSympy2D(*, px: float, py: float, z: float, t: float)

class vector.MomentumSympy2D(*, px: float, py: float, pz: float, t: float)

class vector.MomentumSympy2D(*, rho: float, phi: float, z: float, t: float)

class vector.MomentumSympy2D(*, rho: float, phi: float, pz: float, t: float)

class vector.MomentumSympy2D(*, pt: float, phi: float, z: float, t: float)

class vector.MomentumSympy2D(*, pt: float, phi: float, pz: float, t: float)

class vector.MomentumSympy2D(*, x: float, y: float, theta: float, t: float)

class vector.MomentumSympy2D(*, x: float, py: float, theta: float, t: float)

class vector.MomentumSympy2D(*, px: float, y: float, theta: float, t: float)

class vector.MomentumSympy2D(*, px: float, py: float, theta: float, t: float)

class vector.MomentumSympy2D(*, rho: float, phi: float, theta: float, t: float)

class vector.MomentumSympy2D(*, pt: float, phi: float, theta: float, t: float)

class vector.MomentumSympy2D(*, x: float, y: float, eta: float, t: float)

class vector.MomentumSympy2D(*, x: float, py: float, eta: float, t: float)

class vector.MomentumSympy2D(*, px: float, y: float, eta: float, t: float)

class vector.MomentumSympy2D(*, px: float, py: float, eta: float, t: float)

class vector.MomentumSympy2D(*, rho: float, phi: float, eta: float, t: float)

class vector.MomentumSympy2D(*, pt: float, phi: float, eta: float, t: float)

class vector.MomentumSympy2D(*, x: float, y: float, z: float, tau: float)

class vector.MomentumSympy2D(*, x: float, y: float, pz: float, tau: float)

class vector.MomentumSympy2D(*, x: float, py: float, z: float, tau: float)

class vector.MomentumSympy2D(*, x: float, py: float, pz: float, tau: float)

class vector.MomentumSympy2D(*, px: float, y: float, z: float, tau: float)

class vector.MomentumSympy2D(*, px: float, y: float, pz: float, tau: float)

class vector.MomentumSympy2D(*, px: float, py: float, z: float, tau: float)

class vector.MomentumSympy2D(*, px: float, py: float, pz: float, tau: float)

class vector.MomentumSympy2D(*, rho: float, phi: float, z: float, tau: float)

class vector.MomentumSympy2D(*, rho: float, phi: float, pz: float, tau: float)

class vector.MomentumSympy2D(*, ptau: float, phi: float, z: float, tau: float)

class vector.MomentumSympy2D(*, ptau: float, phi: float, pz: float, tau: float)

class vector.MomentumSympy2D(*, x: float, y: float, theta: float, tau: float)

class vector.MomentumSympy2D(*, x: float, py: float, theta: float, tau: float)

class vector.MomentumSympy2D(*, px: float, y: float, theta: float, tau: float)

class vector.MomentumSympy2D(*, px: float, py: float, theta: float, tau: float)

class vector.MomentumSympy2D(*, rho: float, phi: float, theta: float, tau: float)

class vector.MomentumSympy2D(*, ptau: float, phi: float, theta: float, tau: float)

class vector.MomentumSympy2D(*, x: float, y: float, eta: float, tau: float)

class vector.MomentumSympy2D(*, x: float, py: float, eta: float, tau: float)

class vector.MomentumSympy2D(*, px: float, y: float, eta: float, tau: float)

class vector.MomentumSympy2D(*, px: float, py: float, eta: float, tau: float)

class vector.MomentumSympy2D(*, rho: float, phi: float, eta: float, tau: float)

class vector.MomentumSympy2D(*, ptau: float, phi: float, eta: float, tau: float)

class vector.MomentumSympy2D(*, x: float, y: float, z: float, E: float)

class vector.MomentumSympy2D(*, x: float, y: float, pz: float, E: float)

class vector.MomentumSympy2D(*, x: float, py: float, z: float, E: float)

class vector.MomentumSympy2D(*, x: float, py: float, pz: float, E: float)

class vector.MomentumSympy2D(*, px: float, y: float, z: float, E: float)

class vector.MomentumSympy2D(*, px: float, y: float, pz: float, E: float)

class vector.MomentumSympy2D(*, px: float, py: float, z: float, E: float)

class vector.MomentumSympy2D(*, px: float, py: float, pz: float, E: float)

class vector.MomentumSympy2D(*, rho: float, phi: float, z: float, E: float)

class vector.MomentumSympy2D(*, rho: float, phi: float, pz: float, E: float)

class vector.MomentumSympy2D(*, pE: float, phi: float, z: float, E: float)

class vector.MomentumSympy2D(*, pE: float, phi: float, pz: float, E: float)

class vector.MomentumSympy2D(*, x: float, y: float, theta: float, E: float)

class vector.MomentumSympy2D(*, x: float, py: float, theta: float, E: float)

class vector.MomentumSympy2D(*, px: float, y: float, theta: float, E: float)

class vector.MomentumSympy2D(*, px: float, py: float, theta: float, E: float)

class vector.MomentumSympy2D(*, rho: float, phi: float, theta: float, E: float)

class vector.MomentumSympy2D(*, pE: float, phi: float, theta: float, E: float)

class vector.MomentumSympy2D(*, x: float, y: float, eta: float, E: float)

class vector.MomentumSympy2D(*, x: float, py: float, eta: float, E: float)

class vector.MomentumSympy2D(*, px: float, y: float, eta: float, E: float)

class vector.MomentumSympy2D(*, px: float, py: float, eta: float, E: float)

class vector.MomentumSympy2D(*, rho: float, phi: float, eta: float, E: float)

class vector.MomentumSympy2D(*, pE: float, phi: float, eta: float, E: float)

class vector.MomentumSympy2D(*, x: float, y: float, z: float, e: float)

class vector.MomentumSympy2D(*, x: float, y: float, pz: float, e: float)

class vector.MomentumSympy2D(*, x: float, py: float, z: float, e: float)

class vector.MomentumSympy2D(*, x: float, py: float, pz: float, e: float)

class vector.MomentumSympy2D(*, px: float, y: float, z: float, e: float)

class vector.MomentumSympy2D(*, px: float, y: float, pz: float, e: float)

class vector.MomentumSympy2D(*, px: float, py: float, z: float, e: float)

class vector.MomentumSympy2D(*, px: float, py: float, pz: float, e: float)

class vector.MomentumSympy2D(*, rho: float, phi: float, z: float, e: float)

class vector.MomentumSympy2D(*, rho: float, phi: float, pz: float, e: float)

class vector.MomentumSympy2D(*, pe: float, phi: float, z: float, e: float)

class vector.MomentumSympy2D(*, pe: float, phi: float, pz: float, e: float)

class vector.MomentumSympy2D(*, x: float, y: float, theta: float, e: float)

class vector.MomentumSympy2D(*, x: float, py: float, theta: float, e: float)

class vector.MomentumSympy2D(*, px: float, y: float, theta: float, e: float)

class vector.MomentumSympy2D(*, px: float, py: float, theta: float, e: float)

class vector.MomentumSympy2D(*, rho: float, phi: float, theta: float, e: float)

class vector.MomentumSympy2D(*, pe: float, phi: float, theta: float, e: float)

class vector.MomentumSympy2D(*, x: float, y: float, eta: float, e: float)

class vector.MomentumSympy2D(*, x: float, py: float, eta: float, e: float)

class vector.MomentumSympy2D(*, px: float, y: float, eta: float, e: float)

class vector.MomentumSympy2D(*, px: float, py: float, eta: float, e: float)

class vector.MomentumSympy2D(*, rho: float, phi: float, eta: float, e: float)

class vector.MomentumSympy2D(*, pe: float, phi: float, eta: float, e: float)

class vector.MomentumSympy2D(*, x: float, y: float, z: float, energy: float)

class vector.MomentumSympy2D(*, x: float, y: float, pz: float, energy: float)

class vector.MomentumSympy2D(*, x: float, py: float, z: float, energy: float)

class vector.MomentumSympy2D(*, x: float, py: float, pz: float, energy: float)

class vector.MomentumSympy2D(*, px: float, y: float, z: float, energy: float)

class vector.MomentumSympy2D(*, px: float, y: float, pz: float, energy: float)

class vector.MomentumSympy2D(*, px: float, py: float, z: float, energy: float)

class vector.MomentumSympy2D(*, px: float, py: float, pz: float, energy: float)

class vector.MomentumSympy2D(*, rho: float, phi: float, z: float, energy: float)

class vector.MomentumSympy2D(*, rho: float, phi: float, pz: float, energy: float)

class vector.MomentumSympy2D(*, pt: float, phi: float, z: float, energy: float)

class vector.MomentumSympy2D(*, pt: float, phi: float, pz: float, energy: float)

class vector.MomentumSympy2D(*, x: float, y: float, theta: float, energy: float)

class vector.MomentumSympy2D(*, x: float, py: float, theta: float, energy: float)

class vector.MomentumSympy2D(*, px: float, y: float, theta: float, energy: float)

class vector.MomentumSympy2D(*, px: float, py: float, theta: float, energy: float)

class vector.MomentumSympy2D(*, rho: float, phi: float, theta: float, energy: float)

class vector.MomentumSympy2D(*, pt: float, phi: float, theta: float, energy: float)

class vector.MomentumSympy2D(*, x: float, y: float, eta: float, energy: float)

class vector.MomentumSympy2D(*, x: float, py: float, eta: float, energy: float)

class vector.MomentumSympy2D(*, px: float, y: float, eta: float, energy: float)

class vector.MomentumSympy2D(*, px: float, py: float, eta: float, energy: float)

class vector.MomentumSympy2D(*, rho: float, phi: float, eta: float, energy: float)

class vector.MomentumSympy2D(*, pt: float, phi: float, eta: float, energy: float)

class vector.MomentumSympy2D(*, x: float, y: float, z: float, M: float)

class vector.MomentumSympy2D(*, x: float, y: float, pz: float, M: float)

class vector.MomentumSympy2D(*, x: float, py: float, z: float, M: float)

class vector.MomentumSympy2D(*, x: float, py: float, pz: float, M: float)

class vector.MomentumSympy2D(*, px: float, y: float, z: float, M: float)

class vector.MomentumSympy2D(*, px: float, y: float, pz: float, M: float)

class vector.MomentumSympy2D(*, px: float, py: float, z: float, M: float)

class vector.MomentumSympy2D(*, px: float, py: float, pz: float, M: float)

class vector.MomentumSympy2D(*, rho: float, phi: float, z: float, M: float)

class vector.MomentumSympy2D(*, rho: float, phi: float, pz: float, M: float)

class vector.MomentumSympy2D(*, pM: float, phi: float, z: float, M: float)

class vector.MomentumSympy2D(*, pM: float, phi: float, pz: float, M: float)

class vector.MomentumSympy2D(*, x: float, y: float, theta: float, M: float)

class vector.MomentumSympy2D(*, x: float, py: float, theta: float, M: float)

class vector.MomentumSympy2D(*, px: float, y: float, theta: float, M: float)

class vector.MomentumSympy2D(*, px: float, py: float, theta: float, M: float)

class vector.MomentumSympy2D(*, rho: float, phi: float, theta: float, M: float)

class vector.MomentumSympy2D(*, pM: float, phi: float, theta: float, M: float)

class vector.MomentumSympy2D(*, x: float, y: float, eta: float, M: float)

class vector.MomentumSympy2D(*, x: float, py: float, eta: float, M: float)

class vector.MomentumSympy2D(*, px: float, y: float, eta: float, M: float)

class vector.MomentumSympy2D(*, px: float, py: float, eta: float, M: float)

class vector.MomentumSympy2D(*, rho: float, phi: float, eta: float, M: float)

class vector.MomentumSympy2D(*, pM: float, phi: float, eta: float, M: float)

class vector.MomentumSympy2D(*, x: float, y: float, z: float, m: float)

class vector.MomentumSympy2D(*, x: float, y: float, pz: float, m: float)

class vector.MomentumSympy2D(*, x: float, py: float, z: float, m: float)

class vector.MomentumSympy2D(*, x: float, py: float, pz: float, m: float)

class vector.MomentumSympy2D(*, px: float, y: float, z: float, m: float)

class vector.MomentumSympy2D(*, px: float, y: float, pz: float, m: float)

class vector.MomentumSympy2D(*, px: float, py: float, z: float, m: float)

class vector.MomentumSympy2D(*, px: float, py: float, pz: float, m: float)

class vector.MomentumSympy2D(*, rho: float, phi: float, z: float, m: float)

class vector.MomentumSympy2D(*, rho: float, phi: float, pz: float, m: float)

class vector.MomentumSympy2D(*, pm: float, phi: float, z: float, m: float)

class vector.MomentumSympy2D(*, pm: float, phi: float, pz: float, m: float)

class vector.MomentumSympy2D(*, x: float, y: float, theta: float, m: float)

class vector.MomentumSympy2D(*, x: float, py: float, theta: float, m: float)

class vector.MomentumSympy2D(*, px: float, y: float, theta: float, m: float)

class vector.MomentumSympy2D(*, px: float, py: float, theta: float, m: float)

class vector.MomentumSympy2D(*, rho: float, phi: float, theta: float, m: float)

class vector.MomentumSympy2D(*, pm: float, phi: float, theta: float, m: float)

class vector.MomentumSympy2D(*, x: float, y: float, eta: float, m: float)

class vector.MomentumSympy2D(*, x: float, py: float, eta: float, m: float)

class vector.MomentumSympy2D(*, px: float, y: float, eta: float, m: float)

class vector.MomentumSympy2D(*, px: float, py: float, eta: float, m: float)

class vector.MomentumSympy2D(*, rho: float, phi: float, eta: float, m: float)

class vector.MomentumSympy2D(*, pm: float, phi: float, eta: float, m: float)

class vector.MomentumSympy2D(*, x: float, y: float, z: float, mass: float)

class vector.MomentumSympy2D(*, x: float, y: float, pz: float, mass: float)

class vector.MomentumSympy2D(*, x: float, py: float, z: float, mass: float)

class vector.MomentumSympy2D(*, x: float, py: float, pz: float, mass: float)

class vector.MomentumSympy2D(*, px: float, y: float, z: float, mass: float)

class vector.MomentumSympy2D(*, px: float, y: float, pz: float, mass: float)

class vector.MomentumSympy2D(*, px: float, py: float, z: float, mass: float)

class vector.MomentumSympy2D(*, px: float, py: float, pz: float, mass: float)

class vector.MomentumSympy2D(*, rho: float, phi: float, z: float, mass: float)

class vector.MomentumSympy2D(*, rho: float, phi: float, pz: float, mass: float)

class vector.MomentumSympy2D(*, pt: float, phi: float, z: float, mass: float)

class vector.MomentumSympy2D(*, pt: float, phi: float, pz: float, mass: float)

class vector.MomentumSympy2D(*, x: float, y: float, theta: float, mass: float)

class vector.MomentumSympy2D(*, x: float, py: float, theta: float, mass: float)

class vector.MomentumSympy2D(*, px: float, y: float, theta: float, mass: float)

class vector.MomentumSympy2D(*, px: float, py: float, theta: float, mass: float)

class vector.MomentumSympy2D(*, rho: float, phi: float, theta: float, mass: float)

class vector.MomentumSympy2D(*, pt: float, phi: float, theta: float, mass: float)

class vector.MomentumSympy2D(*, x: float, y: float, eta: float, mass: float)

class vector.MomentumSympy2D(*, x: float, py: float, eta: float, mass: float)

class vector.MomentumSympy2D(*, px: float, y: float, eta: float, mass: float)

class vector.MomentumSympy2D(*, px: float, py: float, eta: float, mass: float)

class vector.MomentumSympy2D(*, rho: float, phi: float, eta: float, mass: float)

class vector.MomentumSympy2D(*, pt: float, phi: float, eta: float, mass: float)

class vector.MomentumSympy2D(__azimuthal: Azimuthal)

class vector.MomentumSympy2D(__azimuthal: Azimuthal, __longitudinal: Longitudinal)

class vector.MomentumSympy2D(__azimuthal: Azimuthal, __longitudinal: Longitudinal, __temporal: Temporal)

Two dimensional momentum vector class for the SymPy backend.

Examples

>>> import vector; import sympy
>>> vec = vector.MomentumSympy2D(px=sympy.Symbol("px"), py=sympy.Symbol("py"))
>>> vec.px, vec.py
(px, py)
>>> vec = vector.MomentumSympy2D(pt=sympy.Symbol("pt"), phi=sympy.Symbol("phi"))
>>> vec.pt, vec.phi
(pt, phi)

For two dimensional SymPy vectors, see vector.backends.object.VectorSympy2D.

3D constructors

class vector.VectorSympy3D(*, x: float, y: float)

class vector.VectorSympy3D(*, rho: float, phi: float)

class vector.VectorSympy3D(*, x: float, y: float, z: float)

class vector.VectorSympy3D(*, x: float, y: float, eta: float)

class vector.VectorSympy3D(*, x: float, y: float, theta: float)

class vector.VectorSympy3D(*, rho: float, phi: float, z: float)

class vector.VectorSympy3D(*, rho: float, phi: float, eta: float)

class vector.VectorSympy3D(*, rho: float, phi: float, theta: float)

class vector.VectorSympy3D(*, px: float, py: float)

class vector.VectorSympy3D(*, x: float, py: float)

class vector.VectorSympy3D(*, px: float, y: float)

class vector.VectorSympy3D(*, pt: float, phi: float)

class vector.VectorSympy3D(*, x: float, y: float, pz: float)

class vector.VectorSympy3D(*, x: float, py: float, z: float)

class vector.VectorSympy3D(*, x: float, py: float, pz: float)

class vector.VectorSympy3D(*, px: float, y: float, z: float)

class vector.VectorSympy3D(*, px: float, y: float, pz: float)

class vector.VectorSympy3D(*, px: float, py: float, z: float)

class vector.VectorSympy3D(*, px: float, py: float, pz: float)

class vector.VectorSympy3D(*, rho: float, phi: float, pz: float)

class vector.VectorSympy3D(*, pt: float, phi: float, z: float)

class vector.VectorSympy3D(*, pt: float, phi: float, pz: float)

class vector.VectorSympy3D(*, x: float, py: float, theta: float)

class vector.VectorSympy3D(*, px: float, y: float, theta: float)

class vector.VectorSympy3D(*, px: float, py: float, theta: float)

class vector.VectorSympy3D(*, pt: float, phi: float, theta: float)

class vector.VectorSympy3D(*, x: float, py: float, eta: float)

class vector.VectorSympy3D(*, px: float, y: float, eta: float)

class vector.VectorSympy3D(*, px: float, py: float, eta: float)

class vector.VectorSympy3D(*, pt: float, phi: float, eta: float)

class vector.VectorSympy3D(*, x: float, y: float, z: float, t: float)

class vector.VectorSympy3D(*, x: float, y: float, pz: float, t: float)

class vector.VectorSympy3D(*, x: float, py: float, z: float, t: float)

class vector.VectorSympy3D(*, x: float, py: float, pz: float, t: float)

class vector.VectorSympy3D(*, px: float, y: float, z: float, t: float)

class vector.VectorSympy3D(*, px: float, y: float, pz: float, t: float)

class vector.VectorSympy3D(*, px: float, py: float, z: float, t: float)

class vector.VectorSympy3D(*, px: float, py: float, pz: float, t: float)

class vector.VectorSympy3D(*, rho: float, phi: float, z: float, t: float)

class vector.VectorSympy3D(*, rho: float, phi: float, pz: float, t: float)

class vector.VectorSympy3D(*, pt: float, phi: float, z: float, t: float)

class vector.VectorSympy3D(*, pt: float, phi: float, pz: float, t: float)

class vector.VectorSympy3D(*, x: float, y: float, theta: float, t: float)

class vector.VectorSympy3D(*, x: float, py: float, theta: float, t: float)

class vector.VectorSympy3D(*, px: float, y: float, theta: float, t: float)

class vector.VectorSympy3D(*, px: float, py: float, theta: float, t: float)

class vector.VectorSympy3D(*, rho: float, phi: float, theta: float, t: float)

class vector.VectorSympy3D(*, pt: float, phi: float, theta: float, t: float)

class vector.VectorSympy3D(*, x: float, y: float, eta: float, t: float)

class vector.VectorSympy3D(*, x: float, py: float, eta: float, t: float)

class vector.VectorSympy3D(*, px: float, y: float, eta: float, t: float)

class vector.VectorSympy3D(*, px: float, py: float, eta: float, t: float)

class vector.VectorSympy3D(*, rho: float, phi: float, eta: float, t: float)

class vector.VectorSympy3D(*, pt: float, phi: float, eta: float, t: float)

class vector.VectorSympy3D(*, x: float, y: float, z: float, tau: float)

class vector.VectorSympy3D(*, x: float, y: float, pz: float, tau: float)

class vector.VectorSympy3D(*, x: float, py: float, z: float, tau: float)

class vector.VectorSympy3D(*, x: float, py: float, pz: float, tau: float)

class vector.VectorSympy3D(*, px: float, y: float, z: float, tau: float)

class vector.VectorSympy3D(*, px: float, y: float, pz: float, tau: float)

class vector.VectorSympy3D(*, px: float, py: float, z: float, tau: float)

class vector.VectorSympy3D(*, px: float, py: float, pz: float, tau: float)

class vector.VectorSympy3D(*, rho: float, phi: float, z: float, tau: float)

class vector.VectorSympy3D(*, rho: float, phi: float, pz: float, tau: float)

class vector.VectorSympy3D(*, ptau: float, phi: float, z: float, tau: float)

class vector.VectorSympy3D(*, ptau: float, phi: float, pz: float, tau: float)

class vector.VectorSympy3D(*, x: float, y: float, theta: float, tau: float)

class vector.VectorSympy3D(*, x: float, py: float, theta: float, tau: float)

class vector.VectorSympy3D(*, px: float, y: float, theta: float, tau: float)

class vector.VectorSympy3D(*, px: float, py: float, theta: float, tau: float)

class vector.VectorSympy3D(*, rho: float, phi: float, theta: float, tau: float)

class vector.VectorSympy3D(*, ptau: float, phi: float, theta: float, tau: float)

class vector.VectorSympy3D(*, x: float, y: float, eta: float, tau: float)

class vector.VectorSympy3D(*, x: float, py: float, eta: float, tau: float)

class vector.VectorSympy3D(*, px: float, y: float, eta: float, tau: float)

class vector.VectorSympy3D(*, px: float, py: float, eta: float, tau: float)

class vector.VectorSympy3D(*, rho: float, phi: float, eta: float, tau: float)

class vector.VectorSympy3D(*, ptau: float, phi: float, eta: float, tau: float)

class vector.VectorSympy3D(*, x: float, y: float, z: float, E: float)

class vector.VectorSympy3D(*, x: float, y: float, pz: float, E: float)

class vector.VectorSympy3D(*, x: float, py: float, z: float, E: float)

class vector.VectorSympy3D(*, x: float, py: float, pz: float, E: float)

class vector.VectorSympy3D(*, px: float, y: float, z: float, E: float)

class vector.VectorSympy3D(*, px: float, y: float, pz: float, E: float)

class vector.VectorSympy3D(*, px: float, py: float, z: float, E: float)

class vector.VectorSympy3D(*, px: float, py: float, pz: float, E: float)

class vector.VectorSympy3D(*, rho: float, phi: float, z: float, E: float)

class vector.VectorSympy3D(*, rho: float, phi: float, pz: float, E: float)

class vector.VectorSympy3D(*, pE: float, phi: float, z: float, E: float)

class vector.VectorSympy3D(*, pE: float, phi: float, pz: float, E: float)

class vector.VectorSympy3D(*, x: float, y: float, theta: float, E: float)

class vector.VectorSympy3D(*, x: float, py: float, theta: float, E: float)

class vector.VectorSympy3D(*, px: float, y: float, theta: float, E: float)

class vector.VectorSympy3D(*, px: float, py: float, theta: float, E: float)

class vector.VectorSympy3D(*, rho: float, phi: float, theta: float, E: float)

class vector.VectorSympy3D(*, pE: float, phi: float, theta: float, E: float)

class vector.VectorSympy3D(*, x: float, y: float, eta: float, E: float)

class vector.VectorSympy3D(*, x: float, py: float, eta: float, E: float)

class vector.VectorSympy3D(*, px: float, y: float, eta: float, E: float)

class vector.VectorSympy3D(*, px: float, py: float, eta: float, E: float)

class vector.VectorSympy3D(*, rho: float, phi: float, eta: float, E: float)

class vector.VectorSympy3D(*, pE: float, phi: float, eta: float, E: float)

class vector.VectorSympy3D(*, x: float, y: float, z: float, e: float)

class vector.VectorSympy3D(*, x: float, y: float, pz: float, e: float)

class vector.VectorSympy3D(*, x: float, py: float, z: float, e: float)

class vector.VectorSympy3D(*, x: float, py: float, pz: float, e: float)

class vector.VectorSympy3D(*, px: float, y: float, z: float, e: float)

class vector.VectorSympy3D(*, px: float, y: float, pz: float, e: float)

class vector.VectorSympy3D(*, px: float, py: float, z: float, e: float)

class vector.VectorSympy3D(*, px: float, py: float, pz: float, e: float)

class vector.VectorSympy3D(*, rho: float, phi: float, z: float, e: float)

class vector.VectorSympy3D(*, rho: float, phi: float, pz: float, e: float)

class vector.VectorSympy3D(*, pe: float, phi: float, z: float, e: float)

class vector.VectorSympy3D(*, pe: float, phi: float, pz: float, e: float)

class vector.VectorSympy3D(*, x: float, y: float, theta: float, e: float)

class vector.VectorSympy3D(*, x: float, py: float, theta: float, e: float)

class vector.VectorSympy3D(*, px: float, y: float, theta: float, e: float)

class vector.VectorSympy3D(*, px: float, py: float, theta: float, e: float)

class vector.VectorSympy3D(*, rho: float, phi: float, theta: float, e: float)

class vector.VectorSympy3D(*, pe: float, phi: float, theta: float, e: float)

class vector.VectorSympy3D(*, x: float, y: float, eta: float, e: float)

class vector.VectorSympy3D(*, x: float, py: float, eta: float, e: float)

class vector.VectorSympy3D(*, px: float, y: float, eta: float, e: float)

class vector.VectorSympy3D(*, px: float, py: float, eta: float, e: float)

class vector.VectorSympy3D(*, rho: float, phi: float, eta: float, e: float)

class vector.VectorSympy3D(*, pe: float, phi: float, eta: float, e: float)

class vector.VectorSympy3D(*, x: float, y: float, z: float, energy: float)

class vector.VectorSympy3D(*, x: float, y: float, pz: float, energy: float)

class vector.VectorSympy3D(*, x: float, py: float, z: float, energy: float)

class vector.VectorSympy3D(*, x: float, py: float, pz: float, energy: float)

class vector.VectorSympy3D(*, px: float, y: float, z: float, energy: float)

class vector.VectorSympy3D(*, px: float, y: float, pz: float, energy: float)

class vector.VectorSympy3D(*, px: float, py: float, z: float, energy: float)

class vector.VectorSympy3D(*, px: float, py: float, pz: float, energy: float)

class vector.VectorSympy3D(*, rho: float, phi: float, z: float, energy: float)

class vector.VectorSympy3D(*, rho: float, phi: float, pz: float, energy: float)

class vector.VectorSympy3D(*, pt: float, phi: float, z: float, energy: float)

class vector.VectorSympy3D(*, pt: float, phi: float, pz: float, energy: float)

class vector.VectorSympy3D(*, x: float, y: float, theta: float, energy: float)

class vector.VectorSympy3D(*, x: float, py: float, theta: float, energy: float)

class vector.VectorSympy3D(*, px: float, y: float, theta: float, energy: float)

class vector.VectorSympy3D(*, px: float, py: float, theta: float, energy: float)

class vector.VectorSympy3D(*, rho: float, phi: float, theta: float, energy: float)

class vector.VectorSympy3D(*, pt: float, phi: float, theta: float, energy: float)

class vector.VectorSympy3D(*, x: float, y: float, eta: float, energy: float)

class vector.VectorSympy3D(*, x: float, py: float, eta: float, energy: float)

class vector.VectorSympy3D(*, px: float, y: float, eta: float, energy: float)

class vector.VectorSympy3D(*, px: float, py: float, eta: float, energy: float)

class vector.VectorSympy3D(*, rho: float, phi: float, eta: float, energy: float)

class vector.VectorSympy3D(*, pt: float, phi: float, eta: float, energy: float)

class vector.VectorSympy3D(*, x: float, y: float, z: float, M: float)

class vector.VectorSympy3D(*, x: float, y: float, pz: float, M: float)

class vector.VectorSympy3D(*, x: float, py: float, z: float, M: float)

class vector.VectorSympy3D(*, x: float, py: float, pz: float, M: float)

class vector.VectorSympy3D(*, px: float, y: float, z: float, M: float)

class vector.VectorSympy3D(*, px: float, y: float, pz: float, M: float)

class vector.VectorSympy3D(*, px: float, py: float, z: float, M: float)

class vector.VectorSympy3D(*, px: float, py: float, pz: float, M: float)

class vector.VectorSympy3D(*, rho: float, phi: float, z: float, M: float)

class vector.VectorSympy3D(*, rho: float, phi: float, pz: float, M: float)

class vector.VectorSympy3D(*, pM: float, phi: float, z: float, M: float)

class vector.VectorSympy3D(*, pM: float, phi: float, pz: float, M: float)

class vector.VectorSympy3D(*, x: float, y: float, theta: float, M: float)

class vector.VectorSympy3D(*, x: float, py: float, theta: float, M: float)

class vector.VectorSympy3D(*, px: float, y: float, theta: float, M: float)

class vector.VectorSympy3D(*, px: float, py: float, theta: float, M: float)

class vector.VectorSympy3D(*, rho: float, phi: float, theta: float, M: float)

class vector.VectorSympy3D(*, pM: float, phi: float, theta: float, M: float)

class vector.VectorSympy3D(*, x: float, y: float, eta: float, M: float)

class vector.VectorSympy3D(*, x: float, py: float, eta: float, M: float)

class vector.VectorSympy3D(*, px: float, y: float, eta: float, M: float)

class vector.VectorSympy3D(*, px: float, py: float, eta: float, M: float)

class vector.VectorSympy3D(*, rho: float, phi: float, eta: float, M: float)

class vector.VectorSympy3D(*, pM: float, phi: float, eta: float, M: float)

class vector.VectorSympy3D(*, x: float, y: float, z: float, m: float)

class vector.VectorSympy3D(*, x: float, y: float, pz: float, m: float)

class vector.VectorSympy3D(*, x: float, py: float, z: float, m: float)

class vector.VectorSympy3D(*, x: float, py: float, pz: float, m: float)

class vector.VectorSympy3D(*, px: float, y: float, z: float, m: float)

class vector.VectorSympy3D(*, px: float, y: float, pz: float, m: float)

class vector.VectorSympy3D(*, px: float, py: float, z: float, m: float)

class vector.VectorSympy3D(*, px: float, py: float, pz: float, m: float)

class vector.VectorSympy3D(*, rho: float, phi: float, z: float, m: float)

class vector.VectorSympy3D(*, rho: float, phi: float, pz: float, m: float)

class vector.VectorSympy3D(*, pm: float, phi: float, z: float, m: float)

class vector.VectorSympy3D(*, pm: float, phi: float, pz: float, m: float)

class vector.VectorSympy3D(*, x: float, y: float, theta: float, m: float)

class vector.VectorSympy3D(*, x: float, py: float, theta: float, m: float)

class vector.VectorSympy3D(*, px: float, y: float, theta: float, m: float)

class vector.VectorSympy3D(*, px: float, py: float, theta: float, m: float)

class vector.VectorSympy3D(*, rho: float, phi: float, theta: float, m: float)

class vector.VectorSympy3D(*, pm: float, phi: float, theta: float, m: float)

class vector.VectorSympy3D(*, x: float, y: float, eta: float, m: float)

class vector.VectorSympy3D(*, x: float, py: float, eta: float, m: float)

class vector.VectorSympy3D(*, px: float, y: float, eta: float, m: float)

class vector.VectorSympy3D(*, px: float, py: float, eta: float, m: float)

class vector.VectorSympy3D(*, rho: float, phi: float, eta: float, m: float)

class vector.VectorSympy3D(*, pm: float, phi: float, eta: float, m: float)

class vector.VectorSympy3D(*, x: float, y: float, z: float, mass: float)

class vector.VectorSympy3D(*, x: float, y: float, pz: float, mass: float)

class vector.VectorSympy3D(*, x: float, py: float, z: float, mass: float)

class vector.VectorSympy3D(*, x: float, py: float, pz: float, mass: float)

class vector.VectorSympy3D(*, px: float, y: float, z: float, mass: float)

class vector.VectorSympy3D(*, px: float, y: float, pz: float, mass: float)

class vector.VectorSympy3D(*, px: float, py: float, z: float, mass: float)

class vector.VectorSympy3D(*, px: float, py: float, pz: float, mass: float)

class vector.VectorSympy3D(*, rho: float, phi: float, z: float, mass: float)

class vector.VectorSympy3D(*, rho: float, phi: float, pz: float, mass: float)

class vector.VectorSympy3D(*, pt: float, phi: float, z: float, mass: float)

class vector.VectorSympy3D(*, pt: float, phi: float, pz: float, mass: float)

class vector.VectorSympy3D(*, x: float, y: float, theta: float, mass: float)

class vector.VectorSympy3D(*, x: float, py: float, theta: float, mass: float)

class vector.VectorSympy3D(*, px: float, y: float, theta: float, mass: float)

class vector.VectorSympy3D(*, px: float, py: float, theta: float, mass: float)

class vector.VectorSympy3D(*, rho: float, phi: float, theta: float, mass: float)

class vector.VectorSympy3D(*, pt: float, phi: float, theta: float, mass: float)

class vector.VectorSympy3D(*, x: float, y: float, eta: float, mass: float)

class vector.VectorSympy3D(*, x: float, py: float, eta: float, mass: float)

class vector.VectorSympy3D(*, px: float, y: float, eta: float, mass: float)

class vector.VectorSympy3D(*, px: float, py: float, eta: float, mass: float)

class vector.VectorSympy3D(*, rho: float, phi: float, eta: float, mass: float)

class vector.VectorSympy3D(*, pt: float, phi: float, eta: float, mass: float)

class vector.VectorSympy3D(__azimuthal: Azimuthal)

class vector.VectorSympy3D(__azimuthal: Azimuthal, __longitudinal: Longitudinal)

class vector.VectorSympy3D(__azimuthal: Azimuthal, __longitudinal: Longitudinal, __temporal: Temporal)

Three dimensional vector class for the SymPy backend.

Examples

>>> import vector; import sympy
>>> vec = vector.VectorSympy3D(x=sympy.Symbol("x"), y=sympy.Symbol("y"), z=sympy.Symbol("z"))
>>> vec.x, vec.y, vec.z
(x, y, z)
>>> vec = vector.VectorSympy3D(rho=sympy.Symbol("rho"), phi=sympy.Symbol("phi"), eta=sympy.Symbol("eta"))
>>> vec.rho, vec.phi, vec.eta
(rho, phi, eta)

For three dimensional momentum SymPy vectors, see vector.backends.object.MomentumSympy3D.

class vector.MomentumSympy3D(*, x: float, y: float)

class vector.MomentumSympy3D(*, rho: float, phi: float)

class vector.MomentumSympy3D(*, x: float, y: float, z: float)

class vector.MomentumSympy3D(*, x: float, y: float, eta: float)

class vector.MomentumSympy3D(*, x: float, y: float, theta: float)

class vector.MomentumSympy3D(*, rho: float, phi: float, z: float)

class vector.MomentumSympy3D(*, rho: float, phi: float, eta: float)

class vector.MomentumSympy3D(*, rho: float, phi: float, theta: float)

class vector.MomentumSympy3D(*, px: float, py: float)

class vector.MomentumSympy3D(*, x: float, py: float)

class vector.MomentumSympy3D(*, px: float, y: float)

class vector.MomentumSympy3D(*, pt: float, phi: float)

class vector.MomentumSympy3D(*, x: float, y: float, pz: float)

class vector.MomentumSympy3D(*, x: float, py: float, z: float)

class vector.MomentumSympy3D(*, x: float, py: float, pz: float)

class vector.MomentumSympy3D(*, px: float, y: float, z: float)

class vector.MomentumSympy3D(*, px: float, y: float, pz: float)

class vector.MomentumSympy3D(*, px: float, py: float, z: float)

class vector.MomentumSympy3D(*, px: float, py: float, pz: float)

class vector.MomentumSympy3D(*, rho: float, phi: float, pz: float)

class vector.MomentumSympy3D(*, pt: float, phi: float, z: float)

class vector.MomentumSympy3D(*, pt: float, phi: float, pz: float)

class vector.MomentumSympy3D(*, x: float, py: float, theta: float)

class vector.MomentumSympy3D(*, px: float, y: float, theta: float)

class vector.MomentumSympy3D(*, px: float, py: float, theta: float)

class vector.MomentumSympy3D(*, pt: float, phi: float, theta: float)

class vector.MomentumSympy3D(*, x: float, py: float, eta: float)

class vector.MomentumSympy3D(*, px: float, y: float, eta: float)

class vector.MomentumSympy3D(*, px: float, py: float, eta: float)

class vector.MomentumSympy3D(*, pt: float, phi: float, eta: float)

class vector.MomentumSympy3D(*, x: float, y: float, z: float, t: float)

class vector.MomentumSympy3D(*, x: float, y: float, pz: float, t: float)

class vector.MomentumSympy3D(*, x: float, py: float, z: float, t: float)

class vector.MomentumSympy3D(*, x: float, py: float, pz: float, t: float)

class vector.MomentumSympy3D(*, px: float, y: float, z: float, t: float)

class vector.MomentumSympy3D(*, px: float, y: float, pz: float, t: float)

class vector.MomentumSympy3D(*, px: float, py: float, z: float, t: float)

class vector.MomentumSympy3D(*, px: float, py: float, pz: float, t: float)

class vector.MomentumSympy3D(*, rho: float, phi: float, z: float, t: float)

class vector.MomentumSympy3D(*, rho: float, phi: float, pz: float, t: float)

class vector.MomentumSympy3D(*, pt: float, phi: float, z: float, t: float)

class vector.MomentumSympy3D(*, pt: float, phi: float, pz: float, t: float)

class vector.MomentumSympy3D(*, x: float, y: float, theta: float, t: float)

class vector.MomentumSympy3D(*, x: float, py: float, theta: float, t: float)

class vector.MomentumSympy3D(*, px: float, y: float, theta: float, t: float)

class vector.MomentumSympy3D(*, px: float, py: float, theta: float, t: float)

class vector.MomentumSympy3D(*, rho: float, phi: float, theta: float, t: float)

class vector.MomentumSympy3D(*, pt: float, phi: float, theta: float, t: float)

class vector.MomentumSympy3D(*, x: float, y: float, eta: float, t: float)

class vector.MomentumSympy3D(*, x: float, py: float, eta: float, t: float)

class vector.MomentumSympy3D(*, px: float, y: float, eta: float, t: float)

class vector.MomentumSympy3D(*, px: float, py: float, eta: float, t: float)

class vector.MomentumSympy3D(*, rho: float, phi: float, eta: float, t: float)

class vector.MomentumSympy3D(*, pt: float, phi: float, eta: float, t: float)

class vector.MomentumSympy3D(*, x: float, y: float, z: float, tau: float)

class vector.MomentumSympy3D(*, x: float, y: float, pz: float, tau: float)

class vector.MomentumSympy3D(*, x: float, py: float, z: float, tau: float)

class vector.MomentumSympy3D(*, x: float, py: float, pz: float, tau: float)

class vector.MomentumSympy3D(*, px: float, y: float, z: float, tau: float)

class vector.MomentumSympy3D(*, px: float, y: float, pz: float, tau: float)

class vector.MomentumSympy3D(*, px: float, py: float, z: float, tau: float)

class vector.MomentumSympy3D(*, px: float, py: float, pz: float, tau: float)

class vector.MomentumSympy3D(*, rho: float, phi: float, z: float, tau: float)

class vector.MomentumSympy3D(*, rho: float, phi: float, pz: float, tau: float)

class vector.MomentumSympy3D(*, ptau: float, phi: float, z: float, tau: float)

class vector.MomentumSympy3D(*, ptau: float, phi: float, pz: float, tau: float)

class vector.MomentumSympy3D(*, x: float, y: float, theta: float, tau: float)

class vector.MomentumSympy3D(*, x: float, py: float, theta: float, tau: float)

class vector.MomentumSympy3D(*, px: float, y: float, theta: float, tau: float)

class vector.MomentumSympy3D(*, px: float, py: float, theta: float, tau: float)

class vector.MomentumSympy3D(*, rho: float, phi: float, theta: float, tau: float)

class vector.MomentumSympy3D(*, ptau: float, phi: float, theta: float, tau: float)

class vector.MomentumSympy3D(*, x: float, y: float, eta: float, tau: float)

class vector.MomentumSympy3D(*, x: float, py: float, eta: float, tau: float)

class vector.MomentumSympy3D(*, px: float, y: float, eta: float, tau: float)

class vector.MomentumSympy3D(*, px: float, py: float, eta: float, tau: float)

class vector.MomentumSympy3D(*, rho: float, phi: float, eta: float, tau: float)

class vector.MomentumSympy3D(*, ptau: float, phi: float, eta: float, tau: float)

class vector.MomentumSympy3D(*, x: float, y: float, z: float, E: float)

class vector.MomentumSympy3D(*, x: float, y: float, pz: float, E: float)

class vector.MomentumSympy3D(*, x: float, py: float, z: float, E: float)

class vector.MomentumSympy3D(*, x: float, py: float, pz: float, E: float)

class vector.MomentumSympy3D(*, px: float, y: float, z: float, E: float)

class vector.MomentumSympy3D(*, px: float, y: float, pz: float, E: float)

class vector.MomentumSympy3D(*, px: float, py: float, z: float, E: float)

class vector.MomentumSympy3D(*, px: float, py: float, pz: float, E: float)

class vector.MomentumSympy3D(*, rho: float, phi: float, z: float, E: float)

class vector.MomentumSympy3D(*, rho: float, phi: float, pz: float, E: float)

class vector.MomentumSympy3D(*, pE: float, phi: float, z: float, E: float)

class vector.MomentumSympy3D(*, pE: float, phi: float, pz: float, E: float)

class vector.MomentumSympy3D(*, x: float, y: float, theta: float, E: float)

class vector.MomentumSympy3D(*, x: float, py: float, theta: float, E: float)

class vector.MomentumSympy3D(*, px: float, y: float, theta: float, E: float)

class vector.MomentumSympy3D(*, px: float, py: float, theta: float, E: float)

class vector.MomentumSympy3D(*, rho: float, phi: float, theta: float, E: float)

class vector.MomentumSympy3D(*, pE: float, phi: float, theta: float, E: float)

class vector.MomentumSympy3D(*, x: float, y: float, eta: float, E: float)

class vector.MomentumSympy3D(*, x: float, py: float, eta: float, E: float)

class vector.MomentumSympy3D(*, px: float, y: float, eta: float, E: float)

class vector.MomentumSympy3D(*, px: float, py: float, eta: float, E: float)

class vector.MomentumSympy3D(*, rho: float, phi: float, eta: float, E: float)

class vector.MomentumSympy3D(*, pE: float, phi: float, eta: float, E: float)

class vector.MomentumSympy3D(*, x: float, y: float, z: float, e: float)

class vector.MomentumSympy3D(*, x: float, y: float, pz: float, e: float)

class vector.MomentumSympy3D(*, x: float, py: float, z: float, e: float)

class vector.MomentumSympy3D(*, x: float, py: float, pz: float, e: float)

class vector.MomentumSympy3D(*, px: float, y: float, z: float, e: float)

class vector.MomentumSympy3D(*, px: float, y: float, pz: float, e: float)

class vector.MomentumSympy3D(*, px: float, py: float, z: float, e: float)

class vector.MomentumSympy3D(*, px: float, py: float, pz: float, e: float)

class vector.MomentumSympy3D(*, rho: float, phi: float, z: float, e: float)

class vector.MomentumSympy3D(*, rho: float, phi: float, pz: float, e: float)

class vector.MomentumSympy3D(*, pe: float, phi: float, z: float, e: float)

class vector.MomentumSympy3D(*, pe: float, phi: float, pz: float, e: float)

class vector.MomentumSympy3D(*, x: float, y: float, theta: float, e: float)

class vector.MomentumSympy3D(*, x: float, py: float, theta: float, e: float)

class vector.MomentumSympy3D(*, px: float, y: float, theta: float, e: float)

class vector.MomentumSympy3D(*, px: float, py: float, theta: float, e: float)

class vector.MomentumSympy3D(*, rho: float, phi: float, theta: float, e: float)

class vector.MomentumSympy3D(*, pe: float, phi: float, theta: float, e: float)

class vector.MomentumSympy3D(*, x: float, y: float, eta: float, e: float)

class vector.MomentumSympy3D(*, x: float, py: float, eta: float, e: float)

class vector.MomentumSympy3D(*, px: float, y: float, eta: float, e: float)

class vector.MomentumSympy3D(*, px: float, py: float, eta: float, e: float)

class vector.MomentumSympy3D(*, rho: float, phi: float, eta: float, e: float)

class vector.MomentumSympy3D(*, pe: float, phi: float, eta: float, e: float)

class vector.MomentumSympy3D(*, x: float, y: float, z: float, energy: float)

class vector.MomentumSympy3D(*, x: float, y: float, pz: float, energy: float)

class vector.MomentumSympy3D(*, x: float, py: float, z: float, energy: float)

class vector.MomentumSympy3D(*, x: float, py: float, pz: float, energy: float)

class vector.MomentumSympy3D(*, px: float, y: float, z: float, energy: float)

class vector.MomentumSympy3D(*, px: float, y: float, pz: float, energy: float)

class vector.MomentumSympy3D(*, px: float, py: float, z: float, energy: float)

class vector.MomentumSympy3D(*, px: float, py: float, pz: float, energy: float)

class vector.MomentumSympy3D(*, rho: float, phi: float, z: float, energy: float)

class vector.MomentumSympy3D(*, rho: float, phi: float, pz: float, energy: float)

class vector.MomentumSympy3D(*, pt: float, phi: float, z: float, energy: float)

class vector.MomentumSympy3D(*, pt: float, phi: float, pz: float, energy: float)

class vector.MomentumSympy3D(*, x: float, y: float, theta: float, energy: float)

class vector.MomentumSympy3D(*, x: float, py: float, theta: float, energy: float)

class vector.MomentumSympy3D(*, px: float, y: float, theta: float, energy: float)

class vector.MomentumSympy3D(*, px: float, py: float, theta: float, energy: float)

class vector.MomentumSympy3D(*, rho: float, phi: float, theta: float, energy: float)

class vector.MomentumSympy3D(*, pt: float, phi: float, theta: float, energy: float)

class vector.MomentumSympy3D(*, x: float, y: float, eta: float, energy: float)

class vector.MomentumSympy3D(*, x: float, py: float, eta: float, energy: float)

class vector.MomentumSympy3D(*, px: float, y: float, eta: float, energy: float)

class vector.MomentumSympy3D(*, px: float, py: float, eta: float, energy: float)

class vector.MomentumSympy3D(*, rho: float, phi: float, eta: float, energy: float)

class vector.MomentumSympy3D(*, pt: float, phi: float, eta: float, energy: float)

class vector.MomentumSympy3D(*, x: float, y: float, z: float, M: float)

class vector.MomentumSympy3D(*, x: float, y: float, pz: float, M: float)

class vector.MomentumSympy3D(*, x: float, py: float, z: float, M: float)

class vector.MomentumSympy3D(*, x: float, py: float, pz: float, M: float)

class vector.MomentumSympy3D(*, px: float, y: float, z: float, M: float)

class vector.MomentumSympy3D(*, px: float, y: float, pz: float, M: float)

class vector.MomentumSympy3D(*, px: float, py: float, z: float, M: float)

class vector.MomentumSympy3D(*, px: float, py: float, pz: float, M: float)

class vector.MomentumSympy3D(*, rho: float, phi: float, z: float, M: float)

class vector.MomentumSympy3D(*, rho: float, phi: float, pz: float, M: float)

class vector.MomentumSympy3D(*, pM: float, phi: float, z: float, M: float)

class vector.MomentumSympy3D(*, pM: float, phi: float, pz: float, M: float)

class vector.MomentumSympy3D(*, x: float, y: float, theta: float, M: float)

class vector.MomentumSympy3D(*, x: float, py: float, theta: float, M: float)

class vector.MomentumSympy3D(*, px: float, y: float, theta: float, M: float)

class vector.MomentumSympy3D(*, px: float, py: float, theta: float, M: float)

class vector.MomentumSympy3D(*, rho: float, phi: float, theta: float, M: float)

class vector.MomentumSympy3D(*, pM: float, phi: float, theta: float, M: float)

class vector.MomentumSympy3D(*, x: float, y: float, eta: float, M: float)

class vector.MomentumSympy3D(*, x: float, py: float, eta: float, M: float)

class vector.MomentumSympy3D(*, px: float, y: float, eta: float, M: float)

class vector.MomentumSympy3D(*, px: float, py: float, eta: float, M: float)

class vector.MomentumSympy3D(*, rho: float, phi: float, eta: float, M: float)

class vector.MomentumSympy3D(*, pM: float, phi: float, eta: float, M: float)

class vector.MomentumSympy3D(*, x: float, y: float, z: float, m: float)

class vector.MomentumSympy3D(*, x: float, y: float, pz: float, m: float)

class vector.MomentumSympy3D(*, x: float, py: float, z: float, m: float)

class vector.MomentumSympy3D(*, x: float, py: float, pz: float, m: float)

class vector.MomentumSympy3D(*, px: float, y: float, z: float, m: float)

class vector.MomentumSympy3D(*, px: float, y: float, pz: float, m: float)

class vector.MomentumSympy3D(*, px: float, py: float, z: float, m: float)

class vector.MomentumSympy3D(*, px: float, py: float, pz: float, m: float)

class vector.MomentumSympy3D(*, rho: float, phi: float, z: float, m: float)

class vector.MomentumSympy3D(*, rho: float, phi: float, pz: float, m: float)

class vector.MomentumSympy3D(*, pm: float, phi: float, z: float, m: float)

class vector.MomentumSympy3D(*, pm: float, phi: float, pz: float, m: float)

class vector.MomentumSympy3D(*, x: float, y: float, theta: float, m: float)

class vector.MomentumSympy3D(*, x: float, py: float, theta: float, m: float)

class vector.MomentumSympy3D(*, px: float, y: float, theta: float, m: float)

class vector.MomentumSympy3D(*, px: float, py: float, theta: float, m: float)

class vector.MomentumSympy3D(*, rho: float, phi: float, theta: float, m: float)

class vector.MomentumSympy3D(*, pm: float, phi: float, theta: float, m: float)

class vector.MomentumSympy3D(*, x: float, y: float, eta: float, m: float)

class vector.MomentumSympy3D(*, x: float, py: float, eta: float, m: float)

class vector.MomentumSympy3D(*, px: float, y: float, eta: float, m: float)

class vector.MomentumSympy3D(*, px: float, py: float, eta: float, m: float)

class vector.MomentumSympy3D(*, rho: float, phi: float, eta: float, m: float)

class vector.MomentumSympy3D(*, pm: float, phi: float, eta: float, m: float)

class vector.MomentumSympy3D(*, x: float, y: float, z: float, mass: float)

class vector.MomentumSympy3D(*, x: float, y: float, pz: float, mass: float)

class vector.MomentumSympy3D(*, x: float, py: float, z: float, mass: float)

class vector.MomentumSympy3D(*, x: float, py: float, pz: float, mass: float)

class vector.MomentumSympy3D(*, px: float, y: float, z: float, mass: float)

class vector.MomentumSympy3D(*, px: float, y: float, pz: float, mass: float)

class vector.MomentumSympy3D(*, px: float, py: float, z: float, mass: float)

class vector.MomentumSympy3D(*, px: float, py: float, pz: float, mass: float)

class vector.MomentumSympy3D(*, rho: float, phi: float, z: float, mass: float)

class vector.MomentumSympy3D(*, rho: float, phi: float, pz: float, mass: float)

class vector.MomentumSympy3D(*, pt: float, phi: float, z: float, mass: float)

class vector.MomentumSympy3D(*, pt: float, phi: float, pz: float, mass: float)

class vector.MomentumSympy3D(*, x: float, y: float, theta: float, mass: float)

class vector.MomentumSympy3D(*, x: float, py: float, theta: float, mass: float)

class vector.MomentumSympy3D(*, px: float, y: float, theta: float, mass: float)

class vector.MomentumSympy3D(*, px: float, py: float, theta: float, mass: float)

class vector.MomentumSympy3D(*, rho: float, phi: float, theta: float, mass: float)

class vector.MomentumSympy3D(*, pt: float, phi: float, theta: float, mass: float)

class vector.MomentumSympy3D(*, x: float, y: float, eta: float, mass: float)

class vector.MomentumSympy3D(*, x: float, py: float, eta: float, mass: float)

class vector.MomentumSympy3D(*, px: float, y: float, eta: float, mass: float)

class vector.MomentumSympy3D(*, px: float, py: float, eta: float, mass: float)

class vector.MomentumSympy3D(*, rho: float, phi: float, eta: float, mass: float)

class vector.MomentumSympy3D(*, pt: float, phi: float, eta: float, mass: float)

class vector.MomentumSympy3D(__azimuthal: Azimuthal)

class vector.MomentumSympy3D(__azimuthal: Azimuthal, __longitudinal: Longitudinal)

class vector.MomentumSympy3D(__azimuthal: Azimuthal, __longitudinal: Longitudinal, __temporal: Temporal)

Three dimensional momentum vector class for the SymPy backend.

Examples

>>> import vector; import sympy
>>> vec = vector.MomentumSympy3D(px=sympy.Symbol("px"), py=sympy.Symbol("py"), pz=sympy.Symbol("pz"))
>>> vec.px, vec.py, vec.pz
(px, py, pz)
>>> vec = vector.MomentumSympy3D(pt=sympy.Symbol("pt"), phi=sympy.Symbol("phi"), pz=sympy.Symbol("pz"))
>>> vec.pt, vec.phi, vec.pz
(pt, phi, pz)

For three dimensional SymPy vectors, see vector.backends.sympy.VectorSympy3D.

4D constructors

class vector.VectorSympy4D(*, x: float, y: float)

class vector.VectorSympy4D(*, rho: float, phi: float)

class vector.VectorSympy4D(*, x: float, y: float, z: float)

class vector.VectorSympy4D(*, x: float, y: float, eta: float)

class vector.VectorSympy4D(*, x: float, y: float, theta: float)

class vector.VectorSympy4D(*, rho: float, phi: float, z: float)

class vector.VectorSympy4D(*, rho: float, phi: float, eta: float)

class vector.VectorSympy4D(*, rho: float, phi: float, theta: float)

class vector.VectorSympy4D(*, px: float, py: float)

class vector.VectorSympy4D(*, x: float, py: float)

class vector.VectorSympy4D(*, px: float, y: float)

class vector.VectorSympy4D(*, pt: float, phi: float)

class vector.VectorSympy4D(*, x: float, y: float, pz: float)

class vector.VectorSympy4D(*, x: float, py: float, z: float)

class vector.VectorSympy4D(*, x: float, py: float, pz: float)

class vector.VectorSympy4D(*, px: float, y: float, z: float)

class vector.VectorSympy4D(*, px: float, y: float, pz: float)

class vector.VectorSympy4D(*, px: float, py: float, z: float)

class vector.VectorSympy4D(*, px: float, py: float, pz: float)

class vector.VectorSympy4D(*, rho: float, phi: float, pz: float)

class vector.VectorSympy4D(*, pt: float, phi: float, z: float)

class vector.VectorSympy4D(*, pt: float, phi: float, pz: float)

class vector.VectorSympy4D(*, x: float, py: float, theta: float)

class vector.VectorSympy4D(*, px: float, y: float, theta: float)

class vector.VectorSympy4D(*, px: float, py: float, theta: float)

class vector.VectorSympy4D(*, pt: float, phi: float, theta: float)

class vector.VectorSympy4D(*, x: float, py: float, eta: float)

class vector.VectorSympy4D(*, px: float, y: float, eta: float)

class vector.VectorSympy4D(*, px: float, py: float, eta: float)

class vector.VectorSympy4D(*, pt: float, phi: float, eta: float)

class vector.VectorSympy4D(*, x: float, y: float, z: float, t: float)

class vector.VectorSympy4D(*, x: float, y: float, pz: float, t: float)

class vector.VectorSympy4D(*, x: float, py: float, z: float, t: float)

class vector.VectorSympy4D(*, x: float, py: float, pz: float, t: float)

class vector.VectorSympy4D(*, px: float, y: float, z: float, t: float)

class vector.VectorSympy4D(*, px: float, y: float, pz: float, t: float)

class vector.VectorSympy4D(*, px: float, py: float, z: float, t: float)

class vector.VectorSympy4D(*, px: float, py: float, pz: float, t: float)

class vector.VectorSympy4D(*, rho: float, phi: float, z: float, t: float)

class vector.VectorSympy4D(*, rho: float, phi: float, pz: float, t: float)

class vector.VectorSympy4D(*, pt: float, phi: float, z: float, t: float)

class vector.VectorSympy4D(*, pt: float, phi: float, pz: float, t: float)

class vector.VectorSympy4D(*, x: float, y: float, theta: float, t: float)

class vector.VectorSympy4D(*, x: float, py: float, theta: float, t: float)

class vector.VectorSympy4D(*, px: float, y: float, theta: float, t: float)

class vector.VectorSympy4D(*, px: float, py: float, theta: float, t: float)

class vector.VectorSympy4D(*, rho: float, phi: float, theta: float, t: float)

class vector.VectorSympy4D(*, pt: float, phi: float, theta: float, t: float)

class vector.VectorSympy4D(*, x: float, y: float, eta: float, t: float)

class vector.VectorSympy4D(*, x: float, py: float, eta: float, t: float)

class vector.VectorSympy4D(*, px: float, y: float, eta: float, t: float)

class vector.VectorSympy4D(*, px: float, py: float, eta: float, t: float)

class vector.VectorSympy4D(*, rho: float, phi: float, eta: float, t: float)

class vector.VectorSympy4D(*, pt: float, phi: float, eta: float, t: float)

class vector.VectorSympy4D(*, x: float, y: float, z: float, tau: float)

class vector.VectorSympy4D(*, x: float, y: float, pz: float, tau: float)

class vector.VectorSympy4D(*, x: float, py: float, z: float, tau: float)

class vector.VectorSympy4D(*, x: float, py: float, pz: float, tau: float)

class vector.VectorSympy4D(*, px: float, y: float, z: float, tau: float)

class vector.VectorSympy4D(*, px: float, y: float, pz: float, tau: float)

class vector.VectorSympy4D(*, px: float, py: float, z: float, tau: float)

class vector.VectorSympy4D(*, px: float, py: float, pz: float, tau: float)

class vector.VectorSympy4D(*, rho: float, phi: float, z: float, tau: float)

class vector.VectorSympy4D(*, rho: float, phi: float, pz: float, tau: float)

class vector.VectorSympy4D(*, ptau: float, phi: float, z: float, tau: float)

class vector.VectorSympy4D(*, ptau: float, phi: float, pz: float, tau: float)

class vector.VectorSympy4D(*, x: float, y: float, theta: float, tau: float)

class vector.VectorSympy4D(*, x: float, py: float, theta: float, tau: float)

class vector.VectorSympy4D(*, px: float, y: float, theta: float, tau: float)

class vector.VectorSympy4D(*, px: float, py: float, theta: float, tau: float)

class vector.VectorSympy4D(*, rho: float, phi: float, theta: float, tau: float)

class vector.VectorSympy4D(*, ptau: float, phi: float, theta: float, tau: float)

class vector.VectorSympy4D(*, x: float, y: float, eta: float, tau: float)

class vector.VectorSympy4D(*, x: float, py: float, eta: float, tau: float)

class vector.VectorSympy4D(*, px: float, y: float, eta: float, tau: float)

class vector.VectorSympy4D(*, px: float, py: float, eta: float, tau: float)

class vector.VectorSympy4D(*, rho: float, phi: float, eta: float, tau: float)

class vector.VectorSympy4D(*, ptau: float, phi: float, eta: float, tau: float)

class vector.VectorSympy4D(*, x: float, y: float, z: float, E: float)

class vector.VectorSympy4D(*, x: float, y: float, pz: float, E: float)

class vector.VectorSympy4D(*, x: float, py: float, z: float, E: float)

class vector.VectorSympy4D(*, x: float, py: float, pz: float, E: float)

class vector.VectorSympy4D(*, px: float, y: float, z: float, E: float)

class vector.VectorSympy4D(*, px: float, y: float, pz: float, E: float)

class vector.VectorSympy4D(*, px: float, py: float, z: float, E: float)

class vector.VectorSympy4D(*, px: float, py: float, pz: float, E: float)

class vector.VectorSympy4D(*, rho: float, phi: float, z: float, E: float)

class vector.VectorSympy4D(*, rho: float, phi: float, pz: float, E: float)

class vector.VectorSympy4D(*, pE: float, phi: float, z: float, E: float)

class vector.VectorSympy4D(*, pE: float, phi: float, pz: float, E: float)

class vector.VectorSympy4D(*, x: float, y: float, theta: float, E: float)

class vector.VectorSympy4D(*, x: float, py: float, theta: float, E: float)

class vector.VectorSympy4D(*, px: float, y: float, theta: float, E: float)

class vector.VectorSympy4D(*, px: float, py: float, theta: float, E: float)

class vector.VectorSympy4D(*, rho: float, phi: float, theta: float, E: float)

class vector.VectorSympy4D(*, pE: float, phi: float, theta: float, E: float)

class vector.VectorSympy4D(*, x: float, y: float, eta: float, E: float)

class vector.VectorSympy4D(*, x: float, py: float, eta: float, E: float)

class vector.VectorSympy4D(*, px: float, y: float, eta: float, E: float)

class vector.VectorSympy4D(*, px: float, py: float, eta: float, E: float)

class vector.VectorSympy4D(*, rho: float, phi: float, eta: float, E: float)

class vector.VectorSympy4D(*, pE: float, phi: float, eta: float, E: float)

class vector.VectorSympy4D(*, x: float, y: float, z: float, e: float)

class vector.VectorSympy4D(*, x: float, y: float, pz: float, e: float)

class vector.VectorSympy4D(*, x: float, py: float, z: float, e: float)

class vector.VectorSympy4D(*, x: float, py: float, pz: float, e: float)

class vector.VectorSympy4D(*, px: float, y: float, z: float, e: float)

class vector.VectorSympy4D(*, px: float, y: float, pz: float, e: float)

class vector.VectorSympy4D(*, px: float, py: float, z: float, e: float)

class vector.VectorSympy4D(*, px: float, py: float, pz: float, e: float)

class vector.VectorSympy4D(*, rho: float, phi: float, z: float, e: float)

class vector.VectorSympy4D(*, rho: float, phi: float, pz: float, e: float)

class vector.VectorSympy4D(*, pe: float, phi: float, z: float, e: float)

class vector.VectorSympy4D(*, pe: float, phi: float, pz: float, e: float)

class vector.VectorSympy4D(*, x: float, y: float, theta: float, e: float)

class vector.VectorSympy4D(*, x: float, py: float, theta: float, e: float)

class vector.VectorSympy4D(*, px: float, y: float, theta: float, e: float)

class vector.VectorSympy4D(*, px: float, py: float, theta: float, e: float)

class vector.VectorSympy4D(*, rho: float, phi: float, theta: float, e: float)

class vector.VectorSympy4D(*, pe: float, phi: float, theta: float, e: float)

class vector.VectorSympy4D(*, x: float, y: float, eta: float, e: float)

class vector.VectorSympy4D(*, x: float, py: float, eta: float, e: float)

class vector.VectorSympy4D(*, px: float, y: float, eta: float, e: float)

class vector.VectorSympy4D(*, px: float, py: float, eta: float, e: float)

class vector.VectorSympy4D(*, rho: float, phi: float, eta: float, e: float)

class vector.VectorSympy4D(*, pe: float, phi: float, eta: float, e: float)

class vector.VectorSympy4D(*, x: float, y: float, z: float, energy: float)

class vector.VectorSympy4D(*, x: float, y: float, pz: float, energy: float)

class vector.VectorSympy4D(*, x: float, py: float, z: float, energy: float)

class vector.VectorSympy4D(*, x: float, py: float, pz: float, energy: float)

class vector.VectorSympy4D(*, px: float, y: float, z: float, energy: float)

class vector.VectorSympy4D(*, px: float, y: float, pz: float, energy: float)

class vector.VectorSympy4D(*, px: float, py: float, z: float, energy: float)

class vector.VectorSympy4D(*, px: float, py: float, pz: float, energy: float)

class vector.VectorSympy4D(*, rho: float, phi: float, z: float, energy: float)

class vector.VectorSympy4D(*, rho: float, phi: float, pz: float, energy: float)

class vector.VectorSympy4D(*, pt: float, phi: float, z: float, energy: float)

class vector.VectorSympy4D(*, pt: float, phi: float, pz: float, energy: float)

class vector.VectorSympy4D(*, x: float, y: float, theta: float, energy: float)

class vector.VectorSympy4D(*, x: float, py: float, theta: float, energy: float)

class vector.VectorSympy4D(*, px: float, y: float, theta: float, energy: float)

class vector.VectorSympy4D(*, px: float, py: float, theta: float, energy: float)

class vector.VectorSympy4D(*, rho: float, phi: float, theta: float, energy: float)

class vector.VectorSympy4D(*, pt: float, phi: float, theta: float, energy: float)

class vector.VectorSympy4D(*, x: float, y: float, eta: float, energy: float)

class vector.VectorSympy4D(*, x: float, py: float, eta: float, energy: float)

class vector.VectorSympy4D(*, px: float, y: float, eta: float, energy: float)

class vector.VectorSympy4D(*, px: float, py: float, eta: float, energy: float)

class vector.VectorSympy4D(*, rho: float, phi: float, eta: float, energy: float)

class vector.VectorSympy4D(*, pt: float, phi: float, eta: float, energy: float)

class vector.VectorSympy4D(*, x: float, y: float, z: float, M: float)

class vector.VectorSympy4D(*, x: float, y: float, pz: float, M: float)

class vector.VectorSympy4D(*, x: float, py: float, z: float, M: float)

class vector.VectorSympy4D(*, x: float, py: float, pz: float, M: float)

class vector.VectorSympy4D(*, px: float, y: float, z: float, M: float)

class vector.VectorSympy4D(*, px: float, y: float, pz: float, M: float)

class vector.VectorSympy4D(*, px: float, py: float, z: float, M: float)

class vector.VectorSympy4D(*, px: float, py: float, pz: float, M: float)

class vector.VectorSympy4D(*, rho: float, phi: float, z: float, M: float)

class vector.VectorSympy4D(*, rho: float, phi: float, pz: float, M: float)

class vector.VectorSympy4D(*, pM: float, phi: float, z: float, M: float)

class vector.VectorSympy4D(*, pM: float, phi: float, pz: float, M: float)

class vector.VectorSympy4D(*, x: float, y: float, theta: float, M: float)

class vector.VectorSympy4D(*, x: float, py: float, theta: float, M: float)

class vector.VectorSympy4D(*, px: float, y: float, theta: float, M: float)

class vector.VectorSympy4D(*, px: float, py: float, theta: float, M: float)

class vector.VectorSympy4D(*, rho: float, phi: float, theta: float, M: float)

class vector.VectorSympy4D(*, pM: float, phi: float, theta: float, M: float)

class vector.VectorSympy4D(*, x: float, y: float, eta: float, M: float)

class vector.VectorSympy4D(*, x: float, py: float, eta: float, M: float)

class vector.VectorSympy4D(*, px: float, y: float, eta: float, M: float)

class vector.VectorSympy4D(*, px: float, py: float, eta: float, M: float)

class vector.VectorSympy4D(*, rho: float, phi: float, eta: float, M: float)

class vector.VectorSympy4D(*, pM: float, phi: float, eta: float, M: float)

class vector.VectorSympy4D(*, x: float, y: float, z: float, m: float)

class vector.VectorSympy4D(*, x: float, y: float, pz: float, m: float)

class vector.VectorSympy4D(*, x: float, py: float, z: float, m: float)

class vector.VectorSympy4D(*, x: float, py: float, pz: float, m: float)

class vector.VectorSympy4D(*, px: float, y: float, z: float, m: float)

class vector.VectorSympy4D(*, px: float, y: float, pz: float, m: float)

class vector.VectorSympy4D(*, px: float, py: float, z: float, m: float)

class vector.VectorSympy4D(*, px: float, py: float, pz: float, m: float)

class vector.VectorSympy4D(*, rho: float, phi: float, z: float, m: float)

class vector.VectorSympy4D(*, rho: float, phi: float, pz: float, m: float)

class vector.VectorSympy4D(*, pm: float, phi: float, z: float, m: float)

class vector.VectorSympy4D(*, pm: float, phi: float, pz: float, m: float)

class vector.VectorSympy4D(*, x: float, y: float, theta: float, m: float)

class vector.VectorSympy4D(*, x: float, py: float, theta: float, m: float)

class vector.VectorSympy4D(*, px: float, y: float, theta: float, m: float)

class vector.VectorSympy4D(*, px: float, py: float, theta: float, m: float)

class vector.VectorSympy4D(*, rho: float, phi: float, theta: float, m: float)

class vector.VectorSympy4D(*, pm: float, phi: float, theta: float, m: float)

class vector.VectorSympy4D(*, x: float, y: float, eta: float, m: float)

class vector.VectorSympy4D(*, x: float, py: float, eta: float, m: float)

class vector.VectorSympy4D(*, px: float, y: float, eta: float, m: float)

class vector.VectorSympy4D(*, px: float, py: float, eta: float, m: float)

class vector.VectorSympy4D(*, rho: float, phi: float, eta: float, m: float)

class vector.VectorSympy4D(*, pm: float, phi: float, eta: float, m: float)

class vector.VectorSympy4D(*, x: float, y: float, z: float, mass: float)

class vector.VectorSympy4D(*, x: float, y: float, pz: float, mass: float)

class vector.VectorSympy4D(*, x: float, py: float, z: float, mass: float)

class vector.VectorSympy4D(*, x: float, py: float, pz: float, mass: float)

class vector.VectorSympy4D(*, px: float, y: float, z: float, mass: float)

class vector.VectorSympy4D(*, px: float, y: float, pz: float, mass: float)

class vector.VectorSympy4D(*, px: float, py: float, z: float, mass: float)

class vector.VectorSympy4D(*, px: float, py: float, pz: float, mass: float)

class vector.VectorSympy4D(*, rho: float, phi: float, z: float, mass: float)

class vector.VectorSympy4D(*, rho: float, phi: float, pz: float, mass: float)

class vector.VectorSympy4D(*, pt: float, phi: float, z: float, mass: float)

class vector.VectorSympy4D(*, pt: float, phi: float, pz: float, mass: float)

class vector.VectorSympy4D(*, x: float, y: float, theta: float, mass: float)

class vector.VectorSympy4D(*, x: float, py: float, theta: float, mass: float)

class vector.VectorSympy4D(*, px: float, y: float, theta: float, mass: float)

class vector.VectorSympy4D(*, px: float, py: float, theta: float, mass: float)

class vector.VectorSympy4D(*, rho: float, phi: float, theta: float, mass: float)

class vector.VectorSympy4D(*, pt: float, phi: float, theta: float, mass: float)

class vector.VectorSympy4D(*, x: float, y: float, eta: float, mass: float)

class vector.VectorSympy4D(*, x: float, py: float, eta: float, mass: float)

class vector.VectorSympy4D(*, px: float, y: float, eta: float, mass: float)

class vector.VectorSympy4D(*, px: float, py: float, eta: float, mass: float)

class vector.VectorSympy4D(*, rho: float, phi: float, eta: float, mass: float)

class vector.VectorSympy4D(*, pt: float, phi: float, eta: float, mass: float)

class vector.VectorSympy4D(__azimuthal: Azimuthal)

class vector.VectorSympy4D(__azimuthal: Azimuthal, __longitudinal: Longitudinal)

class vector.VectorSympy4D(__azimuthal: Azimuthal, __longitudinal: Longitudinal, __temporal: Temporal)

Four dimensional vector class for the SymPy backend.

Examples

>>> import vector; import sympy
>>> vec = vector.VectorSympy4D(x=sympy.Symbol("x"), y=sympy.Symbol("y"), z=sympy.Symbol("z"), t=sympy.Symbol("t"))
>>> vec.x, vec.y, vec.z, vec.t
(x, y, z, t)
>>> vec = vector.VectorSympy4D(rho=sympy.Symbol("rho"), phi=sympy.Symbol("phi"), eta=sympy.Symbol("eta"), tau=sympy.Symbol("tau"))
>>> vec.rho, vec.phi, vec.eta, vec.tau
(rho, phi, eta, tau)

For four dimensional momentum SymPy vectors, see vector.backends.sympy.MomentumSympy4D.

class vector.MomentumSympy4D(*, x: float, y: float)

class vector.MomentumSympy4D(*, rho: float, phi: float)

class vector.MomentumSympy4D(*, x: float, y: float, z: float)

class vector.MomentumSympy4D(*, x: float, y: float, eta: float)

class vector.MomentumSympy4D(*, x: float, y: float, theta: float)

class vector.MomentumSympy4D(*, rho: float, phi: float, z: float)

class vector.MomentumSympy4D(*, rho: float, phi: float, eta: float)

class vector.MomentumSympy4D(*, rho: float, phi: float, theta: float)

class vector.MomentumSympy4D(*, px: float, py: float)

class vector.MomentumSympy4D(*, x: float, py: float)

class vector.MomentumSympy4D(*, px: float, y: float)

class vector.MomentumSympy4D(*, pt: float, phi: float)

class vector.MomentumSympy4D(*, x: float, y: float, pz: float)

class vector.MomentumSympy4D(*, x: float, py: float, z: float)

class vector.MomentumSympy4D(*, x: float, py: float, pz: float)

class vector.MomentumSympy4D(*, px: float, y: float, z: float)

class vector.MomentumSympy4D(*, px: float, y: float, pz: float)

class vector.MomentumSympy4D(*, px: float, py: float, z: float)

class vector.MomentumSympy4D(*, px: float, py: float, pz: float)

class vector.MomentumSympy4D(*, rho: float, phi: float, pz: float)

class vector.MomentumSympy4D(*, pt: float, phi: float, z: float)

class vector.MomentumSympy4D(*, pt: float, phi: float, pz: float)

class vector.MomentumSympy4D(*, x: float, py: float, theta: float)

class vector.MomentumSympy4D(*, px: float, y: float, theta: float)

class vector.MomentumSympy4D(*, px: float, py: float, theta: float)

class vector.MomentumSympy4D(*, pt: float, phi: float, theta: float)

class vector.MomentumSympy4D(*, x: float, py: float, eta: float)

class vector.MomentumSympy4D(*, px: float, y: float, eta: float)

class vector.MomentumSympy4D(*, px: float, py: float, eta: float)

class vector.MomentumSympy4D(*, pt: float, phi: float, eta: float)

class vector.MomentumSympy4D(*, x: float, y: float, z: float, t: float)

class vector.MomentumSympy4D(*, x: float, y: float, pz: float, t: float)

class vector.MomentumSympy4D(*, x: float, py: float, z: float, t: float)

class vector.MomentumSympy4D(*, x: float, py: float, pz: float, t: float)

class vector.MomentumSympy4D(*, px: float, y: float, z: float, t: float)

class vector.MomentumSympy4D(*, px: float, y: float, pz: float, t: float)

class vector.MomentumSympy4D(*, px: float, py: float, z: float, t: float)

class vector.MomentumSympy4D(*, px: float, py: float, pz: float, t: float)

class vector.MomentumSympy4D(*, rho: float, phi: float, z: float, t: float)

class vector.MomentumSympy4D(*, rho: float, phi: float, pz: float, t: float)

class vector.MomentumSympy4D(*, pt: float, phi: float, z: float, t: float)

class vector.MomentumSympy4D(*, pt: float, phi: float, pz: float, t: float)

class vector.MomentumSympy4D(*, x: float, y: float, theta: float, t: float)

class vector.MomentumSympy4D(*, x: float, py: float, theta: float, t: float)

class vector.MomentumSympy4D(*, px: float, y: float, theta: float, t: float)

class vector.MomentumSympy4D(*, px: float, py: float, theta: float, t: float)

class vector.MomentumSympy4D(*, rho: float, phi: float, theta: float, t: float)

class vector.MomentumSympy4D(*, pt: float, phi: float, theta: float, t: float)

class vector.MomentumSympy4D(*, x: float, y: float, eta: float, t: float)

class vector.MomentumSympy4D(*, x: float, py: float, eta: float, t: float)

class vector.MomentumSympy4D(*, px: float, y: float, eta: float, t: float)

class vector.MomentumSympy4D(*, px: float, py: float, eta: float, t: float)

class vector.MomentumSympy4D(*, rho: float, phi: float, eta: float, t: float)

class vector.MomentumSympy4D(*, pt: float, phi: float, eta: float, t: float)

class vector.MomentumSympy4D(*, x: float, y: float, z: float, tau: float)

class vector.MomentumSympy4D(*, x: float, y: float, pz: float, tau: float)

class vector.MomentumSympy4D(*, x: float, py: float, z: float, tau: float)

class vector.MomentumSympy4D(*, x: float, py: float, pz: float, tau: float)

class vector.MomentumSympy4D(*, px: float, y: float, z: float, tau: float)

class vector.MomentumSympy4D(*, px: float, y: float, pz: float, tau: float)

class vector.MomentumSympy4D(*, px: float, py: float, z: float, tau: float)

class vector.MomentumSympy4D(*, px: float, py: float, pz: float, tau: float)

class vector.MomentumSympy4D(*, rho: float, phi: float, z: float, tau: float)

class vector.MomentumSympy4D(*, rho: float, phi: float, pz: float, tau: float)

class vector.MomentumSympy4D(*, ptau: float, phi: float, z: float, tau: float)

class vector.MomentumSympy4D(*, ptau: float, phi: float, pz: float, tau: float)

class vector.MomentumSympy4D(*, x: float, y: float, theta: float, tau: float)

class vector.MomentumSympy4D(*, x: float, py: float, theta: float, tau: float)

class vector.MomentumSympy4D(*, px: float, y: float, theta: float, tau: float)

class vector.MomentumSympy4D(*, px: float, py: float, theta: float, tau: float)

class vector.MomentumSympy4D(*, rho: float, phi: float, theta: float, tau: float)

class vector.MomentumSympy4D(*, ptau: float, phi: float, theta: float, tau: float)

class vector.MomentumSympy4D(*, x: float, y: float, eta: float, tau: float)

class vector.MomentumSympy4D(*, x: float, py: float, eta: float, tau: float)

class vector.MomentumSympy4D(*, px: float, y: float, eta: float, tau: float)

class vector.MomentumSympy4D(*, px: float, py: float, eta: float, tau: float)

class vector.MomentumSympy4D(*, rho: float, phi: float, eta: float, tau: float)

class vector.MomentumSympy4D(*, ptau: float, phi: float, eta: float, tau: float)

class vector.MomentumSympy4D(*, x: float, y: float, z: float, E: float)

class vector.MomentumSympy4D(*, x: float, y: float, pz: float, E: float)

class vector.MomentumSympy4D(*, x: float, py: float, z: float, E: float)

class vector.MomentumSympy4D(*, x: float, py: float, pz: float, E: float)

class vector.MomentumSympy4D(*, px: float, y: float, z: float, E: float)

class vector.MomentumSympy4D(*, px: float, y: float, pz: float, E: float)

class vector.MomentumSympy4D(*, px: float, py: float, z: float, E: float)

class vector.MomentumSympy4D(*, px: float, py: float, pz: float, E: float)

class vector.MomentumSympy4D(*, rho: float, phi: float, z: float, E: float)

class vector.MomentumSympy4D(*, rho: float, phi: float, pz: float, E: float)

class vector.MomentumSympy4D(*, pE: float, phi: float, z: float, E: float)

class vector.MomentumSympy4D(*, pE: float, phi: float, pz: float, E: float)

class vector.MomentumSympy4D(*, x: float, y: float, theta: float, E: float)

class vector.MomentumSympy4D(*, x: float, py: float, theta: float, E: float)

class vector.MomentumSympy4D(*, px: float, y: float, theta: float, E: float)

class vector.MomentumSympy4D(*, px: float, py: float, theta: float, E: float)

class vector.MomentumSympy4D(*, rho: float, phi: float, theta: float, E: float)

class vector.MomentumSympy4D(*, pE: float, phi: float, theta: float, E: float)

class vector.MomentumSympy4D(*, x: float, y: float, eta: float, E: float)

class vector.MomentumSympy4D(*, x: float, py: float, eta: float, E: float)

class vector.MomentumSympy4D(*, px: float, y: float, eta: float, E: float)

class vector.MomentumSympy4D(*, px: float, py: float, eta: float, E: float)

class vector.MomentumSympy4D(*, rho: float, phi: float, eta: float, E: float)

class vector.MomentumSympy4D(*, pE: float, phi: float, eta: float, E: float)

class vector.MomentumSympy4D(*, x: float, y: float, z: float, e: float)

class vector.MomentumSympy4D(*, x: float, y: float, pz: float, e: float)

class vector.MomentumSympy4D(*, x: float, py: float, z: float, e: float)

class vector.MomentumSympy4D(*, x: float, py: float, pz: float, e: float)

class vector.MomentumSympy4D(*, px: float, y: float, z: float, e: float)

class vector.MomentumSympy4D(*, px: float, y: float, pz: float, e: float)

class vector.MomentumSympy4D(*, px: float, py: float, z: float, e: float)

class vector.MomentumSympy4D(*, px: float, py: float, pz: float, e: float)

class vector.MomentumSympy4D(*, rho: float, phi: float, z: float, e: float)

class vector.MomentumSympy4D(*, rho: float, phi: float, pz: float, e: float)

class vector.MomentumSympy4D(*, pe: float, phi: float, z: float, e: float)

class vector.MomentumSympy4D(*, pe: float, phi: float, pz: float, e: float)

class vector.MomentumSympy4D(*, x: float, y: float, theta: float, e: float)

class vector.MomentumSympy4D(*, x: float, py: float, theta: float, e: float)

class vector.MomentumSympy4D(*, px: float, y: float, theta: float, e: float)

class vector.MomentumSympy4D(*, px: float, py: float, theta: float, e: float)

class vector.MomentumSympy4D(*, rho: float, phi: float, theta: float, e: float)

class vector.MomentumSympy4D(*, pe: float, phi: float, theta: float, e: float)

class vector.MomentumSympy4D(*, x: float, y: float, eta: float, e: float)

class vector.MomentumSympy4D(*, x: float, py: float, eta: float, e: float)

class vector.MomentumSympy4D(*, px: float, y: float, eta: float, e: float)

class vector.MomentumSympy4D(*, px: float, py: float, eta: float, e: float)

class vector.MomentumSympy4D(*, rho: float, phi: float, eta: float, e: float)

class vector.MomentumSympy4D(*, pe: float, phi: float, eta: float, e: float)

class vector.MomentumSympy4D(*, x: float, y: float, z: float, energy: float)

class vector.MomentumSympy4D(*, x: float, y: float, pz: float, energy: float)

class vector.MomentumSympy4D(*, x: float, py: float, z: float, energy: float)

class vector.MomentumSympy4D(*, x: float, py: float, pz: float, energy: float)

class vector.MomentumSympy4D(*, px: float, y: float, z: float, energy: float)

class vector.MomentumSympy4D(*, px: float, y: float, pz: float, energy: float)

class vector.MomentumSympy4D(*, px: float, py: float, z: float, energy: float)

class vector.MomentumSympy4D(*, px: float, py: float, pz: float, energy: float)

class vector.MomentumSympy4D(*, rho: float, phi: float, z: float, energy: float)

class vector.MomentumSympy4D(*, rho: float, phi: float, pz: float, energy: float)

class vector.MomentumSympy4D(*, pt: float, phi: float, z: float, energy: float)

class vector.MomentumSympy4D(*, pt: float, phi: float, pz: float, energy: float)

class vector.MomentumSympy4D(*, x: float, y: float, theta: float, energy: float)

class vector.MomentumSympy4D(*, x: float, py: float, theta: float, energy: float)

class vector.MomentumSympy4D(*, px: float, y: float, theta: float, energy: float)

class vector.MomentumSympy4D(*, px: float, py: float, theta: float, energy: float)

class vector.MomentumSympy4D(*, rho: float, phi: float, theta: float, energy: float)

class vector.MomentumSympy4D(*, pt: float, phi: float, theta: float, energy: float)

class vector.MomentumSympy4D(*, x: float, y: float, eta: float, energy: float)

class vector.MomentumSympy4D(*, x: float, py: float, eta: float, energy: float)

class vector.MomentumSympy4D(*, px: float, y: float, eta: float, energy: float)

class vector.MomentumSympy4D(*, px: float, py: float, eta: float, energy: float)

class vector.MomentumSympy4D(*, rho: float, phi: float, eta: float, energy: float)

class vector.MomentumSympy4D(*, pt: float, phi: float, eta: float, energy: float)

class vector.MomentumSympy4D(*, x: float, y: float, z: float, M: float)

class vector.MomentumSympy4D(*, x: float, y: float, pz: float, M: float)

class vector.MomentumSympy4D(*, x: float, py: float, z: float, M: float)

class vector.MomentumSympy4D(*, x: float, py: float, pz: float, M: float)

class vector.MomentumSympy4D(*, px: float, y: float, z: float, M: float)

class vector.MomentumSympy4D(*, px: float, y: float, pz: float, M: float)

class vector.MomentumSympy4D(*, px: float, py: float, z: float, M: float)

class vector.MomentumSympy4D(*, px: float, py: float, pz: float, M: float)

class vector.MomentumSympy4D(*, rho: float, phi: float, z: float, M: float)

class vector.MomentumSympy4D(*, rho: float, phi: float, pz: float, M: float)

class vector.MomentumSympy4D(*, pM: float, phi: float, z: float, M: float)

class vector.MomentumSympy4D(*, pM: float, phi: float, pz: float, M: float)

class vector.MomentumSympy4D(*, x: float, y: float, theta: float, M: float)

class vector.MomentumSympy4D(*, x: float, py: float, theta: float, M: float)

class vector.MomentumSympy4D(*, px: float, y: float, theta: float, M: float)

class vector.MomentumSympy4D(*, px: float, py: float, theta: float, M: float)

class vector.MomentumSympy4D(*, rho: float, phi: float, theta: float, M: float)

class vector.MomentumSympy4D(*, pM: float, phi: float, theta: float, M: float)

class vector.MomentumSympy4D(*, x: float, y: float, eta: float, M: float)

class vector.MomentumSympy4D(*, x: float, py: float, eta: float, M: float)

class vector.MomentumSympy4D(*, px: float, y: float, eta: float, M: float)

class vector.MomentumSympy4D(*, px: float, py: float, eta: float, M: float)

class vector.MomentumSympy4D(*, rho: float, phi: float, eta: float, M: float)

class vector.MomentumSympy4D(*, pM: float, phi: float, eta: float, M: float)

class vector.MomentumSympy4D(*, x: float, y: float, z: float, m: float)

class vector.MomentumSympy4D(*, x: float, y: float, pz: float, m: float)

class vector.MomentumSympy4D(*, x: float, py: float, z: float, m: float)

class vector.MomentumSympy4D(*, x: float, py: float, pz: float, m: float)

class vector.MomentumSympy4D(*, px: float, y: float, z: float, m: float)

class vector.MomentumSympy4D(*, px: float, y: float, pz: float, m: float)

class vector.MomentumSympy4D(*, px: float, py: float, z: float, m: float)

class vector.MomentumSympy4D(*, px: float, py: float, pz: float, m: float)

class vector.MomentumSympy4D(*, rho: float, phi: float, z: float, m: float)

class vector.MomentumSympy4D(*, rho: float, phi: float, pz: float, m: float)

class vector.MomentumSympy4D(*, pm: float, phi: float, z: float, m: float)

class vector.MomentumSympy4D(*, pm: float, phi: float, pz: float, m: float)

class vector.MomentumSympy4D(*, x: float, y: float, theta: float, m: float)

class vector.MomentumSympy4D(*, x: float, py: float, theta: float, m: float)

class vector.MomentumSympy4D(*, px: float, y: float, theta: float, m: float)

class vector.MomentumSympy4D(*, px: float, py: float, theta: float, m: float)

class vector.MomentumSympy4D(*, rho: float, phi: float, theta: float, m: float)

class vector.MomentumSympy4D(*, pm: float, phi: float, theta: float, m: float)

class vector.MomentumSympy4D(*, x: float, y: float, eta: float, m: float)

class vector.MomentumSympy4D(*, x: float, py: float, eta: float, m: float)

class vector.MomentumSympy4D(*, px: float, y: float, eta: float, m: float)

class vector.MomentumSympy4D(*, px: float, py: float, eta: float, m: float)

class vector.MomentumSympy4D(*, rho: float, phi: float, eta: float, m: float)

class vector.MomentumSympy4D(*, pm: float, phi: float, eta: float, m: float)

class vector.MomentumSympy4D(*, x: float, y: float, z: float, mass: float)

class vector.MomentumSympy4D(*, x: float, y: float, pz: float, mass: float)

class vector.MomentumSympy4D(*, x: float, py: float, z: float, mass: float)

class vector.MomentumSympy4D(*, x: float, py: float, pz: float, mass: float)

class vector.MomentumSympy4D(*, px: float, y: float, z: float, mass: float)

class vector.MomentumSympy4D(*, px: float, y: float, pz: float, mass: float)

class vector.MomentumSympy4D(*, px: float, py: float, z: float, mass: float)

class vector.MomentumSympy4D(*, px: float, py: float, pz: float, mass: float)

class vector.MomentumSympy4D(*, rho: float, phi: float, z: float, mass: float)

class vector.MomentumSympy4D(*, rho: float, phi: float, pz: float, mass: float)

class vector.MomentumSympy4D(*, pt: float, phi: float, z: float, mass: float)

class vector.MomentumSympy4D(*, pt: float, phi: float, pz: float, mass: float)

class vector.MomentumSympy4D(*, x: float, y: float, theta: float, mass: float)

class vector.MomentumSympy4D(*, x: float, py: float, theta: float, mass: float)

class vector.MomentumSympy4D(*, px: float, y: float, theta: float, mass: float)

class vector.MomentumSympy4D(*, px: float, py: float, theta: float, mass: float)

class vector.MomentumSympy4D(*, rho: float, phi: float, theta: float, mass: float)

class vector.MomentumSympy4D(*, pt: float, phi: float, theta: float, mass: float)

class vector.MomentumSympy4D(*, x: float, y: float, eta: float, mass: float)

class vector.MomentumSympy4D(*, x: float, py: float, eta: float, mass: float)

class vector.MomentumSympy4D(*, px: float, y: float, eta: float, mass: float)

class vector.MomentumSympy4D(*, px: float, py: float, eta: float, mass: float)

class vector.MomentumSympy4D(*, rho: float, phi: float, eta: float, mass: float)

class vector.MomentumSympy4D(*, pt: float, phi: float, eta: float, mass: float)

class vector.MomentumSympy4D(__azimuthal: Azimuthal)

class vector.MomentumSympy4D(__azimuthal: Azimuthal, __longitudinal: Longitudinal)

class vector.MomentumSympy4D(__azimuthal: Azimuthal, __longitudinal: Longitudinal, __temporal: Temporal)

Four dimensional momentum vector class for the SymPy backend.

Examples

>>> import vector; import sympy
>>> vec = vector.MomentumSympy4D(px=sympy.Symbol("px"), py=sympy.Symbol("py"), pz=sympy.Symbol("pz"), t=sympy.Symbol("t"))
>>> vec.px, vec.py, vec.pz, vec.t
(px, py, pz, t)
>>> vec = vector.MomentumSympy4D(pt=sympy.Symbol("pt"), phi=sympy.Symbol("phi"), pz=sympy.Symbol("pz"), M=sympy.Symbol("M"))
>>> vec.pt, vec.phi, vec.pz, vec.M
(pt, phi, pz, M)

For four dimensional SymPy vectors, see vector.backends.sympy.VectorSympy4D.