Feature/refactor (#9)

* Describe installation from pypi in the Readme
* Make Vector.algebra a class property
* Add Vector.basis

Author: antemons

README.md

@@ -13,10 +13,7 @@ The key features are:
 
 # Installation
 
-From source:
-
-    git clone [email protected]:wandelbotsgmbh/geometricalgebra.git
-    pip install ./geometricalgebra/
+    pip install geometricalgebra
 
 # Example
 

geometricalgebra/algebra.py

@@ -51,7 +51,7 @@ class GeometricAlgebra:
     _instances: Dict[Tuple[int, ...], "GeometricAlgebra"] = {}
 
     def __repr__(self):
-        return f"GeometricAlgebra({self.signature()})"
+        return f"GeometricAlgebra({self.signature})"
 
     def __new__(cls, signature: Tuple[int, ...]):
         if signature not in cls._instances:
@@ -180,16 +180,16 @@ def mask_from_grades(self, a: Grades, other: Optional[Grades] = None) -> Union[s
 
     @lru_cache(2**14)
     def grades_of_product(
-        self, grades_a: Grades, grades_b: Grades, product_type: ProductType = ProductType.GEOMETRIC
+        self, grades_left: Grades, grades_right: Grades, product_type: ProductType = ProductType.GEOMETRIC
     ) -> Grades:
         """Return the grades which might have non-zero entries given the grades of the two inputs multivectors
 
         Note: It gives a superset of the grades since depending on the actual values some grades may vanish,
             e.g., a & a
 
         Args:
-            grades_a: the grades of the first argument
-            grades_b: the grades of the second argument
+            grades_left: the grades of the left argument
+            grades_right: the grades of the right argument
             product_type: type of the product (inner, outer, geometric)
 
         Returns:
@@ -198,7 +198,7 @@ def grades_of_product(
         Raises:
             TypeError: if product_type is of wrong type
         """
-        all_pairs = ((i, j) for i in grades_a for j in grades_b)
+        all_pairs = ((i, j) for i in grades_left for j in grades_right)
         if product_type in (ProductType.GEOMETRIC, ProductType.COMMUTATOR, ProductType.ANTICOMMUTATOR):
             # TODO(dv): commutator and anticommutator output grades can be narrowed down (e.g. based on the generator matrix)
             result = (i for (a, b) in all_pairs for i in range(abs(a - b), a + b + 1, 2))

geometricalgebra/cga.py

@@ -78,7 +78,7 @@ def e_inf(cls):
 
     @classmethod
     def from_euclid(cls: Type[Subtype], vectors: ArrayLike) -> Subtype:
-        """Create a positional vector from euclidean points (via Hestenes mapping)
+        """Create a positional vector from Euclidean points (via Hestenes mapping)
 
         Args:
             vectors: any array of shape (..., 3)
@@ -91,7 +91,7 @@ def from_euclid(cls: Type[Subtype], vectors: ArrayLike) -> Subtype:
 
     @classmethod
     def from_euclid_2d(cls: Type[Subtype], vectors: ArrayLike) -> Subtype:
-        """Create a positional vector from euclidean points in 2D (via Hestenes mapping) in the xy-plane
+        """Create a positional vector from Euclidean points in 2D (via Hestenes mapping) in the xy-plane
 
         Args:
             vectors: any array of shape (..., 2)
@@ -398,7 +398,7 @@ def from_motor_estimation(
             only_2d: Whether only 2d motors are valid
 
         Returns:
-            motor that maps p to to the entities q (as far as possible)
+            motor that maps p to the entities q (as far as possible)
 
         Reference:
             Valkenburg, Dorst, "Estimating Motors from a Variety of Geometric Data in 3D Conformal Geometric Algebra" (2011)

geometricalgebra/cga2d.py

@@ -9,8 +9,9 @@
 class Vector(CGAVector):
     """A 2d CGA Tensor"""
 
+    @classmethod  # type: ignore
     @property
-    def algebra(self):
+    def algebra(cls):
         return ALGEBRA
 
     @classmethod
@@ -46,10 +47,7 @@ def minkovski_plane(cls):
         raise NotImplementedError()
 
 
-e_1 = Vector([1, 0, 0, 0], grade=1)
-e_2 = Vector([0, 1, 0, 0], grade=1)
-e_plus = Vector([0, 0, 1, 0], grade=1)
-e_minus = Vector([0, 0, 0, 1], grade=1)
+e_1, e_2, e_plus, e_minus = Vector.basis()
 e_inf = e_plus + e_minus
 e_0 = (e_minus - e_plus) / 2
 i4 = e_1 ^ e_2 ^ e_inf ^ e_0

geometricalgebra/cga3d.py

@@ -20,8 +20,9 @@
 class Vector(CGAVector):
     """A 3d CGA Tensor"""
 
+    @classmethod  # type: ignore
     @property
-    def algebra(self):
+    def algebra(cls):
         return ALGEBRA
 
     @classmethod
@@ -87,11 +88,7 @@ def to_barycentric_coordinates_full(self, grade=1) -> Tuple[Array, Vector]:  # t
         return self.xnp().einsum("ij,...j->...i", a, self._values), control_points
 
 
-e_1 = Vector([1.0, 0, 0, 0, 0], grade=1)
-e_2 = Vector([0.0, 1, 0, 0, 0], grade=1)
-e_3 = Vector([0.0, 0, 1, 0, 0], grade=1)
-e_plus = Vector([0.0, 0, 0, 1, 0], grade=1)
-e_minus = Vector([0.0, 0, 0, 0, 1], grade=1)
+e_1, e_2, e_3, e_plus, e_minus = Vector.basis()
 e_inf = e_plus + e_minus
 e_0 = (e_minus - e_plus) / 2
 i3 = e_1 ^ e_2 ^ e_3

geometricalgebra/cga4d.py

@@ -11,8 +11,9 @@
 class Vector(CGAVector):
     """A 4d CGA Tensor"""
 
+    @classmethod  # type: ignore
     @property
-    def algebra(self):
+    def algebra(cls):
         return ALGEBRA
 
     @classmethod
@@ -58,11 +59,8 @@ def __init__(self, values, grade: Union[int, Iterable[int]], algebra=None):
         super().__init__(values, grade)
 
 
-e_1 = Vector([1, 0, 0, 0, 0, 0], grade=1)
-e_2 = Vector([0, 1, 0, 0, 0, 0], grade=1)
-e_3 = Vector([0, 0, 1, 0, 0, 0], grade=1)
-e_4 = Vector([0, 0, 0, 1, 0, 0], grade=1)
-e_inf = Vector([0, 0, 0, 0, 1, 1], grade=1)
-e_0 = Vector([0, 0, 0, 0, -0.5, 0.5], grade=1)
+e_1, e_2, e_3, e_4, e_plus, e_minus = Vector.basis()
+e_inf = e_plus + e_minus
+e_0 = (e_minus - e_plus) / 2
 i6 = e_1 ^ e_2 ^ e_3 ^ e_4 ^ e_inf ^ e_0
 i4 = e_1 ^ e_2 ^ e_3 ^ e_4

geometricalgebra/vector.py

@@ -75,6 +75,10 @@ class Vector:  # pylint: disable=too-many-public-methods
     def framework(cls) -> Framework:
         return FRAMEWORK
 
+    @classmethod
+    def basis(cls) -> Vector:
+        return cls(cls.xnp().eye(cls.algebra.dims_of_grade[1]), grade=1)  # type: ignore
+
     @classmethod
     def xnp(cls):
         return cls.framework().numpy
@@ -104,8 +108,9 @@ def __call__(self: Subtype, grade: Union[int, Iterable[int]]) -> Subtype:
         mask = self.algebra.mask_from_grades(grades, self._grades)
         return type(self)(self._values[..., mask], grades)
 
+    @classmethod  # type: ignore
     @property
-    def algebra(self):
+    def algebra(cls):
         raise NotImplementedError()
 
     @property