Make all GP functions available as methods of Pari class

Author: jdemeyer

autogen/args.py

@@ -191,6 +191,13 @@ def convert_code(self):
         elif self.default is None:
             s  = "        {name} = objtogen({name})\n"
             s += "        cdef GEN {tmp} = (<Gen>{name}).g\n"
+        elif self.default is False:
+            # This is actually a required argument
+            # See parse_prototype() in parser.py why we need this
+            s  = "        if {name} is None:\n"
+            s += "            raise TypeError(\"missing required argument: '{name}'\")\n"
+            s += "        {name} = objtogen({name})\n"
+            s += "        cdef GEN {tmp} = (<Gen>{name}).g\n"
         elif self.default == "NULL":
             s  = "        cdef GEN {tmp} = {default}\n"
             s += "        if {name} is not None:\n"

autogen/generator.py

@@ -190,20 +190,19 @@ def bernvec(self, long x):
         except NotImplementedError:
             return  # Skip unsupported prototype codes
 
-        # Is the first argument a GEN?
+        doc = get_rest_doc(function)
+
         if len(args) > 0 and isinstance(args[0], PariArgumentGEN):
-            # If yes, write a method of the Gen class.
-            cargs = args
-            f = self.gen_file
-        else:
-            # If no, write a method of the Pari class.
-            # Parse again with an extra "self" argument.
-            args, ret = parse_prototype(prototype, help, [PariInstanceArgument()])
-            cargs = args[1:]
-            f = self.instance_file
-
-        self.write_method(function, cname, args, ret, cargs, f,
-                get_rest_doc(function), obsolete)
+            # If the first argument is a GEN, write a method of the
+            # Gen class.
+            self.write_method(function, cname, args, ret, args,
+                    self.gen_file, doc, obsolete)
+
+        # In any case, write a method of the Pari class.
+        # Parse again with an extra "self" argument.
+        args, ret = parse_prototype(prototype, help, [PariInstanceArgument()])
+        self.write_method(function, cname, args, ret, args[1:],
+                self.instance_file, doc, obsolete)
 
     def write_method(self, function, cname, args, ret, cargs, file, doc, obsolete):
         """

autogen/parser.py

@@ -156,7 +156,7 @@ def parse_prototype(proto, help, initial_args=[]):
 
     # Go over the prototype characters and build up the arguments
     args = list(initial_args)
-    default = None
+    have_default = False  # Have we seen any default argument?
     while n < len(proto):
         c = proto[n]; n += 1
 
@@ -184,6 +184,25 @@ def parse_prototype(proto, help, initial_args=[]):
                 raise ValueError('unknown prototype character %r' % c)
 
         arg = t(names, default, index=len(args))
+        if arg.default is not None:
+            have_default = True
+        elif have_default:
+            # We have a non-default argument following a default
+            # argument, which means trouble...
+            #
+            # A syntactical wart of Python is that it does not allow
+            # that: something like def foo(x=None, y) is a SyntaxError
+            # (at least with Python-2.7.13, Python-3.6.1 and Cython-0.25.2)
+            #
+            # A small number of GP functions (nfroots() for example)
+            # wants to do this anyway. Luckily, this seems to occur only
+            # for arguments of type GEN (prototype code "G")
+            #
+            # To work around this, we add a "fake" default value and
+            # then raise an error if it was not given...
+            if c != "G":
+                raise NotImplementedError("non-default argument after default argument is only implemented for GEN arguments")
+            arg.default = False
         args.append(arg)
 
     return (args, ret)

cypari2/pari_instance.pyx

@@ -41,14 +41,24 @@ Examples:
 (120*x + 10)/x
 >>> pari('intnum(x=0,13,sin(x)+sin(x^2) + x)')
 85.6215190762676
->>> f = pari('x^3-1')
+>>> f = pari('x^3 - 1')
 >>> v = f.factor(); v
 [x - 1, 1; x^2 + x + 1, 1]
 >>> v[0]   # indexing is 0-based unlike in GP.
 [x - 1, x^2 + x + 1]~
 >>> v[1]
 [1, 1]~
 
+For most functions, you can call the function as method of ``pari``
+or you can first create a :class:`Gen` object and then call the
+function as method of that. In other words, the following two commands
+do the same:
+
+>>> pari('x^3 - 1').factor()
+[x - 1, 1; x^2 + x + 1, 1]
+>>> pari.factor('x^3 - 1')
+[x - 1, 1; x^2 + x + 1, 1]
+
 Arithmetic operations cause all arguments to be converted to PARI:
 
 >>> type(pari(1) + 1)
@@ -221,6 +231,14 @@ Python (:trac:`9636`):
 >>> pari('print("test")')
 test
 
+Verify that ``nfroots()`` (which has an unusual signature with a
+non-default argument following a default argument) works:
+
+>>> pari.nfroots(x='x^4 - 1')
+[-1, 1]
+>>> pari.nfroots(pari.nfinit('t^2 + 1'), "x^4 - 1")
+[-1, 1, Mod(-t, t^2 + 1), Mod(t, t^2 + 1)]
+
 """
 
 #*****************************************************************************