Merge pull request #80 from eric-wieser/strict-positional-mv-args

Raise TypeError for bad arguments to `Mv`

Author: eric-wieser

galgebra/mv.py

@@ -165,13 +165,18 @@ def characterise_Mv(self):
     # helper methods called by __init__. Note that these names must not change,
     # as the part of the name after `_make_` is public API via the string
     # argument passed to __init__.
+    #
+    # The double underscores in argument names are to force the passing
+    # positionally. When python 3.8 is the lowest supported version, we can
+    # switch to using the / syntax from PEP570
 
     @staticmethod
-    def _make_grade(ga, *args, **kwargs):
+    def _make_grade(ga, __name_or_coeffs, __grade, **kwargs):
         """ Make a pure grade multivector. """
-        grade = args[1]
-        if utils.isstr(args[0]):
-            root = args[0] + '__'
+        grade = __grade
+        if utils.isstr(__name_or_coeffs):
+            name = __name_or_coeffs
+            root = name + '__'
             if isinstance(kwargs['f'], bool) and not kwargs['f']:  #Is a constant mulitvector function
                 return sum([Symbol(root + super_script, real=True) * base
                                 for (super_script, base) in zip(ga.blade_super_scripts[grade], ga.blades[grade])])
@@ -183,69 +188,72 @@ def _make_grade(ga, *args, **kwargs):
                 else: #Is a multivector function of tuple kwargs['f'] variables
                     return sum([Function(root + super_script, real=True)(*kwargs['f']) * base
                         for (super_script, base) in zip(ga.blade_super_scripts[grade], ga.blades[grade])])
-        elif isinstance(args[0],(list,tuple)):
-            if len(args[0]) <= len(ga.blades[grade]):
+        elif isinstance(__name_or_coeffs, (list, tuple)):
+            coeffs = __name_or_coeffs
+            if len(coeffs) <= len(ga.blades[grade]):
                 return sum([coef * base
-                    for (coef, base) in zip(args[0], ga.blades[grade][:len(args[0])])])
+                    for (coef, base) in zip(coeffs, ga.blades[grade][:len(coeffs)])])
             else:
                 raise ValueError("Too many coefficients")
         else:
             raise TypeError("Expected a string, list, or tuple")
 
     @staticmethod
-    def _make_scalar(ga, *args, **kwargs):
+    def _make_scalar(ga, __name_or_value, **kwargs):
         """ Make a scalar multivector """
-        if utils.isstr(args[0]):
+        if utils.isstr(__name_or_value):
+            name = __name_or_value
             if 'f' in kwargs and isinstance(kwargs['f'],bool):
                 if kwargs['f']:
-                    return Function(args[0])(*ga.coords)
+                    return Function(name)(*ga.coords)
                 else:
-                    return Symbol(args[0], real=True)
+                    return Symbol(name, real=True)
             else:
                 if 'f' in kwargs and isinstance(kwargs['f'],tuple):
-                    return Function(args[0])(*kwargs['f'])
+                    return Function(name)(*kwargs['f'])
         else:
-            return args[0]
+            value = __name_or_value
+            return value
 
     @staticmethod
-    def _make_vector(ga, *args, **kwargs):
+    def _make_vector(ga, __name_or_coeffs, **kwargs):
         """ Make a vector multivector """
-        return Mv._make_grade(ga, args[0], 1, **kwargs)
+        return Mv._make_grade(ga, __name_or_coeffs, 1, **kwargs)
 
     @staticmethod
-    def _make_bivector(ga, *args, **kwargs):
+    def _make_bivector(ga, __name_or_coeffs, **kwargs):
         """ Make a bivector multivector """
-        return Mv._make_grade(ga, args[0], 2, **kwargs)
+        return Mv._make_grade(ga, __name_or_coeffs, 2, **kwargs)
 
     @staticmethod
-    def _make_pseudo(ga, *args, **kwargs):
+    def _make_pseudo(ga, __name_or_coeffs, **kwargs):
         """ Make a pseudo scalar multivector """
-        return Mv._make_grade(ga, args[0], ga.n, **kwargs)
+        return Mv._make_grade(ga, __name_or_coeffs, ga.n, **kwargs)
 
     @staticmethod
-    def _make_mv(ga, *args, **kwargs):
+    def _make_mv(ga, __name, **kwargs):
         """ Make a general (2**n components) multivector """
-        tmp = Mv._make_scalar(ga, args[0], **kwargs)
+        tmp = Mv._make_scalar(ga, __name, **kwargs)
         for grade in ga.n_range:
-            tmp += Mv._make_grade(ga, args[0], grade + 1, **kwargs)
+            tmp += Mv._make_grade(ga, __name, grade + 1, **kwargs)
         return tmp
 
     @staticmethod
-    def _make_spinor(ga, *args, **kwargs):
+    def _make_spinor(ga, __name, **kwargs):
         """ Make a general even (spinor) multivector """
-        tmp = Mv._make_scalar(ga, args[0], **kwargs)
+        tmp = Mv._make_scalar(ga, __name, **kwargs)
         for grade in ga.n_range:
             if (grade + 1) % 2 == 0:
-                tmp += Mv._make_grade(ga, args[0], grade + 1, **kwargs)
+                tmp += Mv._make_grade(ga, __name, grade + 1, **kwargs)
         return tmp
 
     @staticmethod
-    def _make_odd(ga, *args, **kwargs):
+    def _make_odd(ga, __name_or_coeffs, **kwargs):
         """ Make a general odd multivector """
         tmp = S(0)
         for grade in ga.n_range:
             if (grade + 1) % 2 == 1:
-                tmp += Mv._make_grade(args[0], grade + 1, **kwargs)
+                tmp += Mv._make_grade(ga, __name_or_coeffs, grade + 1, **kwargs)
         return tmp
 
     # aliases
@@ -289,15 +297,18 @@ def __init__(self, *args, **kwargs):
                 self.characterise_Mv()
         else:
             if utils.isstr(args[1]):
-                args = list(args)
-                mode = args.pop(1)
+                make_args = list(args)
+                mode = make_args.pop(1)
                 make_func = getattr(Mv, '_make_{}'.format(mode), None)
                 if make_func is None:
                     raise ValueError('{!r} is not an allowed multivector type.'.format(mode))
-                self.obj = make_func(self.Ga, *args, **kwargs)
+                self.obj = make_func(self.Ga, *make_args, **kwargs)
             elif isinstance(args[1], int):  # args[1] = r (integer) Construct grade r multivector
                 if args[1] == 0:
-                    self.obj = Mv._make_scalar(self.Ga, *args, **kwargs)
+                    # make_grade does not work for scalars (gh-82)
+                    make_args = list(args)
+                    make_args.pop(1)
+                    self.obj = Mv._make_scalar(self.Ga, *make_args, **kwargs)
                 else:
                     self.obj = Mv._make_grade(self.Ga, *args, **kwargs)
             else:

test/test_mv.py

@@ -84,3 +84,27 @@ def test_rep_switching(self):
         self.assertFalse(m0_base.is_blade_rep)  # original should not change
         self.assertTrue(m0_base_blade.is_blade_rep)
         self.assertEqual(m0, m0_base_blade)
+
+    def test_construction(self):
+        (ga, e_1, e_2, e_3) = Ga.build('e*1|2|3')
+
+        # non-function symbol construction
+        self.assertEqual(ga.mv('A', 'scalar').grades, [0])
+        self.assertEqual(ga.mv('A', 0).grades, [0])
+        self.assertEqual(ga.mv('A', 'vector').grades, [1])
+        self.assertEqual(ga.mv('A', 'grade', 1).grades, [1])
+        self.assertEqual(ga.mv('A', 1).grades, [1])
+        self.assertEqual(ga.mv('A', 'bivector').grades, [2])
+        self.assertEqual(ga.mv('A', 'grade2').grades, [2])
+        self.assertEqual(ga.mv('A', 2).grades, [2])
+        self.assertEqual(ga.mv('A', 'pseudo').grades, [3])
+        self.assertEqual(ga.mv('A', 'spinor').grades, [0, 2])
+        self.assertEqual(ga.mv('A', 'even').grades, [0, 2])
+        self.assertEqual(ga.mv('A', 'odd').grades, [1, 3])
+        self.assertEqual(ga.mv('A', 'mv').grades, [0, 1, 2, 3])
+
+        # illegal arguments
+        with self.assertRaises(TypeError):
+            ga.mv('A', 'vector', "too many arguments")
+        with self.assertRaises(TypeError):
+            ga.mv('A', 'grade')  # too few arguments