Add gr_derivative, with implementations for polynomial rings

doc/source/gr.rst

@@ -739,6 +739,14 @@ Powering
     should override these methods with faster versions or
     to support more general notions of exponentiation when possible.
 
+Derivative
+........................................................................
+
+.. function:: int gr_derivative(gr_ptr res, gr_srcptr x, slong var, gr_ctx_t ctx)
+
+    Sets *res* to the derivative of *x* with respect to the variable of index *var*.
+    The variables here are the generators of *ctx*.
+
 Square roots
 ........................................................................
 

src/gr.h

@@ -265,6 +265,8 @@ typedef enum
     GR_METHOD_POW_OTHER,
     GR_METHOD_OTHER_POW,
 
+    GR_METHOD_DERIVATIVE,
+
     GR_METHOD_IS_SQUARE,
     GR_METHOD_SQRT,
     GR_METHOD_RSQRT,
@@ -1130,6 +1132,8 @@ GR_INLINE WARN_UNUSED_RESULT int gr_pow_fmpq(gr_ptr res, gr_srcptr x, const fmpq
 GR_INLINE WARN_UNUSED_RESULT int gr_pow_other(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_ctx_t y_ctx, gr_ctx_t ctx) { return GR_BINARY_OP_OTHER(ctx, POW_OTHER)(res, x, y, y_ctx, ctx); }
 GR_INLINE WARN_UNUSED_RESULT int gr_other_pow(gr_ptr res, gr_srcptr x, gr_ctx_t x_ctx, gr_srcptr y, gr_ctx_t ctx) { return GR_OTHER_BINARY_OP(ctx, OTHER_POW)(res, x, x_ctx, y, ctx); }
 
+GR_INLINE WARN_UNUSED_RESULT int gr_derivative(gr_ptr res, gr_srcptr x, slong var, gr_ctx_t ctx) { return GR_BINARY_OP_SI(ctx, DERIVATIVE)(res, x, var, ctx); }
+
 GR_INLINE WARN_UNUSED_RESULT int gr_sqrt(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) { return GR_UNARY_OP(ctx, SQRT)(res, x, ctx); }
 GR_INLINE WARN_UNUSED_RESULT int gr_rsqrt(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) { return GR_UNARY_OP(ctx, RSQRT)(res, x, ctx); }
 GR_INLINE truth_t gr_is_square(gr_srcptr x, gr_ctx_t ctx) { return GR_UNARY_PREDICATE(ctx, IS_SQUARE)(x, ctx); }

src/gr/fmpq_poly.c

@@ -639,6 +639,17 @@ _gr_fmpq_poly_pow_fmpz(fmpq_poly_t res, const fmpq_poly_t x, const fmpz_t exp, g
     }
 }
 
+int
+_gr_fmpq_poly_derivative(fmpq_poly_t res, const fmpq_poly_t x, slong var, const gr_ctx_t ctx)
+{
+    if (var == 0)
+    {
+        fmpq_poly_derivative(res, x);
+        return GR_SUCCESS;
+    }
+    return GR_DOMAIN;
+}
+
 int
 _gr_fmpq_poly_numerator(fmpq_poly_t res, const fmpq_poly_t x, const gr_ctx_t ctx)
 {
@@ -799,6 +810,7 @@ gr_method_tab_input _fmpq_poly_methods_input[] =
     {GR_METHOD_POW_UI,          (gr_funcptr) _gr_fmpq_poly_pow_ui},
     {GR_METHOD_POW_SI,          (gr_funcptr) _gr_fmpq_poly_pow_si},
     {GR_METHOD_POW_FMPZ,        (gr_funcptr) _gr_fmpq_poly_pow_fmpz},
+    {GR_METHOD_DERIVATIVE,      (gr_funcptr) _gr_fmpq_poly_derivative},
     {GR_METHOD_NUMERATOR,       (gr_funcptr) _gr_fmpq_poly_numerator},
     {GR_METHOD_DENOMINATOR,     (gr_funcptr) _gr_fmpq_poly_denominator},
     {GR_METHOD_CANONICAL_ASSOCIATE,  (gr_funcptr) _gr_fmpq_poly_canonical_associate},

src/gr/fmpz_mpoly.c

@@ -492,6 +492,17 @@ _gr_fmpz_mpoly_pow_fmpz(fmpz_mpoly_t res, const fmpz_mpoly_t poly1, const fmpz_t
         return GR_UNABLE;
 }
 
+int
+_gr_fmpz_mpoly_derivative(fmpz_mpoly_t res, const fmpz_mpoly_t poly, slong var, gr_ctx_t ctx)
+{
+    if (var >= 0 && var < MPOLYNOMIAL_MCTX(ctx)->minfo->nvars)
+    {
+        fmpz_mpoly_derivative(res, poly, var, MPOLYNOMIAL_MCTX(ctx));
+        return GR_SUCCESS;
+    }
+    return GR_DOMAIN;
+}
+
 truth_t
 _gr_fmpz_mpoly_is_square(const fmpz_mpoly_t poly, gr_ctx_t ctx)
 {
@@ -643,6 +654,7 @@ gr_method_tab_input _gr_fmpz_mpoly_methods_input[] =
     {GR_METHOD_IS_INVERTIBLE,   (gr_funcptr) _gr_fmpz_mpoly_is_invertible},
     {GR_METHOD_POW_UI,      (gr_funcptr) _gr_fmpz_mpoly_pow_ui},
     {GR_METHOD_POW_FMPZ,    (gr_funcptr) _gr_fmpz_mpoly_pow_fmpz},
+    {GR_METHOD_DERIVATIVE,  (gr_funcptr) _gr_fmpz_mpoly_derivative},
     {GR_METHOD_SQRT,        (gr_funcptr) _gr_fmpz_mpoly_sqrt},
     {GR_METHOD_IS_SQUARE,   (gr_funcptr) _gr_fmpz_mpoly_is_square},
     {GR_METHOD_CANONICAL_ASSOCIATE,   (gr_funcptr) _gr_fmpz_mpoly_canonical_associate},

src/gr/fmpz_poly.c

@@ -707,6 +707,17 @@ _gr_fmpz_poly_pow_fmpz(fmpz_poly_t res, const fmpz_poly_t x, const fmpz_t exp, c
     }
 }
 
+int
+_gr_fmpz_poly_derivative(fmpz_poly_t res, const fmpz_poly_t x, slong var, const gr_ctx_t ctx)
+{
+    if (var == 0)
+    {
+        fmpz_poly_derivative(res, x);
+        return GR_SUCCESS;
+    }
+    return GR_DOMAIN;
+}
+
 truth_t
 _gr_fmpz_poly_is_square(const fmpz_poly_t x, const gr_ctx_t ctx)
 {
@@ -904,6 +915,7 @@ gr_method_tab_input _fmpz_poly_methods_input[] =
     {GR_METHOD_POW_UI,          (gr_funcptr) _gr_fmpz_poly_pow_ui},
     {GR_METHOD_POW_SI,          (gr_funcptr) _gr_fmpz_poly_pow_si},
     {GR_METHOD_POW_FMPZ,        (gr_funcptr) _gr_fmpz_poly_pow_fmpz},
+    {GR_METHOD_DERIVATIVE,      (gr_funcptr) _gr_fmpz_poly_derivative},
     {GR_METHOD_IS_SQUARE,       (gr_funcptr) _gr_fmpz_poly_is_square},
     {GR_METHOD_SQRT,            (gr_funcptr) _gr_fmpz_poly_sqrt},
     {GR_METHOD_RSQRT,           (gr_funcptr) _gr_fmpz_poly_rsqrt},

src/gr/polynomial.c

@@ -669,6 +669,12 @@ polynomial_pow_si(gr_poly_t res, const gr_poly_t poly, slong exp, gr_ctx_t ctx)
     return status;
 }
 
+int
+polynomial_derivative(gr_poly_t res, const gr_poly_t poly, slong var, gr_ctx_t ctx)
+{
+    return (var == 0) ? gr_poly_derivative(res, poly, POLYNOMIAL_ELEM_CTX(ctx)) : GR_DOMAIN;
+}
+
 int
 polynomial_gcd(gr_poly_t res, const gr_poly_t x, const gr_poly_t y, const gr_ctx_t ctx)
 {
@@ -808,6 +814,8 @@ gr_method_tab_input _gr_poly_methods_input[] =
     {GR_METHOD_DIVEXACT,    (gr_funcptr) polynomial_divexact},
     {GR_METHOD_INV,         (gr_funcptr) polynomial_inv},
 
+    {GR_METHOD_DERIVATIVE,  (gr_funcptr) polynomial_derivative},
+
     {GR_METHOD_EUCLIDEAN_DIV,         (gr_funcptr) polynomial_euclidean_div},
     {GR_METHOD_EUCLIDEAN_REM,         (gr_funcptr) polynomial_euclidean_rem},
     {GR_METHOD_EUCLIDEAN_DIVREM,      (gr_funcptr) polynomial_euclidean_divrem},

src/gr_generic/generic.c

@@ -1268,6 +1268,11 @@ int gr_generic_other_pow(gr_ptr res, gr_srcptr x, gr_ctx_t x_ctx, gr_srcptr y, g
     return status;
 }
 
+int gr_generic_derivative(gr_ptr res, gr_srcptr x, slong var, gr_ctx_t ctx)
+{
+    return GR_UNABLE;
+}
+
 int gr_generic_numerator(gr_ptr res, gr_srcptr x, gr_ctx_t ctx)
 {
     return gr_set(res, x, ctx);
@@ -2794,6 +2799,8 @@ const gr_method_tab_input _gr_generic_methods[] =
     {GR_METHOD_POW_FMPQ,                (gr_funcptr) gr_generic_pow_fmpq},
     {GR_METHOD_OTHER_POW,               (gr_funcptr) gr_generic_other_pow},
 
+    {GR_METHOD_DERIVATIVE,              (gr_funcptr) gr_generic_derivative},
+
     {GR_METHOD_IS_SQUARE,               (gr_funcptr) gr_generic_is_square},
     {GR_METHOD_SQRT,                    (gr_funcptr) gr_generic_sqrt},
     {GR_METHOD_RSQRT,                   (gr_funcptr) gr_generic_rsqrt},

src/gr_mpoly/ctx.c

@@ -355,6 +355,7 @@ gr_method_tab_input _gr_mpoly_methods_input[] =
     {GR_METHOD_MUL_FMPQ,    (gr_funcptr) gr_mpoly_mul_fmpq},
     {GR_METHOD_INV,         (gr_funcptr) gr_mpoly_inv},
     {GR_METHOD_CANONICAL_ASSOCIATE,         (gr_funcptr) gr_mpoly_canonical_associate},
+    {GR_METHOD_DERIVATIVE,  (gr_funcptr) gr_mpoly_derivative},
     {0,                     (gr_funcptr) NULL},
 };