vector 1.3.1__tar.gz → 1.4.1__tar.gz

{vector-1.3.1 → vector-1.4.1}/.github/workflows/cd.yml

@@ -9,6 +9,10 @@ on:
 jobs:
   dist:
     runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+      attestations: write
+      contents: read
     steps:
       - uses: actions/checkout@v4
         with:
@@ -17,13 +21,18 @@ jobs:
       - name: Build SDist and wheel
         run: pipx run build
 
+      - name: Check metadata
+        run: pipx run twine check dist/*
+
+      - name: Generate artifact attestation for sdist and wheel
+        uses: actions/attest-build-provenance@49df96e17e918a15956db358890b08e61c704919 # v1.2.0
+        with:
+          subject-path: "dist/vector-*"
+
       - uses: actions/upload-artifact@v4
         with:
           path: dist/*
 
-      - name: Check metadata
-        run: pipx run twine check dist/*
-
   publish:
     needs: [dist]
     runs-on: ubuntu-latest
@@ -40,4 +49,17 @@ jobs:
           name: artifact
           path: dist
 
+      - name: List distributions to be deployed
+        run: ls -l dist/
+
+      - name: Verify sdist artifact attestation
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: gh attestation verify dist/vector-*.tar.gz --repo ${{ github.repository }}
+
+      - name: Verify wheel artifact attestation
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: gh attestation verify dist/vector-*.whl --repo ${{ github.repository }}
+
       - uses: pypa/gh-action-pypi-publish@release/v1

{vector-1.3.1 → vector-1.4.1}/.github/workflows/ci.yml

@@ -57,6 +57,14 @@ jobs:
       - name: Test light package
         run: python -m pytest -ra --ignore tests/test_notebooks.py
 
+      - name: Install numpy v2
+        if: matrix.python-version != 3.8
+        run: python -m pip install "numpy>=2.0.0b1"
+
+      - name: Test light package with numpy v2.x
+        if: matrix.python-version != 3.8
+        run: python -m pytest -ra --ignore tests/test_notebooks.py
+
   check-awkward-v1:
     needs: [check-light]
     runs-on: ubuntu-latest
@@ -129,8 +137,16 @@ jobs:
       - name: Test package with awkward v2.x
         run: python -m pytest -ra --cov=vector --ignore tests/test_notebooks.py .
 
+      - name: Install numpy v2
+        if: matrix.python-version != 3.8
+        run: python -m pip install "numpy>=2.0.0b1"
+
+      - name: Test package with numpy v2.x
+        if: matrix.python-version != 3.8
+        run: python -m pytest -ra --cov=vector --ignore tests/test_notebooks.py .
+
       - name: Upload coverage report
-        uses: codecov/codecov-action@v4.1.0
+        uses: codecov/codecov-action@v4.4.1
         with:
           token: ${{ secrets.CODECOV_TOKEN }}
 

{vector-1.3.1 → vector-1.4.1}/.pre-commit-config.yaml

@@ -4,7 +4,7 @@ ci:
 
 repos:
   - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v4.5.0
+    rev: v4.6.0
     hooks:
       - id: check-added-large-files
       - id: check-case-conflict
@@ -19,19 +19,14 @@ repos:
       - id: trailing-whitespace
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: "v0.3.2"
+    rev: "v0.4.4"
     hooks:
       - id: ruff
         args: ["--fix", "--show-fixes"]
       - id: ruff-format
 
-  - repo: https://github.com/tox-dev/pyproject-fmt
-    rev: "1.7.0"
-    hooks:
-      - id: pyproject-fmt
-
   - repo: https://github.com/pre-commit/mirrors-mypy
-    rev: v1.9.0
+    rev: v1.10.0
     hooks:
       - id: mypy
         files: src
@@ -39,11 +34,13 @@ repos:
         additional_dependencies:
           - numpy
           - packaging
+          - sympy
 
   - repo: https://github.com/codespell-project/codespell
     rev: v2.2.6
     hooks:
       - id: codespell
+        exclude: ^docs/usage/intro.ipynb$
 
   - repo: https://github.com/pre-commit/mirrors-prettier
     rev: "v4.0.0-alpha.8"
@@ -69,7 +66,7 @@ repos:
       - id: rst-inline-touching-normal
 
   - repo: https://github.com/nbQA-dev/nbQA
-    rev: 1.8.4
+    rev: 1.8.5
     hooks:
       - id: nbqa-pyupgrade
         args: ["--py37-plus"]

{vector-1.3.1 → vector-1.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: vector
-Version: 1.3.1
+Version: 1.4.1
 Summary: Vector classes and utilities
 Project-URL: Bug Tracker, https://github.com/scikit-hep/vector/issues
 Project-URL: Changelog, https://vector.readthedocs.io/en/latest/changelog.html
@@ -42,6 +42,7 @@ Requires-Dist: papermill>=2.4; extra == 'dev'
 Requires-Dist: pytest-cov>=3; extra == 'dev'
 Requires-Dist: pytest-doctestplus; extra == 'dev'
 Requires-Dist: pytest>=6; extra == 'dev'
+Requires-Dist: sympy; extra == 'dev'
 Provides-Extra: docs
 Requires-Dist: awkward>=1.2; extra == 'docs'
 Requires-Dist: ipykernel; extra == 'docs'
@@ -53,6 +54,8 @@ Requires-Dist: sphinx-math-dollar; extra == 'docs'
 Requires-Dist: sphinx>=4; extra == 'docs'
 Provides-Extra: numba
 Requires-Dist: numba>=0.57; (python_version < '3.12') and extra == 'numba'
+Provides-Extra: sympy
+Requires-Dist: sympy; extra == 'sympy'
 Provides-Extra: test
 Requires-Dist: dask-awkward; extra == 'test'
 Requires-Dist: nox; extra == 'test'
@@ -93,10 +96,12 @@ Main features of Vector:
 - Uses names and conventions set by [ROOT](https://root.cern/)'s [TLorentzVector](https://root.cern.ch/doc/master/classTLorentzVector.html) and [Math::LorentzVector](https://root.cern.ch/doc/master/classROOT_1_1Math_1_1LorentzVector.html), as well as [scikit-hep/math](https://github.com/scikit-hep/scikit-hep/tree/master/skhep/math), [uproot-methods TLorentzVector](https://github.com/scikit-hep/uproot3-methods/blob/master/uproot3_methods/classes/TLorentzVector.py), [henryiii/hepvector](https://github.com/henryiii/hepvector), and [coffea.nanoevents.methods.vector](https://coffeateam.github.io/coffea/modules/coffea.nanoevents.methods.vector.html).
 - Implemented on a variety of backends:
   - pure Python objects
+  - [SymPy](https://www.sympy.org/en/index.html) vectors
   - NumPy arrays of vectors (as a [structured array](https://numpy.org/doc/stable/user/basics.rec.html) subclass)
   - [Awkward Arrays](https://awkward-array.org/) of vectors
   - potential for more: CuPy, TensorFlow, Torch, JAX...
-- NumPy/Awkward backends also implemented in [Numba](https://numba.pydata.org/) for JIT-compiled calculations on vectors.
+- Awkward backend also implemented in [Numba](https://numba.pydata.org/) for JIT-compiled calculations on vectors.
+- [JAX](https://awkward-array.org/doc/main/user-guide/how-to-specialize-differentiate-jax.html) and [Dask](https://dask-awkward.readthedocs.io/en/stable/) support through Awkward Arrays.
 - Distinction between geometrical vectors, which have a minimum of attribute and method names, and vectors representing momentum, which have synonyms like `pt` = `rho`, `energy` = `t`, `mass` = `tau`.
 
 ## Installation
@@ -125,7 +130,7 @@ The easiest way to create one or many vectors is with a helper function:
 
 ### Pure Python vectors
 
-You can directly use the `VectorObject` classes to construct object type vectors:
+You can directly use the `VectorObject` and `MomentumObject` classes to construct object type vectors:
 
 ```python
 vector.VectorObject2D(x=1.1, y=2.2)
@@ -226,6 +231,80 @@ vector.VectorObject4D.from_xyetatau(1.1, 2.2, 3.3, 4.4)
 
 and so on, for all combinations of azimuthal, longitudinal, and temporal coordinates, geometric and momentum-flavored.
 
+### SymPy vectors
+
+> **Note:** Operations on SymPy vectors are only 100% compatible with numeric vectors (Python, NumPy, and Awkward backends) if the vectors are positive time-like, that is, if `t**2 > x**2 + y**2 + z**2`. The space-like and negative time-like cases have different sign conventions.
+
+You can directly use the `VectorSympy` and `MomentumSympy` classes to construct object type vectors:
+
+```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,  # see sympy assumptions to add more restrictions on the symbols
+)
+vector.VectorSympy2D(x=x, y=y)
+vector.MomentumSympy3D(px=px, py=py, pz=pz)
+vector.VectorSympy4D(x=x, y=y, eta=eta, tau=tau)
+```
+
+and so on for every class.
+
+```python
+# Test instance type for any level of granularity.
+(
+    # is a vector or array of vectors
+    isinstance(vector.VectorSympy2D(x=x, y=y), vector.Vector),
+    # is 2D (not 3D or 4D)
+    isinstance(vector.VectorSympy2D(x=x, y=y), vector.Vector2D),
+    # is a sympy vector (not an array)
+    isinstance(vector.VectorSympy2D(x=x, y=y), vector.VectorSympy),
+    # has momentum synonyms
+    isinstance(vector.MomentumSympy2D(px=px, py=py), vector.Momentum),
+    # has transverse plane (2D, 3D, or 4D)
+    isinstance(vector.VectorSympy4D(x=x, y=y, z=z, t=t), vector.Planar),
+    # has all spatial coordinates (3D or 4D)
+    isinstance(vector.VectorSympy4D(x=x, y=y, z=z, t=t), vector.Spatial),
+    # has temporal coordinates (4D)
+    isinstance(vector.VectorSympy4D(x=x, y=y, z=z, t=t), vector.Lorentz),
+    # azimuthal coordinate type
+    isinstance(vector.VectorSympy4D(x=x, y=y, z=z, t=t).azimuthal, vector.AzimuthalXY),
+    # longitudinal coordinate type
+    isinstance(
+        vector.VectorSympy4D(x=x, y=y, z=z, t=t).longitudinal, vector.LongitudinalZ
+    ),
+    # temporal coordinate type
+    isinstance(vector.VectorSympy4D(x=x, y=y, z=z, t=t).temporal, vector.TemporalT),
+)
+```
+
+Since `VectorSympy2D`, `VectorSympy3D`, `VectorSympy4D`, and their momentum equivalents operate on SymPy expressions, all of the normal SymPy methods and functions work on the results, coordinates, and the vectors.
+
+```python
+sympy.init_session()  # latex printing
+
+v1 = vector.VectorSympy2D(x=x, y=y)
+sympy.Eq(v1.rho, sympy.sqrt(x**2 + y**2))
+
+v2 = vector.VectorSympy4D(x=x, y=y, z=z, t=t)
+v2.to_rhophithetatau().tau
+
+values = {x: 3, y: 2, z: 1, t: 10}  # t**2 > x**2 + y**2 + z**2
+v2.is_timelike()
+v2.is_timelike().subs(values)
+
+v2.to_rhophithetatau().tau.subs(values).evalf()
+
+v2.boost(v2.to_beta3())
+v2.boost(v2.to_beta3()).t
+v2.boost(v2.to_beta3()).t.simplify()
+v2.boost(v2.to_beta3()).t.subs(values)
+v2.boost(v2.to_beta3()).t.subs(values).evalf()
+```
+
+All of the keyword arguments and rules that apply to `vector.obj` construction apply to `vector.VectorSympyND` and `vector.MomentumObjectND` objects.
+
 ### NumPy arrays of vectors
 
 You can directly use the `VectorNumpy` classes to construct object type vectors:
@@ -752,6 +831,104 @@ def compute_masses(array):
 compute_masses(array)
 ```
 
+## Sub-classing Awkward mixins
+
+At the moment, it is possible to sub-class vector awkward mixins to extend the vector functionalities. Although the mechanism in place works well, it is still being improved.
+
+For instance, the `MomentumAwkward` classes can be extended in the following way:
+
+```py
+@ak.mixin_class(vector.backends.awkward.behavior)
+class TwoVector(vector.backends.awkward.MomentumAwkward2D):
+    pass
+
+
+@ak.mixin_class(vector.backends.awkward.behavior)
+class ThreeVector(vector.backends.awkward.MomentumAwkward3D):
+    pass
+
+
+# required for transforming vectors
+# the class names must always end with "Array"
+TwoVectorArray.ProjectionClass2D = TwoVectorArray  # noqa: F821
+TwoVectorArray.ProjectionClass3D = ThreeVectorArray  # noqa: F821
+TwoVectorArray.MomentumClass = TwoVectorArray  # noqa: F821
+
+ThreeVectorArray.ProjectionClass2D = TwoVectorArray  # noqa: F821
+ThreeVectorArray.ProjectionClass3D = ThreeVectorArray  # noqa: F821
+ThreeVectorArray.MomentumClass = ThreeVectorArray  # noqa: F821
+
+vec = ak.zip(
+    {
+        "pt": [[1, 2], [], [3], [4]],
+        "phi": [[1.2, 1.4], [], [1.6], [3.4]],
+    },
+    with_name="TwoVector",
+    behavior=vector.backends.awkward.behavior,
+)
+
+vec
+```
+
+The binary operators are not automatically registered by awkward, but vector methods can be used to perform operations on sub-classed vectors.
+
+```py
+vec.add(vec)
+```
+
+Similarly, other vector methods can be used by the new methods internally.
+
+```py
+@ak.mixin_class(vector.backends.awkward.behavior)
+class LorentzVector(vector.backends.awkward.MomentumAwkward4D):
+    @ak.mixin_class_method(np.divide, {numbers.Number})
+    def divide(self, factor):
+        return self.scale(1 / factor)
+
+
+# required for transforming vectors
+# the class names must always end with "Array"
+LorentzVectorArray.ProjectionClass2D = TwoVectorArray  # noqa: F821
+LorentzVectorArray.ProjectionClass3D = ThreeVectorArray  # noqa: F821
+LorentzVectorArray.ProjectionClass4D = LorentzVectorArray  # noqa: F821
+LorentzVectorArray.MomentumClass = LorentzVectorArray  # noqa: F821
+
+vec = ak.zip(
+    {
+        "pt": [[1, 2], [], [3], [4]],
+        "eta": [[1.2, 1.4], [], [1.6], [3.4]],
+        "phi": [[0.3, 0.4], [], [0.5], [0.6]],
+        "energy": [[50, 51], [], [52], [60]],
+    },
+    with_name="LorentzVector",
+    behavior=vector.backends.awkward.behavior,
+)
+
+vec / 2
+vec.like(vector.obj(x=1, y=2))
+vec.like(vector.obj(x=1, y=2, z=3))
+```
+
+It is also possible to manually add binary operations in vector's behavior dict to enable binary operations.
+
+```py
+_binary_dispatch_cls = {
+    "TwoVector": TwoVector,
+    "ThreeVector": ThreeVector,
+    "LorentzVector": LorentzVector,
+}
+_rank = [TwoVector, ThreeVector, LorentzVector]
+
+for lhs, lhs_to in _binary_dispatch_cls.items():
+    for rhs, rhs_to in _binary_dispatch_cls.items():
+        out_to = min(lhs_to, rhs_to, key=_rank.index)
+        vector.backends.awkward.behavior[(np.add, lhs, rhs)] = out_to.add
+        vector.backends.awkward.behavior[(np.subtract, lhs, rhs)] = out_to.subtract
+
+vec + vec
+vec.to_2D() + vec.to_2D()
+```
+
 ## Talks about vector
 
 - 9th October 2023 - [What’s new with Vector? First major release is out!](https://indi.to/35ym5) - [PyHEP 2023 (virtual)](https://indico.cern.ch/event/1252095/) [🎥](https://www.youtube.com/watch?v=JHEAb2R3xzE&list=PLKZ9c4ONm-VlAorAG8kR09ZqhMfHiH2LJ&index=10)

{vector-1.3.1 → vector-1.4.1}/README.md

@@ -26,10 +26,12 @@ Main features of Vector:
 - Uses names and conventions set by [ROOT](https://root.cern/)'s [TLorentzVector](https://root.cern.ch/doc/master/classTLorentzVector.html) and [Math::LorentzVector](https://root.cern.ch/doc/master/classROOT_1_1Math_1_1LorentzVector.html), as well as [scikit-hep/math](https://github.com/scikit-hep/scikit-hep/tree/master/skhep/math), [uproot-methods TLorentzVector](https://github.com/scikit-hep/uproot3-methods/blob/master/uproot3_methods/classes/TLorentzVector.py), [henryiii/hepvector](https://github.com/henryiii/hepvector), and [coffea.nanoevents.methods.vector](https://coffeateam.github.io/coffea/modules/coffea.nanoevents.methods.vector.html).
 - Implemented on a variety of backends:
   - pure Python objects
+  - [SymPy](https://www.sympy.org/en/index.html) vectors
   - NumPy arrays of vectors (as a [structured array](https://numpy.org/doc/stable/user/basics.rec.html) subclass)
   - [Awkward Arrays](https://awkward-array.org/) of vectors
   - potential for more: CuPy, TensorFlow, Torch, JAX...
-- NumPy/Awkward backends also implemented in [Numba](https://numba.pydata.org/) for JIT-compiled calculations on vectors.
+- Awkward backend also implemented in [Numba](https://numba.pydata.org/) for JIT-compiled calculations on vectors.
+- [JAX](https://awkward-array.org/doc/main/user-guide/how-to-specialize-differentiate-jax.html) and [Dask](https://dask-awkward.readthedocs.io/en/stable/) support through Awkward Arrays.
 - Distinction between geometrical vectors, which have a minimum of attribute and method names, and vectors representing momentum, which have synonyms like `pt` = `rho`, `energy` = `t`, `mass` = `tau`.
 
 ## Installation
@@ -58,7 +60,7 @@ The easiest way to create one or many vectors is with a helper function:
 
 ### Pure Python vectors
 
-You can directly use the `VectorObject` classes to construct object type vectors:
+You can directly use the `VectorObject` and `MomentumObject` classes to construct object type vectors:
 
 ```python
 vector.VectorObject2D(x=1.1, y=2.2)
@@ -159,6 +161,80 @@ vector.VectorObject4D.from_xyetatau(1.1, 2.2, 3.3, 4.4)
 
 and so on, for all combinations of azimuthal, longitudinal, and temporal coordinates, geometric and momentum-flavored.
 
+### SymPy vectors
+
+> **Note:** Operations on SymPy vectors are only 100% compatible with numeric vectors (Python, NumPy, and Awkward backends) if the vectors are positive time-like, that is, if `t**2 > x**2 + y**2 + z**2`. The space-like and negative time-like cases have different sign conventions.
+
+You can directly use the `VectorSympy` and `MomentumSympy` classes to construct object type vectors:
+
+```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,  # see sympy assumptions to add more restrictions on the symbols
+)
+vector.VectorSympy2D(x=x, y=y)
+vector.MomentumSympy3D(px=px, py=py, pz=pz)
+vector.VectorSympy4D(x=x, y=y, eta=eta, tau=tau)
+```
+
+and so on for every class.
+
+```python
+# Test instance type for any level of granularity.
+(
+    # is a vector or array of vectors
+    isinstance(vector.VectorSympy2D(x=x, y=y), vector.Vector),
+    # is 2D (not 3D or 4D)
+    isinstance(vector.VectorSympy2D(x=x, y=y), vector.Vector2D),
+    # is a sympy vector (not an array)
+    isinstance(vector.VectorSympy2D(x=x, y=y), vector.VectorSympy),
+    # has momentum synonyms
+    isinstance(vector.MomentumSympy2D(px=px, py=py), vector.Momentum),
+    # has transverse plane (2D, 3D, or 4D)
+    isinstance(vector.VectorSympy4D(x=x, y=y, z=z, t=t), vector.Planar),
+    # has all spatial coordinates (3D or 4D)
+    isinstance(vector.VectorSympy4D(x=x, y=y, z=z, t=t), vector.Spatial),
+    # has temporal coordinates (4D)
+    isinstance(vector.VectorSympy4D(x=x, y=y, z=z, t=t), vector.Lorentz),
+    # azimuthal coordinate type
+    isinstance(vector.VectorSympy4D(x=x, y=y, z=z, t=t).azimuthal, vector.AzimuthalXY),
+    # longitudinal coordinate type
+    isinstance(
+        vector.VectorSympy4D(x=x, y=y, z=z, t=t).longitudinal, vector.LongitudinalZ
+    ),
+    # temporal coordinate type
+    isinstance(vector.VectorSympy4D(x=x, y=y, z=z, t=t).temporal, vector.TemporalT),
+)
+```
+
+Since `VectorSympy2D`, `VectorSympy3D`, `VectorSympy4D`, and their momentum equivalents operate on SymPy expressions, all of the normal SymPy methods and functions work on the results, coordinates, and the vectors.
+
+```python
+sympy.init_session()  # latex printing
+
+v1 = vector.VectorSympy2D(x=x, y=y)
+sympy.Eq(v1.rho, sympy.sqrt(x**2 + y**2))
+
+v2 = vector.VectorSympy4D(x=x, y=y, z=z, t=t)
+v2.to_rhophithetatau().tau
+
+values = {x: 3, y: 2, z: 1, t: 10}  # t**2 > x**2 + y**2 + z**2
+v2.is_timelike()
+v2.is_timelike().subs(values)
+
+v2.to_rhophithetatau().tau.subs(values).evalf()
+
+v2.boost(v2.to_beta3())
+v2.boost(v2.to_beta3()).t
+v2.boost(v2.to_beta3()).t.simplify()
+v2.boost(v2.to_beta3()).t.subs(values)
+v2.boost(v2.to_beta3()).t.subs(values).evalf()
+```
+
+All of the keyword arguments and rules that apply to `vector.obj` construction apply to `vector.VectorSympyND` and `vector.MomentumObjectND` objects.
+
 ### NumPy arrays of vectors
 
 You can directly use the `VectorNumpy` classes to construct object type vectors:
@@ -685,6 +761,104 @@ def compute_masses(array):
 compute_masses(array)
 ```
 
+## Sub-classing Awkward mixins
+
+At the moment, it is possible to sub-class vector awkward mixins to extend the vector functionalities. Although the mechanism in place works well, it is still being improved.
+
+For instance, the `MomentumAwkward` classes can be extended in the following way:
+
+```py
+@ak.mixin_class(vector.backends.awkward.behavior)
+class TwoVector(vector.backends.awkward.MomentumAwkward2D):
+    pass
+
+
+@ak.mixin_class(vector.backends.awkward.behavior)
+class ThreeVector(vector.backends.awkward.MomentumAwkward3D):
+    pass
+
+
+# required for transforming vectors
+# the class names must always end with "Array"
+TwoVectorArray.ProjectionClass2D = TwoVectorArray  # noqa: F821
+TwoVectorArray.ProjectionClass3D = ThreeVectorArray  # noqa: F821
+TwoVectorArray.MomentumClass = TwoVectorArray  # noqa: F821
+
+ThreeVectorArray.ProjectionClass2D = TwoVectorArray  # noqa: F821
+ThreeVectorArray.ProjectionClass3D = ThreeVectorArray  # noqa: F821
+ThreeVectorArray.MomentumClass = ThreeVectorArray  # noqa: F821
+
+vec = ak.zip(
+    {
+        "pt": [[1, 2], [], [3], [4]],
+        "phi": [[1.2, 1.4], [], [1.6], [3.4]],
+    },
+    with_name="TwoVector",
+    behavior=vector.backends.awkward.behavior,
+)
+
+vec
+```
+
+The binary operators are not automatically registered by awkward, but vector methods can be used to perform operations on sub-classed vectors.
+
+```py
+vec.add(vec)
+```
+
+Similarly, other vector methods can be used by the new methods internally.
+
+```py
+@ak.mixin_class(vector.backends.awkward.behavior)
+class LorentzVector(vector.backends.awkward.MomentumAwkward4D):
+    @ak.mixin_class_method(np.divide, {numbers.Number})
+    def divide(self, factor):
+        return self.scale(1 / factor)
+
+
+# required for transforming vectors
+# the class names must always end with "Array"
+LorentzVectorArray.ProjectionClass2D = TwoVectorArray  # noqa: F821
+LorentzVectorArray.ProjectionClass3D = ThreeVectorArray  # noqa: F821
+LorentzVectorArray.ProjectionClass4D = LorentzVectorArray  # noqa: F821
+LorentzVectorArray.MomentumClass = LorentzVectorArray  # noqa: F821
+
+vec = ak.zip(
+    {
+        "pt": [[1, 2], [], [3], [4]],
+        "eta": [[1.2, 1.4], [], [1.6], [3.4]],
+        "phi": [[0.3, 0.4], [], [0.5], [0.6]],
+        "energy": [[50, 51], [], [52], [60]],
+    },
+    with_name="LorentzVector",
+    behavior=vector.backends.awkward.behavior,
+)
+
+vec / 2
+vec.like(vector.obj(x=1, y=2))
+vec.like(vector.obj(x=1, y=2, z=3))
+```
+
+It is also possible to manually add binary operations in vector's behavior dict to enable binary operations.
+
+```py
+_binary_dispatch_cls = {
+    "TwoVector": TwoVector,
+    "ThreeVector": ThreeVector,
+    "LorentzVector": LorentzVector,
+}
+_rank = [TwoVector, ThreeVector, LorentzVector]
+
+for lhs, lhs_to in _binary_dispatch_cls.items():
+    for rhs, rhs_to in _binary_dispatch_cls.items():
+        out_to = min(lhs_to, rhs_to, key=_rank.index)
+        vector.backends.awkward.behavior[(np.add, lhs, rhs)] = out_to.add
+        vector.backends.awkward.behavior[(np.subtract, lhs, rhs)] = out_to.subtract
+
+vec + vec
+vec.to_2D() + vec.to_2D()
+```
+
 ## Talks about vector
 
 - 9th October 2023 - [What’s new with Vector? First major release is out!](https://indi.to/35ym5) - [PyHEP 2023 (virtual)](https://indico.cern.ch/event/1252095/) [🎥](https://www.youtube.com/watch?v=JHEAb2R3xzE&list=PLKZ9c4ONm-VlAorAG8kR09ZqhMfHiH2LJ&index=10)

{vector-1.3.1 → vector-1.4.1}/docs/changelog.md

@@ -1,5 +1,54 @@
 # Changelog
 
+## Version 1.4
+
+### Version 1.4.1
+
+#### Fixes
+
+- fix: sympy backend on numpy 2.0 (full numpy 2.0 support) [#473][]
+- fix: add lower and upper bounds for deltaangle [#465][]
+- fix: maximum for SymPy backend is the identity function now [#465][]
+- fix: get coordinate classes to work for numpy [#466][]
+
+#### Documentation
+
+- docs: add basic docs for sub-classing awkward mixins [#468][]
+
+#### Maintenance
+
+- chore: add missing compute function tests [#454]
+- ci: Add GitHub artifact attestations to package distribution [#470][]
+
+[#473]: https://github.com/scikit-hep/vector/pull/473
+[#465]: https://github.com/scikit-hep/vector/pull/465
+[#466]: https://github.com/scikit-hep/vector/pull/466
+[#468]: https://github.com/scikit-hep/vector/pull/468
+[#454]: https://github.com/scikit-hep/vector/pull/454
+[#470]: https://github.com/scikit-hep/vector/pull/470
+
+### Version 1.4.0
+
+#### Features
+
+- feat: allow coord values in to\_<coord_names> methods [#446][]
+- feat: a sympy backend [#442][]
+
+#### Bug fixes
+
+- fix: call the square implementation for power 2 on object vectors [#444][]
+- fix: use negfactor in negfactor scale test [#456][]
+
+#### Maintenance
+
+- chore: test on numpy 2.0 [#451][]
+
+[#446]: https://github.com/scikit-hep/vector/pull/446
+[#442]: https://github.com/scikit-hep/vector/pull/442
+[#444]: https://github.com/scikit-hep/vector/pull/444
+[#456]: https://github.com/scikit-hep/vector/pull/456
+[#451]: https://github.com/scikit-hep/vector/pull/451
+
 ## Version 1.3
 
 ### Version 1.3.1