# 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),

```python
>>> 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),

```python
>>> 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(, pt: float, phi: float, z: float, tau: float)

### *class* vector.VectorSympy2D(, pt: 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(, pt: 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(, pt: 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(, pt: float, phi: float, z: float, E: float)

### *class* vector.VectorSympy2D(, pt: 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(, pt: 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(, pt: 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(, pt: float, phi: float, z: float, e: float)

### *class* vector.VectorSympy2D(, pt: 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(, pt: 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(, pt: 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(, pt: float, phi: float, z: float, M: float)

### *class* vector.VectorSympy2D(, pt: 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(, pt: 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(, pt: 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(, pt: float, phi: float, z: float, m: float)

### *class* vector.VectorSympy2D(, pt: 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(, pt: 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(, pt: 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

```pycon
>>> 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`](#vector.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(, pt: float, phi: float, z: float, tau: float)

### *class* vector.MomentumSympy2D(, pt: 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(, pt: 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(, pt: 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(, pt: float, phi: float, z: float, E: float)

### *class* vector.MomentumSympy2D(, pt: 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(, pt: 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(, pt: 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(, pt: float, phi: float, z: float, e: float)

### *class* vector.MomentumSympy2D(, pt: 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(, pt: 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(, pt: 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(, pt: float, phi: float, z: float, M: float)

### *class* vector.MomentumSympy2D(, pt: 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(, pt: 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(, pt: 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(, pt: float, phi: float, z: float, m: float)

### *class* vector.MomentumSympy2D(, pt: 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(, pt: 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(, pt: 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

```pycon
>>> 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(, pt: float, phi: float, z: float, tau: float)

### *class* vector.VectorSympy3D(, pt: 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(, pt: 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(, pt: 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(, pt: float, phi: float, z: float, E: float)

### *class* vector.VectorSympy3D(, pt: 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(, pt: 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(, pt: 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(, pt: float, phi: float, z: float, e: float)

### *class* vector.VectorSympy3D(, pt: 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(, pt: 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(, pt: 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(, pt: float, phi: float, z: float, M: float)

### *class* vector.VectorSympy3D(, pt: 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(, pt: 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(, pt: 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(, pt: float, phi: float, z: float, m: float)

### *class* vector.VectorSympy3D(, pt: 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(, pt: 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(, pt: 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

```pycon
>>> 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(, pt: float, phi: float, z: float, tau: float)

### *class* vector.MomentumSympy3D(, pt: 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(, pt: 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(, pt: 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(, pt: float, phi: float, z: float, E: float)

### *class* vector.MomentumSympy3D(, pt: 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(, pt: 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(, pt: 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(, pt: float, phi: float, z: float, e: float)

### *class* vector.MomentumSympy3D(, pt: 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(, pt: 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(, pt: 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(, pt: float, phi: float, z: float, M: float)

### *class* vector.MomentumSympy3D(, pt: 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(, pt: 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(, pt: 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(, pt: float, phi: float, z: float, m: float)

### *class* vector.MomentumSympy3D(, pt: 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(, pt: 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(, pt: 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

```pycon
>>> 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`](#vector.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(, pt: float, phi: float, z: float, tau: float)

### *class* vector.VectorSympy4D(, pt: 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(, pt: 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(, pt: 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(, pt: float, phi: float, z: float, E: float)

### *class* vector.VectorSympy4D(, pt: 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(, pt: 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(, pt: 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(, pt: float, phi: float, z: float, e: float)

### *class* vector.VectorSympy4D(, pt: 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(, pt: 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(, pt: 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(, pt: float, phi: float, z: float, M: float)

### *class* vector.VectorSympy4D(, pt: 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(, pt: 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(, pt: 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(, pt: float, phi: float, z: float, m: float)

### *class* vector.VectorSympy4D(, pt: 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(, pt: 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(, pt: 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

```pycon
>>> 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`](#vector.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(, pt: float, phi: float, z: float, tau: float)

### *class* vector.MomentumSympy4D(, pt: 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(, pt: 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(, pt: 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(, pt: float, phi: float, z: float, E: float)

### *class* vector.MomentumSympy4D(, pt: 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(, pt: 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(, pt: 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(, pt: float, phi: float, z: float, e: float)

### *class* vector.MomentumSympy4D(, pt: 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(, pt: 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(, pt: 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(, pt: float, phi: float, z: float, M: float)

### *class* vector.MomentumSympy4D(, pt: 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(, pt: 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(, pt: 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(, pt: float, phi: float, z: float, m: float)

### *class* vector.MomentumSympy4D(, pt: 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(, pt: 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(, pt: 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

```pycon
>>> 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`](#vector.VectorSympy4D).