Interface for 4D vectors

Contents

Interface for 4D vectors#

4D vectors of all backends have the following attributes, properties, and methods.

For the momentum synonyms, see Interface for 4D momentum.

class vector._methods.VectorProtocolLorentz#
property temporal: Temporal#

Container of temporal coordinates, for use in dispatching to compute functions or to identify coordinate system with isinstance.

property t: Any#

The Cartesian \(t\) (time) coordinate of the vector or every vector in the array.

If \(t\) is derived from \(\tau\), it is not allowed to be NaN.

t = sqrt(max(copysign(tau**2, tau) + mag**2, 0))
property t2: Any#

The Cartesian \(t\) (time) coordinate squared of the vector or every vector in the array.

If \(t^2\) is derived from \(\tau\), it is not allowed to be negative.

t2 = max(copysign(tau**2, tau) + mag**2, 0)
property tau: Any#

The Lorentz magnitude \(\tau\) (proper time) of the vector or every vector in the array.

If \(\tau\) is derived from \(t\), spacelike vectors are represented by negative proper times.

tau = copysign(sqrt(abs(t**2 - mag**2)), t**2 - mag**2)
property tau2: Any#

The Lorentz magnitude \(\tau\) (proper time) squared of the vector or every vector in the array.

tau2 = t**2 - mag**2
property beta: Any#

The speed(s) of the Lorentz vector or array of vectors, in which lightlike vectors have beta == 1.

property gamma: Any#

The time dilation/length contraction factor(s) of the Lorentz vector or array of vectors: \(t/\tau\).

property rapidity: Any#

The rapidity relative to the longitudinal axis of the Lorentz vector or array of vectors.

0.5 * log((t + z) / (t - z))
deltaRapidityPhi(other: VectorProtocolLorentz) → Any#

Sum in quadrature of vector._methods.VectorProtocolPlanar.deltaphi() and the difference in vector._methods.VectorProtocolLorentz.rapidity of the two vectors:

\[\Delta R_{\mbox{rapidity}} = \sqrt{\Delta\phi^2 + \Delta \mbox{rapidity}^2}\]

deltaRapidityPhi2(other: VectorProtocolLorentz) → Any#

Square of the sum in quadrature of vector._methods.VectorProtocolPlanar.deltaphi() and the difference in vector._methods.VectorProtocolLorentz.rapidity of the two vectors:

\[\Delta R_{\mbox{rapidity}} = \Delta\phi^2 + \Delta \mbox{rapidity}^2\]

scale4D(factor: Any) → SameVectorType#

Same as scale.

property neg4D: SameVectorType#

Same as multiplying by -1.

boost_p4(p4: VectorProtocolLorentz) → SameVectorType#

Boosts the vector or array of vectors in a direction and magnitude given by the 4D vector or array of vectors p4.

This function is equivalent to but more numerically stable than

boost_beta3(p4.to_beta3())

where vector._methods.VectorProtocolLorentz.to_beta3() converts a 4D Lorentz vector into a 3D velocity (in which lightlike velocities have mag == 1).

Note that v.boost_p4(v) does not boost into the center-of-mass (CM) frame of v; it boosts away from its CM frame. Neither does v.boost_p4(-v), since that negates the time component of v as well.

To boost to the center-of-mass frame of a vector v, use vector._methods.VectorProtocolLorentz.boostCM_of_p4(). For instance, v.boostCM_of_p4(v) is guaranteed to have spatial components close to zero and a temporal component close to v.tau.

boost_beta3(beta3: VectorProtocolSpatial) → SameVectorType#

Boosts the vector or array of vectors in a direction and magnitude given by the 3D velocity or array of velocity vectors beta3.

Note that v.boost_beta3(v.to_beta3()) does not boost into the center-of-mass (CM) frame of v; it boosts away from its CM frame. Neither does v.boost_beta3((-v).to_beta3()), since that negates the time component of v as well. On the other hand, v.boost_beta3(-(v.to_beta3())) would boost to the center-of-mass frame.

However, there’s a function for that: vector._methods.VectorProtocolLorentz.boostCM_of_beta3() is explicit about boosting to a center-of-mass (CM) frame and it handles the negative sign for you: v.boostCM_of_beta3(v.to_beta3()) is guaranteed to have spatial components close to zero and a temporal component close to v.tau.

boost(booster: VectorProtocolSpatial | VectorProtocolLorentz) → SameVectorType#

Boosts the vector or array of vectors using the 3D or 4D booster.

If booster is 3D, it is interpreted as a velocity (in which lightlike velocities have mag == 1) and vector._methods.VectorProtocolLorentz.boost_beta3() is called.

If booster is 4D, it is interpreted as a Lorentz vector and vector._methods.VectorProtocolLorentz.boost_p4() is called.

Note that v.boost(v) does not boost into the center-of-mass (CM) frame of v; it boosts away from its CM frame. Neither does v.boost(-v), since that negates the time component of v as well.

To boost to the center-of-mass frame of a vector v, use vector._methods.VectorProtocolLorentz.boostCM_of(). For instance, v.boostCM_of(v) is guaranteed to have spatial components close to zero and a temporal component close to v.tau.

boostCM_of_p4(p4: VectorProtocolLorentz) → SameVectorType#

Boosts the vector or array of vectors to the center-of-mass (CM) frame of the 4D vector or array of vectors p4.

This function is equivalent to but more numerically stable than

boostCM_of_beta3(p4.to_beta3())

Note that v.boostCM_of_p4(v) is guaranteed to have spatial components close to zero and a temporal component close to v.tau.

boostCM_of_beta3(beta3: VectorProtocolSpatial) → SameVectorType#

Boosts the vector or array of vectors to the center-of-mass (CM) frame of the 3D velocity or array of velocity vectors beta3.

Note that v.boostCM_of_beta3(v.to_beta3()) is guaranteed to have spatial components close to zero and a temporal component close to v.tau.

boostCM_of(booster: VectorProtocolSpatial | VectorProtocolLorentz) → SameVectorType#

Boosts the vector or array of vectors to the center-of-mass (CM) frame of the 3D or 4D booster.

If booster is 3D, it is interpreted as a velocity (in which lightlike velocities have mag == 1) and vector._methods.VectorProtocolLorentz.boostCM_of_beta3() is called.

If booster is 4D, it is interpreted as a Lorentz vector and vector._methods.VectorProtocolLorentz.boostCM_of_p4() is called.

Note that v.boostCM_of(v) is guaranteed to have spatial components close to zero and a temporal component close to v.tau.

boostX(beta: Any | None = None, gamma: Any | None = None) → SameVectorType#

Boosts the vector or array of vectors in the \(x\) direction by a speed beta (in which lightlike boosts have beta == 1) or time dilation/length contraction factor gamma.

Either beta xor gamma must be specified, not both or neither.

If beta or gamma is negative, it is taken as a boost in the \(-x\) direction.

boostY(beta: Any | None = None, gamma: Any | None = None) → SameVectorType#

Boosts the vector or array of vectors in the \(y\) direction by a speed beta (in which lightlike boosts have beta == 1) or time dilation/length contraction factor gamma.

Either beta xor gamma must be specified, not both or neither.

If beta or gamma is negative, it is taken as a boost in the \(-y\) direction.

boostZ(beta: Any | None = None, gamma: Any | None = None) → SameVectorType#

Boosts the vector or array of vectors in the \(z\) direction by a speed beta (in which lightlike boosts have beta == 1) or time dilation/length contraction factor gamma.

Either beta xor gamma must be specified, not both or neither.

If beta or gamma is negative, it is taken as a boost in the \(-z\) direction.

transform4D(obj: TransformProtocol4D) → SameVectorType#

Arbitrarily transforms the vector(s) by

obj["xx"] obj["xy"] obj["xz"] obj["xt"]
obj["yx"] obj["yy"] obj["yz"] obj["yt"]
obj["zx"] obj["zy"] obj["zz"] obj["zt"]
obj["tx"] obj["ty"] obj["tz"] obj["tt"]

There is no restriction on the type of obj; it just has to provide those components (which can be arrays if the vectors are in an array).

to_beta3() → VectorProtocolSpatial#

Converts the 4D Lorentz vector or array of vectors into a 3D velocity vector or array of vectors, in which lightlike velocities have mag == 1.

is_timelike(tolerance: Any = 0) → Any#

Returns True if the vector or a vector in the array is pointing in a timelike direction, t**2 > mag**2, False otherwise.

The tolerance is in units of t and mag. Note that

If you want to use these methods to divide space-time into non-overlapping regions (the light-cone), use the same tolerance for each.

is_spacelike(tolerance: Any = 0) → Any#

Returns True if the vector or a vector in the array is pointing in a spacelike direction, t**2 < mag**2, False otherwise.

The tolerance is in units of t and mag. Note that

If you want to use these methods to divide space-time into non-overlapping regions (the light-cone), use the same tolerance for each.

is_lightlike(tolerance: Any = 1e-05) → Any#

Returns True if the vector or a vector in the array is pointing in a lightlike direction, t**2 == mag**2, False otherwise.

The tolerance is in units of t and mag. Note that

If you want to use these methods to divide space-time into non-overlapping regions (the light-cone), use the same tolerance for each.

add(other: VectorProtocol) → VectorProtocol#

Sum of self and other.

This method is equivalent to the + operator.

property azimuthal: Azimuthal#

Container of azimuthal coordinates, for use in dispatching to compute functions or to identify coordinate system with isinstance.

property costheta: Any#

The \(\cos\theta\) coordinate of the vector or every vector in the array (has the same sign as \(z\)).

property cottheta: Any#

The \(\cot\theta\) coordinate of the vector or every vector in the array (has the same sign as \(z\)).

cross(other: VectorProtocolSpatial) → VectorProtocolSpatial#

The 3D cross-product of self with other.

Even if self or other is 4D, the resulting vector(s) is/are 3D.

deltaR(other: VectorProtocolSpatial | VectorProtocolLorentz) → Any#

Sum in quadrature of vector._methods.VectorProtocolPlanar.deltaphi() and vector._methods.VectorProtocolSpatial.deltaeta():

\[\Delta R = \sqrt{\Delta\phi^2 + \Delta\eta^2}\]

deltaR2(other: VectorProtocolSpatial | VectorProtocolLorentz) → Any#

Square of the sum in quadrature of vector._methods.VectorProtocolPlanar.deltaphi() and vector._methods.VectorProtocolSpatial.deltaeta():

\[\Delta R^2 = \Delta\phi^2 + \Delta\eta^2\]

deltaangle(other: VectorProtocolSpatial | VectorProtocolLorentz) → Any#

Angle in 3D space between self and other, which is always positive, between \(0\) and \(\pi\).

deltaeta(other: VectorProtocolSpatial | VectorProtocolLorentz) → Any#

Signed difference in \(\eta\) of self minus other.

deltaphi(other: VectorProtocol) → Any#

Signed difference in \(\phi\) of self minus other (in radians).

dot(other: VectorProtocol) → Any#

Vector dot product of self with other.

This method is equivalent to the @ operator.

equal(other: VectorProtocol) → Any#

Returns True if self is exactly equal to other (possibly for arrays of vectors), False otherwise.

This method is equivalent to the == operator.

Typically, you’ll want to check vector._methods.VectorProtocol.isclose() to allow for numerical errors.

property eta: Any#

The pseudorapidity \(\eta\) coordinate of the vector or every vector in the array (in radians, always between \(0\) (\(+z\)) and \(\pi\) (\(-z\))).

is_antiparallel(other: VectorProtocol, tolerance: Any = 1e-05) → Any#

Returns True if self and other are pointing in opposite directions (i.e. dot product is nearly -abs(self) * abs(other)).

The tolerance is measured in units of \(\cos(\Delta\alpha)\) where \(\Delta\alpha\) is self.deltaangle(other).

is_parallel(other: VectorProtocol, tolerance: Any = 1e-05) → Any#

Returns True if self and other are pointing in the same direction (i.e. not “antiparallel”; dot product is nearly abs(self) * abs(other)).

The tolerance is measured in units of \(\cos(\Delta\alpha)\) where \(\Delta\alpha\) is self.deltaangle(other).

is_perpendicular(other: VectorProtocol, tolerance: Any = 1e-05) → Any#

Returns True if self and other are pointing in perpendicular directions (i.e. dot product is nearly 0).

The tolerance is measured in units of \(\cos(\Delta\alpha)\) where \(\Delta\alpha\) is self.deltaangle(other).

isclose(other: VectorProtocol, rtol: Any = 1e-05, atol: Any = 1e-08, equal_nan: Any = False) → Any#

Returns True if self is approximately equal to other (possibly for arrays of vectors), False otherwise.

The relative tolerance (rtol) and absolute tolerance (atol) are interpreted as in np.isclose:

close_enough = abs(self - other) <= atol + rtol * abs(other)
like(other: VectorProtocol) → VectorProtocol#

Projects the vector into the geometric coordinates of the other vector.

Value(s) of \(0\) is/are imputed while transforming vector from a lower geometric dimension to a higher geometric dimension.

vec_4d + vec_3d.like(vec_4d)

For more flexibility (passing new coordinate values), see vector._methods.Vector2D.to_Vector3D(), vector._methods.Vector2D.to_Vector4D(), and vector._methods.Vector3D.to_Vector4D(), which can be used as:

vec_2d.to_Vector3D(z=3.0)
vec_2d.to_Vector4D(z=3.0, t=4.0)
vec_3d.to_Vector4D(t=4.0)
property longitudinal: Longitudinal#

Container of longitudinal coordinates, for use in dispatching to compute functions or to identify coordinate system with isinstance.

property mag: Any#

The magnitude of the vector(s) in 3D (not including any temporal parts).

property mag2: Any#

The magnitude-squared of the vector(s) in 3D (not including any temporal parts).

property neg2D: SameVectorType#

Returns vector(s) with the 2D part negated, not affecting any longitudinal or temporal parts.

property neg3D: SameVectorType#

Returns vector(s) with the 3D part negated, not affecting any longitudinal or temporal parts.

not_equal(other: VectorProtocol) → Any#

Returns False if self is exactly equal to other (possibly for arrays of vectors), True otherwise.

This method is equivalent to the != operator.

Typically, you’ll want to check vector._methods.VectorProtocol.isclose() to allow for numerical errors.

property phi: Any#

The polar \(\phi\) coordinate of the vector or every vector in the array (in radians, always between \(-\pi\) and \(\pi\)).

property rho: Any#

The polar \(\rho\) coordinate of the vector or every vector in the array.

This is also the magnitude of the 2D azimuthal part of the vector (not including any longitudinal or temporal parts).

property rho2: Any#

The polar \(\rho\) coordinate squared of the vector or every vector in the array.

rotateX(angle: Any) → SameVectorType#

Rotates the vector(s) by a given angle (in radians) around the \(x\) axis.

Note that the angle can be an array with the same length as the vectors, if the vectors are in an array.

rotateY(angle: Any) → SameVectorType#

Rotates the vector(s) by a given angle (in radians) around the \(y\) axis.

Note that the angle can be an array with the same length as the vectors, if the vectors are in an array.

rotateZ(angle: Any) → SameVectorType#

Rotates the vector(s) by a given angle (in radians) around the longitudinal axis.

Note that the angle can be an array with the same length as the vectors, if the vectors are in an array.

rotate_axis(axis: VectorProtocolSpatial, angle: Any) → SameVectorType#

Rotates the vector(s) by a given angle (in radians) around the axis indicated by another vector, axis. The magnitude of axis is ignored.

Note that the axis and angle can be arrays with the same length as the vectors, if the vectors are in an array.

rotate_euler(phi: Any, theta: Any, psi: Any, order: str = 'zxz') → SameVectorType#

Rotates the vector(s) by three given angles: phi, theta, and psi (in radians). The order string determines which axis each rotation is applied around:

The names phi, theta, and psi agree with Wikipedia’s terminology, and both the names and order agree with ROOT’s Math::EulerAngles. The default order = "zxz" is also ROOT’s convention.

Note that the angles can be arrays with the same lengths as the vectors, if the vectors are in an array.

rotate_nautical(yaw: Any, pitch: Any, roll: Any) → SameVectorType#

Rotates the vector(s) by three given angles: yaw, pitch, and roll (in radians). These are Tait-Bryan angles often used for boats and planes (see this lesson and this lesson).

This function is entirely equivalent to

rotate_euler(roll, pitch, yaw, order="zyx")

Note that the angles can be arrays with the same lengths as the vectors, if the vectors are in an array.

rotate_quaternion(u: Any, i: Any, j: Any, k: Any) → SameVectorType#

Rotates the vector(s) by four angles as quaternion coefficients (in radians). Four angles are sometimes preferred over three because the latter has a pathology known as “gimbal lock.”

This function follows the same conventions as ROOT’s Math::Quaternion.

Note that the angles can be arrays with the same lengths as the vectors, if the vectors are in an array.

scale(factor: Any) → SameVectorType#

Returns vector(s) scaled by a factor, changing the length(s) but not the direction(s).

This method is equivalent to the * operator.

scale2D(factor: Any) → SameVectorType#

Returns vector(s) with the 2D part scaled by a factor, not affecting any longitudinal or temporal parts.

scale3D(factor: Any) → SameVectorType#

Returns vector(s) with the 3D part scaled by a factor, not affecting any longitudinal or temporal parts.

subtract(other: VectorProtocol) → VectorProtocol#

Difference of self minus other.

This method is equivalent to the - operator.

property theta: Any#

The spherical \(\theta\) coordinate (polar angle) of the vector or every vector in the array (in radians, always between \(0\) (\(+z\)) and \(\pi\) (\(-z\))).

to_2D() → VectorProtocolPlanar#

Projects this vector/these vectors onto azimuthal coordinates only.

Alias for vector._methods.VectorProtocol.to_Vector2D().

to_3D() → VectorProtocolSpatial#

Projects this vector/these vectors onto azimuthal and longitudinal coordinates only.

If 2D, a default \(z\) component of \(0\) is imputed.

The longitudinal coordinate can be passed as a named argument.

Alias for vector._methods.VectorProtocol.to_Vector3D().

to_4D() → VectorProtocolLorentz#

Projects this vector/these vectors onto azimuthal, longitudinal, and temporal coordinates.

If 3D, a default \(t\) component of \(0\) is imputed.

If 2D, a \(z\) component of \(0\) is imputed along with a default \(t\) component of \(0\).

The longitudinal and temporal coordinates can be passed as named arguments.

Alias for vector._methods.VectorProtocol.to_Vector4D().

to_Vector2D() → VectorProtocolPlanar#

Projects this vector/these vectors onto azimuthal coordinates only.

to_Vector3D() → VectorProtocolSpatial#

Projects this vector/these vectors onto azimuthal and longitudinal coordinates only.

If 2D, a default \(z\) component of \(0\) is imputed.

The longitudinal coordinate can be passed as a named argument.

to_Vector4D() → VectorProtocolLorentz#

Projects this vector/these vectors onto azimuthal, longitudinal, and temporal coordinates.

If 3D, a default \(t\) component of \(0\) is imputed.

If 2D, a \(z\) component of \(0\) is imputed along with a default \(t\) component of \(0\).

The longitudinal and temporal coordinates can be passed as named arguments.

to_ptphi() → VectorProtocolPlanar#

Converts to \(pt\)-\(\phi\) coordinates, possibly eliminating dimensions with a projection.

to_ptphieta() → VectorProtocolSpatial#

Converts to \(pt\)-\(\phi\)-\(\eta\) coordinates, possibly eliminating or imputing dimensions with a projection.

The \(eta\) coordinate can be passed as a named argument.

to_ptphietaenergy() → VectorProtocolLorentz#

Converts to \(pt\)-\(\phi\)-\(\eta\)-\(energy\) coordinates, possibly imputing dimensions with a projection.

The \(eta\) and \(energy\) coordinates can be passed as a named argument.

to_ptphietamass() → VectorProtocolLorentz#

Converts to \(pt\)-\(\phi\)-\(\theta\)-\(mass\) coordinates, possibly imputing dimensions with a projection.

The \(eta\) and \(mass\) coordinates can be passed as a named argument.

to_ptphipz() → VectorProtocolSpatial#

Converts to \(pt\)-\(\phi\)-\(pz\) coordinates, possibly eliminating or imputing dimensions with a projection.

The \(pz\) coordinate can be passed as a named argument.

to_ptphipzenergy() → VectorProtocolLorentz#

Converts to \(pt\)-\(\phi\)-\(pz\)-\(energy\) coordinates, possibly imputing dimensions with a projection.

The \(pz\) and \(energy\) coordinates can be passed as a named argument.

to_ptphipzmass() → VectorProtocolLorentz#

Converts to \(pt\)-\(\phi\)-\(pz\)-\(mass\) coordinates, possibly imputing dimensions with a projection.

The \(pz\) and \(mass\) coordinates can be passed as a named argument.

to_ptphitheta() → VectorProtocolSpatial#

Converts to \(pt\)-\(\phi\)-\(\theta\) coordinates, possibly eliminating or imputing dimensions with a projection.

The \(theta\) coordinate can be passed as a named argument.

to_ptphithetaenergy() → VectorProtocolLorentz#

Converts to \(pt\)-\(\phi\)-\(\theta\)-\(energy\) coordinates, possibly imputing dimensions with a projection.

The \(theta\) and \(energy\) coordinates can be passed as a named argument.

to_ptphithetamass() → VectorProtocolLorentz#

Converts to \(pt\)-\(\phi\)-\(\theta\)-\(mass\) coordinates, possibly imputing dimensions with a projection.

The \(theta\) and \(mass\) coordinates can be passed as a named argument.

to_pxpy() → VectorProtocolPlanar#

Converts to \(px\)-\(py\) coordinates, possibly eliminating dimensions with a projection.

to_pxpyeta() → VectorProtocolSpatial#

Converts to \(px\)-\(py\)-\(\eta\) coordinates, possibly eliminating or imputing dimensions with a projection.

The \(eta\) coordinate can be passed as a named argument.

to_pxpyetaenergy() → VectorProtocolLorentz#

Converts to \(px\)-\(py\)-\(\eta\)-\(energy\) coordinates, possibly imputing dimensions with a projection.

The \(eta\) and \(energy\) coordinates can be passed as a named argument.

to_pxpyetamass() → VectorProtocolLorentz#

Converts to \(px\)-\(py\)-\(\eta\)-\(mass\) coordinates, possibly imputing dimensions with a projection.

The \(eta\) and \(mass\) coordinates can be passed as a named argument.

to_pxpypz() → VectorProtocolSpatial#

Converts to \(px\)-\(py\)-\(pz\) coordinates, possibly eliminating or imputing dimensions with a projection.

The \(pz\) coordinate can be passed as a named argument.

to_pxpypzenergy() → VectorProtocolLorentz#

Converts to \(px\)-\(py\)-\(pz\)-\(energy\) coordinates, possibly imputing dimensions with a projection.

The \(pz\) and \(energy\) coordinates can be passed as a named argument.

to_pxpypzmass() → VectorProtocolLorentz#

Converts to \(px\)-\(py\)-\(pz\)-\(mass\) coordinates, possibly imputing dimensions with a projection.

The \(pz\) and \(mass\) coordinates can be passed as a named argument.

to_pxpytheta() → VectorProtocolSpatial#

Converts to \(px\)-\(py\)-\(\theta\) coordinates, possibly eliminating or imputing dimensions with a projection.

The \(theta\) coordinate can be passed as a named argument.

to_pxpythetaenergy() → VectorProtocolLorentz#

Converts to \(px\)-\(py\)-\(\theta\)-\(energy\) coordinates, possibly imputing dimensions with a projection.

The \(theta\) and \(energy\) coordinates can be passed as a named argument.

to_pxpythetamass() → VectorProtocolLorentz#

Converts to \(px\)-\(py\)-\(\theta\)-\(energy\) coordinates, possibly imputing dimensions with a projection.

The \(theta\) and \(mass\) coordinates can be passed as a named argument.

to_rhophi() → VectorProtocolPlanar#

Converts to \(\rho\)-\(\phi\) coordinates, possibly eliminating dimensions with a projection.

to_rhophieta() → VectorProtocolSpatial#

Converts to \(\rho\)-\(\phi\)-\(\eta\) coordinates, possibly eliminating or imputing dimensions with a projection.

The \(eta\) coordinate can be passed as a named argument.

to_rhophietat() → VectorProtocolLorentz#

Converts to \(\rho\)-\(\phi\)-\(\eta\)-\(t\) coordinates, possibly imputing dimensions with a projection.

The \(eta\) and \(t\) coordinates can be passed as a named argument.

to_rhophietatau() → VectorProtocolLorentz#

Converts to \(\rho\)-\(\phi\)-\(\eta\)-\(\tau\) coordinates, possibly imputing dimensions with a projection.

The \(eta\) and \(tau\) coordinates can be passed as a named argument.

to_rhophitheta() → VectorProtocolSpatial#

Converts to \(\rho\)-\(\phi\)-\(\theta\) coordinates, possibly eliminating or imputing dimensions with a projection.

The \(theta\) coordinate can be passed as a named argument.

to_rhophithetat() → VectorProtocolLorentz#

Converts to \(\rho\)-\(\phi\)-\(\theta\)-\(t\) coordinates, possibly imputing dimensions with a projection.

The \(theta\) and \(t\) coordinates can be passed as a named argument.

to_rhophithetatau() → VectorProtocolLorentz#

Converts to \(\rho\)-\(\phi\)-\(\theta\)-\(\tau\) coordinates, possibly imputing dimensions with a projection.

The \(theta\) and \(tau\) coordinates can be passed as a named argument.

to_rhophiz() → VectorProtocolSpatial#

Converts to \(\rho\)-\(\phi\)-\(z\) coordinates, possibly eliminating or imputing dimensions with a projection.

The \(z\) coordinate can be passed as a named argument.

to_rhophizt() → VectorProtocolLorentz#

Converts to \(\rho\)-\(\phi\)-\(z\)-\(t\) coordinates, possibly imputing dimensions with a projection.

The \(z\) and \(t\) coordinates can be passed as a named argument.

to_rhophiztau() → VectorProtocolLorentz#

Converts to \(\rho\)-\(\phi\)-\(z\)-\(\tau\) coordinates, possibly imputing dimensions with a projection.

The \(z\) and \(tau\) coordinates can be passed as a named argument.

to_xy() → VectorProtocolPlanar#

Converts to \(x\)-\(y\) coordinates, possibly eliminating dimensions with a projection.

to_xyeta() → VectorProtocolSpatial#

Converts to \(x\)-\(y\)-\(\eta\) coordinates, possibly eliminating or imputing dimensions with a projection.

The \(eta\) coordinate can be passed as a named argument.

to_xyetat() → VectorProtocolLorentz#

Converts to \(x\)-\(y\)-\(\eta\)-\(t\) coordinates, possibly imputing dimensions with a projection.

The \(eta\) and \(t\) coordinates can be passed as a named argument.

to_xyetatau() → VectorProtocolLorentz#

Converts to \(x\)-\(y\)-\(\eta\)-\(\tau\) coordinates, possibly imputing dimensions with a projection.

The \(eta\) and \(tau\) coordinates can be passed as a named argument.

to_xytheta() → VectorProtocolSpatial#

Converts to \(x\)-\(y\)-\(\theta\) coordinates, possibly eliminating or imputing dimensions with a projection.

The \(theta\) coordinate can be passed as a named argument.

to_xythetat() → VectorProtocolLorentz#

Converts to \(x\)-\(y\)-\(\theta\)-\(t\) coordinates, possibly imputing dimensions with a projection.

The \(theta\) and \(t\) coordinates can be passed as a named argument.

to_xythetatau() → VectorProtocolLorentz#

Converts to \(x\)-\(y\)-\(\theta\)-\(\tau\) coordinates, possibly imputing dimensions with a projection.

The \(theta\) and \(tau\) coordinates can be passed as a named argument.

to_xyz() → VectorProtocolSpatial#

Converts to \(x\)-\(y\)-\(z\) coordinates, possibly eliminating or imputing dimensions with a projection.

The \(z\) coordinate can be passed as a named argument.

to_xyzt() → VectorProtocolLorentz#

Converts to \(x\)-\(y\)-\(z\)-\(t\) coordinates, possibly imputing dimensions with a projection.

The \(z\) and \(t\) coordinates can be passed as a named argument.

to_xyztau() → VectorProtocolLorentz#

Converts to \(x\)-\(y\)-\(z\)-\(\tau\) coordinates, possibly imputing dimensions with a projection.

The \(z\) and \(tau\) coordinates can be passed as a named argument.

transform2D(obj: TransformProtocol2D) → SameVectorType#

Arbitrarily transforms the vector(s) by

obj["xx"] obj["xy"]
obj["yx"] obj["yy"]

leaving any longitudinal or temporal coordinates unchanged. There is no restriction on the type of obj; it just has to provide those components (which can be arrays if the vectors are in an array).

transform3D(obj: TransformProtocol3D) → SameVectorType#

Arbitrarily transforms the vector(s) by

obj["xx"] obj["xy"] obj["xz"]
obj["yx"] obj["yy"] obj["yz"]
obj["zx"] obj["zy"] obj["zz"]

leaving any temporal coordinate unchanged. There is no restriction on the type of obj; it just has to provide those components (which can be arrays if the vectors are in an array).

unit() → SameVectorType#

Returns vector(s) normalized to unit length, which is rho == 1 for 2D vectors, mag == 1 for 3D vectors, and tau == 1 for 4D vectors.

property x: Any#

The Cartesian \(x\) coordinate of the vector or every vector in the array.

property y: Any#

The Cartesian \(y\) coordinate of the vector or every vector in the array.

property z: Any#

The Cartesian \(z\) coordinate of the vector or every vector in the array.

Contents