sagemathgh-39851: add pari algo for polynomial interpolation

Fixes sagemath#39833

### 📝 Checklist

- [x] The title is concise and informative.
- [ ] The description explains in detail what this PR is about.
- [x] I have linked a relevant issue or discussion.
- [x] I have created tests covering the changes.
- [x] I have updated the documentation and checked the documentation
preview.

URL: sagemath#39851
Reported by: Frédéric Chapoton
Reviewer(s):

Author: Release Manager

build/pkgs/configure/checksums.ini

@@ -1,3 +1,3 @@
 tarball=configure-VERSION.tar.gz
-sha1=3371667ee074aefdde8fc64ad60928a29a1e3578
-sha256=4e93801f29ba7d242285ed1461300586b50db56474e84cefe0b793f8dbf54842
+sha1=8a3ce3d350a3a750f562de1af26f07fce4dcef72
+sha256=fc8bedfe9af21649b0878294149f4c5d75b58e4d7c771893a29a00b4c73397a1

build/pkgs/configure/package-version.txt

@@ -1 +1 @@
-a2b47d65bcbe9d176b07208feb6aae513fc41244
+9d7288c7fba20f1d442ffb5bb4e24031473a8342

src/sage/rings/polynomial/polynomial_ring.py

@@ -2348,7 +2348,8 @@ def divided_difference(self, points, full_table=False):
         else:
             return [F[i][i] for i in range(n)]
 
-    def lagrange_polynomial(self, points, algorithm='divided_difference', previous_row=None):
+    def lagrange_polynomial(self, points, algorithm='divided_difference',
+                            previous_row=None):
         r"""
         Return the Lagrange interpolation polynomial through the
         given points.
@@ -2376,6 +2377,8 @@ def lagrange_polynomial(self, points, algorithm='divided_difference', previous_r
             table, instead of the full table itself.  Generating the
             full table can be memory inefficient.
 
+          - ``'pari'``: use Pari's function :pari:`polinterpolate`
+
         - ``previous_row`` -- (default: ``None``) this option is only
           relevant if used with ``algorithm='neville'``.  If provided,
           this should be the last row of the table resulting from a
@@ -2454,24 +2457,23 @@ def lagrange_polynomial(self, points, algorithm='divided_difference', previous_r
             ....:                       algorithm='neville', previous_row=p)[-1]
             a^2*x^2 + a^2*x + a^2
 
+        One can also use ``Pari``'s implementation::
+
+            sage: R = PolynomialRing(QQ, 'x')
+            sage: data = [(0,1), (2,5), (3,10)]
+            sage: p = R.lagrange_polynomial(data, algorithm='pari'); p
+            x^2 + 1
+
         TESTS:
 
         The value for ``algorithm`` must be either
-        ``'divided_difference'`` (default), or ``'neville'``::
+        ``'divided_difference'`` (default), ``'neville'`` or ``'pari'``::
 
             sage: R = PolynomialRing(QQ, 'x')
             sage: R.lagrange_polynomial([(0,1),(2,2),(3,-2),(-4,9)], algorithm='abc')
             Traceback (most recent call last):
             ...
-            ValueError: algorithm must be one of 'divided_difference' or 'neville'
-            sage: R.lagrange_polynomial([(0,1),(2,2),(3,-2),(-4,9)], algorithm='divided difference')
-            Traceback (most recent call last):
-            ...
-            ValueError: algorithm must be one of 'divided_difference' or 'neville'
-            sage: R.lagrange_polynomial([(0,1),(2,2),(3,-2),(-4,9)], algorithm='')
-            Traceback (most recent call last):
-            ...
-            ValueError: algorithm must be one of 'divided_difference' or 'neville'
+            ValueError: algorithm can be 'divided_difference', 'neville' or 'pari'
 
         Make sure that :issue:`10304` is fixed.  The return value
         should always be an element of ``self`` in the case of
@@ -2556,24 +2558,13 @@ def lagrange_polynomial(self, points, algorithm='divided_difference', previous_r
                 P, Q = Q, P # the current row is complete, reuse the old P to hold the next row
             return P # return the last row in the Neville table
 
-#        # use the definition of Lagrange interpolation polynomial
-#        elif algorithm == "definition":
-#            def Pj(j):
-#                denom = 1
-#                divis = 1
-#                for i in range(len(points)):
-#                    if i!=j:
-#                        denom *= (var          - points[i][0])
-#                        divis *= (points[j][0] - points[i][0])
-#            return denom/divis
-#
-#            P = 0
-#            for j in range(len(points)):
-#                P += Pj(j)*points[j][1]
-#            return P
+        elif algorithm == "pari":
+            from sage.libs.pari import pari
+            positions = pari([a for a, b in points])
+            values = pari([b for a, b in points])
+            return self(pari.polinterpolate(positions, values))
 
-        else:
-            raise ValueError("algorithm must be one of 'divided_difference' or 'neville'")
+        raise ValueError("algorithm can be 'divided_difference', 'neville' or 'pari'")
 
     @cached_method
     def fraction_field(self):