Merge pull request #245 from eric-wieser/bi_map

Deprecate a bunch of similar members of `Ga`

Author: eric-wieser

doc/changelog.rst

@@ -2,8 +2,28 @@
 Changelog
 =========
 
-- :support:`64` :attr:`galgebra.ga.Ga.indexes_lst`, :attr:`galgebra.ga.Ga.bases_lst`, :attr:`galgebra.ga.Ga.blades_lst`, and :attr:`galgebra.ga.Ga.mv_blades_lst` are deprecated in favor of the new :attr:`~galgebra.ga.GradedTuple.flat` attribute of :attr:`galgebra.ga.Ga.indexes`, :attr:`galgebra.ga.Ga.bases`, :attr:`galgebra.ga.Ga.blades`, and :attr:`galgebra.ga.Ga.mv_blades`.
-  Since the new properties also include the scalar element, so ``ga.blades_lst`` is equivalent to ``ga.blades.flat[1:]`` (and likewise for the other two properties).
+- :support:`245` The following attributes have been deprecated to reduce the number of similar members in :class:`~galgebra.ga.Ga`.
+
+  * Unified into :attr:`galgebra.ga.Ga.indexes_to_bases_dict`:
+
+    * :attr:`galgebra.ga.Ga.indexes_to_bases` |rarr| ``indexes_to_bases_dict.items()``
+    * :attr:`galgebra.ga.Ga.bases_to_indexes` |rarr| ``indexes_to_bases_dict.inverse.items()``
+    * :attr:`galgebra.ga.Ga.bases_to_indexes_dict` |rarr| ``indexes_to_bases_dict.inverse``
+
+  * Unified into :attr:`galgebra.ga.Ga.indexes_to_bases_dict`:
+
+    * :attr:`galgebra.ga.Ga.indexes_to_blades` |rarr| ``indexes_to_blades_dict.items()``
+    * :attr:`galgebra.ga.Ga.blades_to_indexes` |rarr| ``indexes_to_blades_dict.inverse.items()``
+    * :attr:`galgebra.ga.Ga.blades_to_indexes_dict` |rarr| ``indexes_to_blades_dict.inverse``
+
+- :support:`64` The following attributes have been deprecated in favor of using the new :attr:`~galgebra.ga.GradedTuple.flat` attribute:
+
+  * :attr:`galgebra.ga.Ga.indexes_lst` |rarr| :attr:`galgebra.ga.Ga.indexes` ``.flat``
+  * :attr:`galgebra.ga.Ga.bases_lst` |rarr| :attr:`galgebra.ga.Ga.bases` ``.flat``
+  * :attr:`galgebra.ga.Ga.blades_lst` |rarr| :attr:`galgebra.ga.Ga.blades` ``.flat``
+  * :attr:`galgebra.ga.Ga.mv_blades_lst` |rarr| :attr:`galgebra.ga.Ga.mv_blades` ``.flat``
+
+  Since the replacement properties also include the scalar element, ``ga.blades_lst`` is equivalent to ``ga.blades.flat[1:]`` (and likewise for the other properties).
 
 - :release:`0.4.5 <2019.12.31>`
 - :support:`83` This is the last release to support Python 2.7.
@@ -144,3 +164,5 @@ Changelog
 - :support:`2` Clean up obsolete code in setup.py and make it simple
 - :bug:`2` Fixes `brombo/galgebra#19 <https://github.com/brombo/galgebra/issues/19>`_: Failures in `test_noneuclidian_distance_calculation`
 - :bug:`2` Fixes `brombo/galgebra#20 <https://github.com/brombo/galgebra/issues/20>`_: Incorrect LaTeX output in `test_derivatives_in_spherical_coordinates`
+
+.. include:: <isonum.txt>

galgebra/ga.py

@@ -8,7 +8,7 @@
 from itertools import combinations
 import functools
 from functools import reduce
-from typing import Tuple, TypeVar, Callable
+from typing import Tuple, TypeVar, Callable, Mapping
 
 from sympy import (
     diff, Rational, Symbol, S, Mul, Add,
@@ -137,7 +137,7 @@ def nc_subs(expr, base_keys, base_values=None):
 
 
 _T = TypeVar('T')
-_U = TypeVar('T')
+_U = TypeVar('U')
 
 
 class GradedTuple(Tuple[Tuple[_T, ...], ...]):
@@ -170,6 +170,20 @@ def _map(self, func: Callable[[_T], _U]) -> 'GradedTuple[_U]':
         )
 
 
+class OrderedBiMap(OrderedDict, Mapping):
+    """ A dict with an ``.inverse`` attribute mapping in the other direction """
+    def __init__(self, items):
+        # set up the inverse mapping, bypassing our __init__
+        self.inverse = OrderedBiMap.__new__(type(self))
+
+        # populate both
+        OrderedDict.__init__(self, items)
+        OrderedDict.__init__(self.inverse, [(v, k) for k, v in items])
+
+        # and complete the inverse loop
+        self.inverse.inverse = self
+
+
 class Ga(metric.Metric):
     r"""
     The vector space (basis, metric, derivatives of basis vectors) is
@@ -245,21 +259,17 @@ class Ga(metric.Metric):
         Linear combination of coordinates and basis vectors.  For
         example in orthogonal 3D :math:`x*e_x+y*e_y+z*e_z`.
 
-    .. attribute:: blades_to_indexes_dict
-
-        Map basis blades to index tuples (dictionary).
-
     .. attribute:: indexes_to_blades_dict
 
-        Map index tuples to basis blades (dictionary).
-
-    .. attribute:: bases_to_indexes_dict
+        Bidirectional map from index tuples (:attr:`indices`) to basis blades (:attr:`blades`)
 
-        Map basis bases to index tuples (dictionary).
+        :type: OrderedBiMap[Tuple[int, ...], sympy.Symbol]
 
     .. attribute:: indexes_to_bases_dict
 
-        Map index tuples to basis bases (dictionary).
+        Bidirectional map from index tuples (:attr:`indices`) to basis bases (:attr:`bases`)
+
+        :type: OrderedBiMap[Tuple[int, ...], sympy.Symbol]
 
     .. rubric:: Multiplication tables data structures
 
@@ -830,13 +840,7 @@ def _build_bases(self):
         self.blades = self.indexes._map(
             lambda index: self._build_basis_blade_symbol(index))
 
-        self.blades_to_indexes = []
-        self.indexes_to_blades = []
-        for index, blade in zip(self.indexes.flat, self.blades.flat):
-            self.blades_to_indexes.append((blade, index))
-            self.indexes_to_blades.append((index, blade))
-        self.blades_to_indexes_dict = OrderedDict(self.blades_to_indexes)
-        self.indexes_to_blades_dict = OrderedDict(self.indexes_to_blades)
+        self.indexes_to_blades_dict = OrderedBiMap(list(zip(self.indexes.flat, self.blades.flat)))
 
         self.blades_to_grades_dict = {
             blade: igrade
@@ -848,13 +852,7 @@ def _build_bases(self):
             self.bases = self.indexes._map(
                 lambda index: self._build_basis_base_symbol(index))
 
-            self.bases_to_indexes = []
-            self.indexes_to_bases = []
-            for index, base in zip(self.indexes.flat, self.bases.flat):
-                self.bases_to_indexes.append((base, index))
-                self.indexes_to_bases.append((index, base))
-            self.bases_to_indexes_dict = OrderedDict(self.bases_to_indexes)
-            self.indexes_to_bases_dict = OrderedDict(self.indexes_to_bases)
+            self.indexes_to_bases_dict = OrderedBiMap(list(zip(self.indexes.flat, self.bases.flat)))
 
             self.bases_to_grades_dict = {
                 base: igrade
@@ -879,13 +877,11 @@ def _build_bases(self):
         if self.debug:
             printer.oprint('indexes', self.indexes, 'list(indexes)', self.indexes.flat,
                            'blades', self.blades, 'list(blades)', self.blades.flat,
-                           'blades_to_indexes_dict', self.blades_to_indexes_dict,
                            'indexes_to_blades_dict', self.indexes_to_blades_dict,
                            'blades_to_grades_dict', self.blades_to_grades_dict,
                            'blade_super_scripts', self.blade_super_scripts)
             if not self.is_ortho:
                 printer.oprint('bases', self.bases, 'list(bases)', self.bases.flat,
-                               'bases_to_indexes_dict', self.bases_to_indexes_dict,
                                'indexes_to_bases_dict', self.indexes_to_bases_dict,
                                'bases_to_grades_dict', self.bases_to_grades_dict)
 
@@ -897,6 +893,54 @@ def _build_bases(self):
             for obj in self.basis
         )
 
+    @property
+    def indexes_to_bases(self):
+        # galgebra 0.5.0
+        warnings.warn(
+            "`ga.indexes_to_bases` is deprecated, use `ga.indexes_to_bases_dict.items()`",
+            DeprecationWarning, stacklevel=2)
+        return self.indexes_to_bases_dict.items()
+
+    @property
+    def indexes_to_blades(self):
+        # galgebra 0.5.0
+        warnings.warn(
+            "`ga.indexes_to_blades` is deprecated, use `ga.indexes_to_blades_dict.items()`",
+            DeprecationWarning, stacklevel=2)
+        return self.indexes_to_blades_dict.items()
+
+    @property
+    def bases_to_indexes(self):
+        # galgebra 0.5.0
+        warnings.warn(
+            "`ga.bases_to_indexes` is deprecated, use `ga.indexes_to_bases_dict.inverse.items()`",
+            DeprecationWarning, stacklevel=2)
+        return self.indexes_to_bases_dict.inverse.items()
+
+    @property
+    def blades_to_indexes(self):
+        # galgebra 0.5.0
+        warnings.warn(
+            "`ga.blades_to_indexes` is deprecated, use `ga.indexes_to_blades_dict.inverse.items()`",
+            DeprecationWarning, stacklevel=2)
+        return self.indexes_to_blades_dict.inverse.items()
+
+    @property
+    def bases_to_indexes_dict(self):
+        # galgebra 0.5.0
+        warnings.warn(
+            "`ga.bases_to_indexes_dict` is deprecated, use `ga.indexes_to_bases_dict.inverse.`",
+            DeprecationWarning, stacklevel=2)
+        return self.indexes_to_bases_dict.inverse
+
+    @property
+    def blades_to_indexes_dict(self):
+        # galgebra 0.5.0
+        warnings.warn(
+            "`ga.blades_to_indexes_dict` is deprecated, use `ga.indexes_to_blades_dict.inverse`",
+            DeprecationWarning, stacklevel=2)
+        return self.indexes_to_blades_dict.inverse
+
     def _build_basis_product_tables(self):
         """
         For the different products of geometric algebra bases/blade
@@ -954,8 +998,8 @@ def geometric_product_basis_blades(self, blade12):
         # geometric (*) product for orthogonal basis
         if self.is_ortho:
             blade1, blade2 = blade12
-            index1 = self.blades_to_indexes_dict[blade1]
-            index2 = self.blades_to_indexes_dict[blade2]
+            index1 = self.indexes_to_blades_dict.inverse[blade1]
+            index2 = self.indexes_to_blades_dict.inverse[blade2]
             blade_index = list(index1 + index2)
             repeats = []
             sgn = 1
@@ -1137,8 +1181,8 @@ def wedge_product_basis_blades(self, blade12):  # blade12 = blade1*blade2
         # outer (^) product of basis blades
         # this method works for both orthogonal and non-orthogonal basis
         blade1, blade2 = blade12
-        index1 = self.blades_to_indexes_dict[blade1]
-        index2 = self.blades_to_indexes_dict[blade2]
+        index1 = self.indexes_to_blades_dict.inverse[blade1]
+        index2 = self.indexes_to_blades_dict.inverse[blade2]
         index12 = list(index1 + index2)
 
         if len(index12) > self.n:
@@ -1177,8 +1221,8 @@ def dot_product_basis_blades(self, blade12, mode):
         # dot (|), left (<), and right (>) products
         # dot product for orthogonal basis
         blade1, blade2 = blade12
-        index1 = self.blades_to_indexes_dict[blade1]
-        index2 = self.blades_to_indexes_dict[blade2]
+        index1 = self.indexes_to_blades_dict.inverse[blade1]
+        index2 = self.indexes_to_blades_dict.inverse[blade2]
         index = list(index1 + index2)
 
         grade = self._dot_product_grade(len(index1), len(index2), mode=mode)
@@ -1265,7 +1309,7 @@ def _build_non_orthogonal_mul_table(self):
     def non_orthogonal_bases_products(self, base12):  # base12 = (base1, base2)
         # geometric product of bases for non-orthogonal basis vectors
         base1, base2 = base12
-        index = self.bases_to_indexes_dict[base1] + self.bases_to_indexes_dict[base2]
+        index = self.indexes_to_bases_dict.inverse[base1] + self.indexes_to_bases_dict.inverse[base2]
 
         coefs, indexes = self.reduce_basis(index)
 
@@ -1281,7 +1325,7 @@ def _build_base_blade_conversions(self):
 
         # expand blade basis in terms of base basis
         for blade in self.blades.flat:
-            index = self.blades_to_indexes_dict[blade]
+            index = self.indexes_to_blades_dict.inverse[blade]
             grade = len(index)
             if grade <= 1:
                 blade_expansion.append(blade)
@@ -1766,7 +1810,7 @@ def blade_derivation(self, blade, ib):
         if key in self._dbases:
             return self._dbases[key]
 
-        index = self.blades_to_indexes_dict[blade]
+        index = self.indexes_to_blades_dict.inverse[blade]
         grade = len(index)
         if grade == 1:
             db = self.de[ib][index[0]]

galgebra/lt.py

@@ -277,7 +277,7 @@ def __call__(self, v, obj=False):
             self.mv_dict = copy(self.lt_dict)
             for key in self.Ga.blades[2:]:
                 for blade in key:
-                    index = self.Ga.blades_to_indexes_dict[blade]
+                    index = self.Ga.indexes_to_blades_dict.inverse[blade]
                     lt_blade = self(self.Ga.basis[index[0]], obj=True)
                     for i in index[1:]:
                         lt_blade = self.Ga.wedge(lt_blade, self(self.Ga.basis[i], obj=True))

test/test_test.py

@@ -435,3 +435,22 @@ def test_deprecations(self):
             assert ga.bases_lst[0] == e_1.obj
         with pytest.warns(DeprecationWarning):
             assert ga.indexes_lst[1] == (1,)
+
+        # deprecated to reduce the number of similar members
+        with pytest.warns(DeprecationWarning):
+            ga.blades_to_indexes
+        with pytest.warns(DeprecationWarning):
+            ga.bases_to_indexes
+        with pytest.warns(DeprecationWarning):
+            ga.blades_to_indexes_dict
+        with pytest.warns(DeprecationWarning):
+            ga.bases_to_indexes_dict
+        with pytest.warns(DeprecationWarning):
+            ga.indexes_to_blades
+        with pytest.warns(DeprecationWarning):
+            ga.indexes_to_bases
+
+        # all the above are deprecated in favor of these two, which are _not_
+        # deprecated
+        ga.indexes_to_blades_dict
+        ga.indexes_to_bases_dict