access to generator names

doc/source/gr.rst

@@ -278,6 +278,15 @@ Context operations
     The name is used when printing and may be used to choose
     coercions.
 
+.. function:: int gr_ctx_ngens(slong * ngens, gr_ctx_t ctx)
+
+    Get the number of generators.
+
+.. function:: int gr_ctx_gen_name(char ** name, slong i, gr_ctx_t ctx)
+
+    Get the name of the generator of index *i*.
+    The returned buffer must be freed with :func:`flint_free`.
+
 Element operations
 --------------------------------------------------------------------------------
 

src/gr.h

@@ -133,6 +133,8 @@ typedef enum
     GR_METHOD_CTX_SET_IS_FIELD,
     GR_METHOD_CTX_SET_GEN_NAME,
     GR_METHOD_CTX_SET_GEN_NAMES,
+    GR_METHOD_CTX_NGENS,
+    GR_METHOD_CTX_GEN_NAME,
 
     GR_METHOD_INIT,
     GR_METHOD_CLEAR,
@@ -748,6 +750,8 @@ typedef void ((*gr_method_swap_op)(gr_ptr, gr_ptr, gr_ctx_ptr));
 typedef int ((*gr_method_ctx)(gr_ctx_ptr));
 typedef void ((*gr_method_ctx_void_op)(gr_ctx_ptr));
 typedef truth_t ((*gr_method_ctx_predicate)(gr_ctx_ptr));
+typedef slong ((*gr_method_ctx_size)(gr_ctx_ptr));
+typedef int ((*gr_method_ctx_gen_name)(char **, slong, gr_ctx_ptr));
 typedef int ((*gr_method_ctx_set_si)(gr_ctx_ptr, slong));
 typedef int ((*gr_method_ctx_get_si)(slong *, gr_ctx_ptr));
 typedef int ((*gr_method_ctx_set_truth)(gr_ctx_ptr, truth_t));
@@ -847,6 +851,8 @@ typedef int ((*gr_method_set_fexpr_op)(gr_ptr, fexpr_vec_t, gr_vec_t, const fexp
 #define GR_CTX_VOID_OP(ctx, NAME) (((gr_method_ctx_void_op *) ctx->methods)[GR_METHOD_ ## NAME])
 #define GR_CTX_STREAM(ctx, NAME) (((gr_method_ctx_stream *) ctx->methods)[GR_METHOD_ ## NAME])
 #define GR_CTX_PREDICATE(ctx, NAME) (((gr_method_ctx_predicate *) ctx->methods)[GR_METHOD_ ## NAME])
+#define GR_CTX_SIZE(ctx, NAME) (((gr_method_ctx_size *) ctx->methods)[GR_METHOD_ ## NAME])
+#define GR_CTX_GEN_NAME(ctx, NAME) (((gr_method_ctx_gen_name *) ctx->methods)[GR_METHOD_ ## NAME])
 #define GR_CTX_SET_SI(ctx, NAME) (((gr_method_ctx_set_si *) ctx->methods)[GR_METHOD_ ## NAME])
 #define GR_CTX_GET_SI(ctx, NAME) (((gr_method_ctx_get_si *) ctx->methods)[GR_METHOD_ ## NAME])
 #define GR_CTX_SET_TRUTH(ctx, NAME) (((gr_method_ctx_set_truth *) ctx->methods)[GR_METHOD_ ## NAME])
@@ -975,6 +981,8 @@ GR_INLINE WARN_UNUSED_RESULT int gr_ctx_get_real_prec(slong * prec, gr_ctx_t ctx
 GR_INLINE WARN_UNUSED_RESULT int gr_ctx_set_is_field(gr_ctx_t ctx, truth_t is_field) { return GR_CTX_SET_TRUTH(ctx, CTX_SET_IS_FIELD)(ctx, is_field); }
 GR_INLINE WARN_UNUSED_RESULT int gr_ctx_set_gen_name(gr_ctx_t ctx, const char * s) { return GR_CTX_SET_STR(ctx, CTX_SET_GEN_NAME)(ctx, s); }
 GR_INLINE WARN_UNUSED_RESULT int gr_ctx_set_gen_names(gr_ctx_t ctx, const char ** s) { return GR_CTX_SET_STRS(ctx, CTX_SET_GEN_NAMES)(ctx, s); }
+GR_INLINE int gr_ctx_ngens(slong * ngens, gr_ctx_t ctx) { return GR_CTX_GET_SI(ctx, CTX_NGENS)(ngens, ctx); }
+GR_INLINE int gr_ctx_gen_name(char ** name, slong i, gr_ctx_t ctx) { return GR_CTX_GEN_NAME(ctx, CTX_GEN_NAME)(name, i, ctx); }
 
 GR_INLINE slong _gr_ctx_get_real_prec(gr_ctx_t ctx)
 {

src/gr/fmpq_poly.c

@@ -50,6 +50,8 @@ int _gr_fmpq_poly_ctx_set_gen_names(gr_ctx_t ctx, const char ** s)
     return _gr_fmpq_poly_ctx_set_gen_name(ctx, s[0]);
 }
 
+int _gr_gr_poly_ctx_gen_name(char ** name, slong i, gr_ctx_t ctx);
+#define _gr_fmpq_poly_ctx_gen_name _gr_gr_poly_ctx_gen_name
 
 int
 _gr_fmpq_poly_ctx_write(gr_stream_t out, gr_ctx_t ctx)
@@ -738,6 +740,8 @@ gr_method_tab_input _fmpq_poly_methods_input[] =
 
     {GR_METHOD_CTX_SET_GEN_NAME,  (gr_funcptr) _gr_fmpq_poly_ctx_set_gen_name},
     {GR_METHOD_CTX_SET_GEN_NAMES, (gr_funcptr) _gr_fmpq_poly_ctx_set_gen_names},
+    {GR_METHOD_CTX_NGENS,       (gr_funcptr) gr_generic_ctx_ngens_1},
+    {GR_METHOD_CTX_GEN_NAME,    (gr_funcptr) _gr_fmpq_poly_ctx_gen_name},
     {GR_METHOD_INIT,            (gr_funcptr) _gr_fmpq_poly_init},
     {GR_METHOD_CLEAR,           (gr_funcptr) _gr_fmpq_poly_clear},
     {GR_METHOD_SWAP,            (gr_funcptr) _gr_fmpq_poly_swap},

src/gr/fmpz_mod_mpoly_q.c

@@ -85,6 +85,33 @@ _gr_fmpz_mod_mpoly_q_ctx_set_gen_names(gr_ctx_t ctx, const char ** s)
 
     return GR_SUCCESS;
 }
+
+slong
+_gr_fmpz_mod_mpoly_q_ctx_ngens(slong * ngens, gr_ctx_t ctx)
+{
+    * ngens = MPOLYNOMIAL_MCTX(ctx)->minfo->nvars;
+    return GR_SUCCESS;
+}
+
+int
+_gr_fmpz_mod_mpoly_q_ctx_gen_name(char ** name, slong i, gr_ctx_t ctx)
+{
+    if (i < 0 || i >= MPOLYNOMIAL_MCTX(ctx)->minfo->nvars)
+        return GR_DOMAIN;
+
+    if (MPOLYNOMIAL_CTX(ctx)->vars == NULL)
+        return GR_UNABLE;
+
+    char * var = MPOLYNOMIAL_CTX(ctx)->vars[i];
+    size_t len = strlen(var);
+    * name = flint_malloc(len + 1);
+    if (* name == NULL)
+        return GR_UNABLE;
+    strncpy(* name, var, len + 1);
+
+    return GR_SUCCESS;
+}
+
 void
 _gr_fmpz_mod_mpoly_q_init(fmpz_mod_mpoly_q_t res, gr_ctx_t ctx)
 {
@@ -444,6 +471,8 @@ gr_method_tab_input _gr_fmpz_mod_mpoly_q_methods_input[] =
     {GR_METHOD_CTX_IS_FINITE_CHARACTERISTIC,    (gr_funcptr) gr_generic_ctx_predicate_true},
     {GR_METHOD_CTX_IS_THREADSAFE,               (gr_funcptr) gr_generic_ctx_predicate_true},
     {GR_METHOD_CTX_SET_GEN_NAMES,               (gr_funcptr) _gr_fmpz_mod_mpoly_q_ctx_set_gen_names},
+    {GR_METHOD_CTX_NGENS,   (gr_funcptr) _gr_fmpz_mod_mpoly_q_ctx_ngens},
+    {GR_METHOD_CTX_GEN_NAME, (gr_funcptr) _gr_fmpz_mod_mpoly_q_ctx_gen_name},
     {GR_METHOD_INIT,        (gr_funcptr) _gr_fmpz_mod_mpoly_q_init},
     {GR_METHOD_CLEAR,       (gr_funcptr) _gr_fmpz_mod_mpoly_q_clear},
     {GR_METHOD_SWAP,        (gr_funcptr) _gr_fmpz_mod_mpoly_q_swap},

src/gr/fmpz_mpoly.c

@@ -85,6 +85,32 @@ _gr_fmpz_mpoly_ctx_set_gen_names(gr_ctx_t ctx, const char ** s)
     return GR_SUCCESS;
 }
 
+slong
+_gr_fmpz_mpoly_ctx_ngens(slong * ngens, gr_ctx_t ctx)
+{
+    * ngens = MPOLYNOMIAL_MCTX(ctx)->minfo->nvars;
+    return GR_SUCCESS;
+}
+
+int
+_gr_fmpz_mpoly_ctx_gen_name(char ** name, slong i, gr_ctx_t ctx)
+{
+    if (i < 0 || i >= MPOLYNOMIAL_MCTX(ctx)->minfo->nvars)
+        return GR_DOMAIN;
+
+    if (MPOLYNOMIAL_CTX(ctx)->vars == NULL)
+        return GR_UNABLE;
+
+    char * var = MPOLYNOMIAL_CTX(ctx)->vars[i];
+    size_t len = strlen(var);
+    * name = flint_malloc(len + 1);
+    if (* name == NULL)
+        return GR_UNABLE;
+    strncpy(* name, var, len + 1);
+
+    return GR_SUCCESS;
+}
+
 void
 _gr_fmpz_mpoly_init(fmpz_mpoly_t res, gr_ctx_t ctx)
 {
@@ -572,6 +598,8 @@ gr_method_tab_input _gr_fmpz_mpoly_methods_input[] =
     {GR_METHOD_CTX_IS_COMPLEX_VECTOR_SPACE, (gr_funcptr) gr_generic_ctx_predicate_false},
     {GR_METHOD_CTX_IS_THREADSAFE,               (gr_funcptr) gr_generic_ctx_predicate_true},
     {GR_METHOD_CTX_SET_GEN_NAMES,               (gr_funcptr) _gr_fmpz_mpoly_ctx_set_gen_names},
+    {GR_METHOD_CTX_NGENS,   (gr_funcptr) _gr_fmpz_mpoly_ctx_ngens},
+    {GR_METHOD_CTX_GEN_NAME, (gr_funcptr) _gr_fmpz_mpoly_ctx_gen_name},
     {GR_METHOD_INIT,        (gr_funcptr) _gr_fmpz_mpoly_init},
     {GR_METHOD_CLEAR,       (gr_funcptr) _gr_fmpz_mpoly_clear},
     {GR_METHOD_SWAP,        (gr_funcptr) _gr_fmpz_mpoly_swap},

src/gr/fmpz_mpoly_q.c

@@ -43,9 +43,13 @@ int _gr_fmpz_mpoly_q_ctx_write(gr_stream_t out, gr_ctx_t ctx)
 /* Some methods are identical to their fmpz_mpoly counterparts */
 void _gr_fmpz_mpoly_ctx_clear(gr_ctx_t ctx);
 int _gr_fmpz_mpoly_ctx_set_gen_names(gr_ctx_t ctx, const char ** s);
+slong _gr_fmpz_mpoly_ctx_ngens(gr_ctx_t ctx);
+char const * const _gr_fmpz_mpoly_ctx_gen_name(char ** name, slong i, gr_ctx_t ctx);
 
 #define _gr_fmpz_mpoly_q_ctx_clear _gr_fmpz_mpoly_ctx_clear
 #define _gr_fmpz_mpoly_q_ctx_set_gen_names _gr_fmpz_mpoly_ctx_set_gen_names
+#define _gr_fmpz_mpoly_q_ctx_ngens _gr_fmpz_mpoly_ctx_ngens
+#define _gr_fmpz_mpoly_q_ctx_gen_name _gr_fmpz_mpoly_ctx_gen_name
 
 void
 _gr_fmpz_mpoly_q_init(fmpz_mpoly_q_t res, gr_ctx_t ctx)
@@ -535,6 +539,8 @@ gr_method_tab_input _gr_fmpz_mpoly_q_methods_input[] =
     {GR_METHOD_CTX_IS_COMPLEX_VECTOR_SPACE, (gr_funcptr) gr_generic_ctx_predicate_false},
     {GR_METHOD_CTX_IS_THREADSAFE,               (gr_funcptr) gr_generic_ctx_predicate_true},
     {GR_METHOD_CTX_SET_GEN_NAMES,               (gr_funcptr) _gr_fmpz_mpoly_q_ctx_set_gen_names},
+    {GR_METHOD_CTX_NGENS,   (gr_funcptr) _gr_fmpz_mpoly_q_ctx_ngens},
+    {GR_METHOD_CTX_GEN_NAME, (gr_funcptr) _gr_fmpz_mpoly_q_ctx_gen_name},
     {GR_METHOD_INIT,        (gr_funcptr) _gr_fmpz_mpoly_q_init},
     {GR_METHOD_CLEAR,       (gr_funcptr) _gr_fmpz_mpoly_q_clear},
     {GR_METHOD_SWAP,        (gr_funcptr) _gr_fmpz_mpoly_q_swap},

src/gr/fmpz_poly.c

@@ -53,6 +53,9 @@ int _gr_fmpz_poly_ctx_set_gen_names(gr_ctx_t ctx, const char ** s)
     return _gr_fmpz_poly_ctx_set_gen_name(ctx, s[0]);
 }
 
+int _gr_gr_poly_ctx_gen_name(char ** name, slong i, gr_ctx_t ctx);
+#define _gr_fmpz_poly_ctx_gen_name _gr_gr_poly_ctx_gen_name
+
 int
 _gr_fmpz_poly_ctx_write(gr_stream_t out, gr_ctx_t ctx)
 {
@@ -831,6 +834,8 @@ gr_method_tab_input _fmpz_poly_methods_input[] =
 
     {GR_METHOD_CTX_SET_GEN_NAME,  (gr_funcptr) _gr_fmpz_poly_ctx_set_gen_name},
     {GR_METHOD_CTX_SET_GEN_NAMES, (gr_funcptr) _gr_fmpz_poly_ctx_set_gen_names},
+    {GR_METHOD_CTX_NGENS,       (gr_funcptr) gr_generic_ctx_ngens_1},
+    {GR_METHOD_CTX_GEN_NAME,    (gr_funcptr) _gr_fmpz_poly_ctx_gen_name},
 
     {GR_METHOD_INIT,            (gr_funcptr) _gr_fmpz_poly_init},
     {GR_METHOD_CLEAR,           (gr_funcptr) _gr_fmpz_poly_clear},

src/gr/fmpzi.c

@@ -10,6 +10,7 @@
 */
 
 #include <math.h>
+#include <string.h>
 #include "fmpq.h"
 #include "fexpr.h"
 #include "qqbar.h"
@@ -24,6 +25,20 @@ _gr_fmpzi_ctx_write(gr_stream_t out, gr_ctx_t ctx)
     return GR_SUCCESS;
 }
 
+int
+_gr_fmpzi_ctx_gen_name(char ** name, slong i, gr_ctx_t ctx)
+{
+    if (i != 0)
+        return GR_DOMAIN;
+
+    * name = flint_malloc(2);
+    if (* name == NULL)
+        return GR_UNABLE;
+    strncpy(* name, "I", 2);
+
+    return GR_SUCCESS;
+}
+
 void
 _gr_fmpzi_init(fmpzi_t x, const gr_ctx_t ctx)
 {
@@ -954,6 +969,8 @@ gr_method_tab_input _fmpzi_methods_input[] =
     {GR_METHOD_CTX_IS_EXACT,    (gr_funcptr) gr_generic_ctx_predicate_true},
     {GR_METHOD_CTX_IS_CANONICAL,
                                 (gr_funcptr) gr_generic_ctx_predicate_true},
+    {GR_METHOD_CTX_NGENS,       (gr_funcptr) gr_generic_ctx_ngens_1},
+    {GR_METHOD_CTX_GEN_NAME,    (gr_funcptr) _gr_fmpzi_ctx_gen_name},
     {GR_METHOD_INIT,            (gr_funcptr) _gr_fmpzi_init},
     {GR_METHOD_CLEAR,           (gr_funcptr) _gr_fmpzi_clear},
     {GR_METHOD_SWAP,            (gr_funcptr) _gr_fmpzi_swap},

src/gr/fq.c

@@ -58,6 +58,22 @@ int _gr_fq_ctx_set_gen_names(gr_ctx_t ctx, const char ** s)
     return _gr_fq_ctx_set_gen_name(ctx, s[0]);
 }
 
+int
+_gr_fq_ctx_gen_name(char ** name, slong i, gr_ctx_t ctx)
+{
+    if (i != 0)
+        return GR_DOMAIN;
+
+    char * var = FQ_CTX(ctx)->var;
+    size_t len = strlen(var);
+    * name = flint_malloc(len + 1);
+    if (* name == NULL)
+        return GR_UNABLE;
+    strncpy(* name, var, len + 1);
+
+    return GR_SUCCESS;
+}
+
 void
 _gr_fq_init(fq_t x, const gr_ctx_t ctx)
 {
@@ -716,6 +732,8 @@ gr_method_tab_input _fq_methods_input[] =
     {GR_METHOD_CTX_WRITE,       (gr_funcptr) _gr_fq_ctx_write},
     {GR_METHOD_CTX_SET_GEN_NAME,    (gr_funcptr) _gr_fq_ctx_set_gen_name},
     {GR_METHOD_CTX_SET_GEN_NAMES,   (gr_funcptr) _gr_fq_ctx_set_gen_names},
+    {GR_METHOD_CTX_NGENS,       (gr_funcptr) gr_generic_ctx_ngens_1},
+    {GR_METHOD_CTX_GEN_NAME,    (gr_funcptr) _gr_fq_ctx_gen_name},
     {GR_METHOD_CTX_IS_RING,     (gr_funcptr) gr_generic_ctx_predicate_true},
     {GR_METHOD_CTX_IS_COMMUTATIVE_RING, (gr_funcptr) gr_generic_ctx_predicate_true},
     {GR_METHOD_CTX_IS_INTEGRAL_DOMAIN,  (gr_funcptr) gr_generic_ctx_predicate_true},

src/gr/fq_nmod.c

@@ -59,6 +59,22 @@ int _gr_fq_nmod_ctx_set_gen_names(gr_ctx_t ctx, const char ** s)
     return _gr_fq_nmod_ctx_set_gen_name(ctx, s[0]);
 }
 
+int
+_gr_fq_nmod_ctx_gen_name(char ** name, slong i, gr_ctx_t ctx)
+{
+    if (i != 0)
+        return GR_DOMAIN;
+
+    char * var = FQ_CTX(ctx)->var;
+    size_t len = strlen(var);
+    * name = flint_malloc(len + 1);
+    if (* name == NULL)
+        return GR_UNABLE;
+    strncpy(* name, var, len + 1);
+
+    return GR_SUCCESS;
+}
+
 void
 _gr_fq_nmod_init(fq_nmod_t x, const gr_ctx_t ctx)
 {
@@ -679,6 +695,8 @@ gr_method_tab_input _fq_nmod_methods_input[] =
     {GR_METHOD_CTX_WRITE,       (gr_funcptr) _gr_fq_nmod_ctx_write},
     {GR_METHOD_CTX_SET_GEN_NAME,    (gr_funcptr) _gr_fq_nmod_ctx_set_gen_name},
     {GR_METHOD_CTX_SET_GEN_NAMES,   (gr_funcptr) _gr_fq_nmod_ctx_set_gen_names},
+    {GR_METHOD_CTX_NGENS,       (gr_funcptr) gr_generic_ctx_ngens_1},
+    {GR_METHOD_CTX_GEN_NAME,    (gr_funcptr) _gr_fq_nmod_ctx_gen_name},
     {GR_METHOD_CTX_IS_RING,     (gr_funcptr) gr_generic_ctx_predicate_true},
     {GR_METHOD_CTX_IS_COMMUTATIVE_RING, (gr_funcptr) gr_generic_ctx_predicate_true},
     {GR_METHOD_CTX_IS_INTEGRAL_DOMAIN,  (gr_funcptr) gr_generic_ctx_predicate_true},

src/gr/fq_zech.c

@@ -60,6 +60,22 @@ int _gr_fq_zech_ctx_set_gen_names(gr_ctx_t ctx, const char ** s)
     return _gr_fq_zech_ctx_set_gen_name(ctx, s[0]);
 }
 
+int
+_gr_fq_zech_ctx_gen_name(char ** name, slong i, gr_ctx_t ctx)
+{
+    if (i != 0)
+        return GR_DOMAIN;
+
+    char * var = FQ_CTX(ctx)->fq_nmod_ctx->var;
+    size_t len = strlen(var);
+    * name = flint_malloc(len + 1);
+    if (* name == NULL)
+        return GR_UNABLE;
+    strncpy(* name, var, len + 1);
+
+    return GR_SUCCESS;
+}
+
 void
 _gr_fq_zech_init(fq_zech_t x, const gr_ctx_t ctx)
 {
@@ -560,6 +576,8 @@ gr_method_tab_input _fq_zech_methods_input[] =
     {GR_METHOD_CTX_WRITE,       (gr_funcptr) _gr_fq_zech_ctx_write},
     {GR_METHOD_CTX_SET_GEN_NAME,    (gr_funcptr) _gr_fq_zech_ctx_set_gen_name},
     {GR_METHOD_CTX_SET_GEN_NAMES,   (gr_funcptr) _gr_fq_zech_ctx_set_gen_names},
+    {GR_METHOD_CTX_NGENS,       (gr_funcptr) gr_generic_ctx_ngens_1},
+    {GR_METHOD_CTX_GEN_NAME,    (gr_funcptr) _gr_fq_zech_ctx_gen_name},
     {GR_METHOD_CTX_IS_RING,     (gr_funcptr) gr_generic_ctx_predicate_true},
     {GR_METHOD_CTX_IS_COMMUTATIVE_RING, (gr_funcptr) gr_generic_ctx_predicate_true},
     {GR_METHOD_CTX_IS_INTEGRAL_DOMAIN,  (gr_funcptr) gr_generic_ctx_predicate_true},

src/gr/nf.c

@@ -59,6 +59,22 @@ int _gr_nf_ctx_set_gen_names(gr_ctx_t ctx, const char ** s)
     return _gr_nf_ctx_set_gen_name(ctx, s[0]);
 }
 
+int
+_gr_nf_ctx_gen_name(char ** name, slong i, gr_ctx_t ctx)
+{
+    if (i != 0)
+        return GR_DOMAIN;
+
+    char * var = NF_VAR(ctx);
+    size_t len = strlen(var);
+    * name = flint_malloc(len + 1);
+    if (* name == NULL)
+        return GR_UNABLE;
+    strncpy(* name, var, len + 1);
+
+    return GR_SUCCESS;
+}
+
 void
 _gr_nf_ctx_clear(gr_ctx_t ctx)
 {
@@ -545,6 +561,8 @@ gr_method_tab_input _nf_methods_input[] =
                                 (gr_funcptr) gr_generic_ctx_predicate_true},
     {GR_METHOD_CTX_SET_GEN_NAME, (gr_funcptr) _gr_nf_ctx_set_gen_name},
     {GR_METHOD_CTX_SET_GEN_NAMES,(gr_funcptr) _gr_nf_ctx_set_gen_names},
+    {GR_METHOD_CTX_NGENS,       (gr_funcptr) gr_generic_ctx_ngens_1},
+    {GR_METHOD_CTX_GEN_NAME,    (gr_funcptr) _gr_nf_ctx_gen_name},
     {GR_METHOD_INIT,            (gr_funcptr) _gr_nf_init},
     {GR_METHOD_CLEAR,           (gr_funcptr) _gr_nf_clear},
     {GR_METHOD_SWAP,            (gr_funcptr) _gr_nf_swap},

src/gr/polynomial.c

@@ -53,6 +53,22 @@ int _gr_gr_poly_ctx_set_gen_names(gr_ctx_t ctx, const char ** s)
     return _gr_gr_poly_ctx_set_gen_name(ctx, s[0]);
 }
 
+int
+_gr_gr_poly_ctx_gen_name(char ** name, slong i, gr_ctx_t ctx)
+{
+    if (i != 0)
+        return GR_DOMAIN;
+
+    char * var = POLYNOMIAL_CTX(ctx)->var;
+    size_t len = strlen(var);
+    * name = flint_malloc(len + 1);
+    if (* name == NULL)
+        return GR_UNABLE;
+    strncpy(* name, var, len + 1);
+
+    return GR_SUCCESS;
+}
+
 void
 polynomial_ctx_clear(gr_ctx_t ctx)
 {
@@ -694,6 +710,8 @@ gr_method_tab_input _gr_poly_methods_input[] =
     {GR_METHOD_CTX_IS_THREADSAFE,       (gr_funcptr) polynomial_ctx_is_threadsafe},
     {GR_METHOD_CTX_SET_GEN_NAME,        (gr_funcptr) _gr_gr_poly_ctx_set_gen_name},
     {GR_METHOD_CTX_SET_GEN_NAMES,       (gr_funcptr) _gr_gr_poly_ctx_set_gen_names},
+    {GR_METHOD_CTX_NGENS,               (gr_funcptr) gr_generic_ctx_ngens_1},
+    {GR_METHOD_CTX_GEN_NAME,            (gr_funcptr) _gr_gr_poly_ctx_gen_name},
 
     {GR_METHOD_INIT,        (gr_funcptr) polynomial_init},
     {GR_METHOD_CLEAR,       (gr_funcptr) polynomial_clear},