include/flint/gr.h

0001 /*
0002     Copyright (C) 2023 Fredrik Johansson
0003
0004     This file is part of FLINT.
0005
0006     FLINT is free software: you can redistribute it and/or modify it under
0007     the terms of the GNU Lesser General Public License (LGPL) as published
0008     by the Free Software Foundation; either version 3 of the License, or
0009     (at your option) any later version.  See <https://www.gnu.org/licenses/>.
0010 */
0011
0012 #ifndef GR_H
0013 #define GR_H
0014
0015 #ifdef GR_INLINES_C
0016 #define GR_INLINE
0017 #else
0018 #define GR_INLINE static inline
0019 #endif
0020
0021 #include "fmpz_types.h"
0022 #include "gr_types.h"
0023
0024 #ifdef __cplusplus
0025 extern "C" {
0026 #endif
0027
0028 GR_INLINE truth_t truth_and(truth_t x, truth_t y)
0029 {
0030     if (x == T_FALSE || y == T_FALSE)
0031         return T_FALSE;
0032     if (x == T_TRUE && y == T_TRUE)
0033         return T_TRUE;
0034     return T_UNKNOWN;
0035 }
0036
0037 GR_INLINE truth_t truth_or(truth_t x, truth_t y)
0038 {
0039     if (x == T_TRUE || y == T_TRUE)
0040         return T_TRUE;
0041     if (x == T_FALSE && y == T_FALSE)
0042         return T_FALSE;
0043     return T_UNKNOWN;
0044 }
0045
0046 GR_INLINE truth_t truth_not(truth_t x)
0047 {
0048     if (x == T_TRUE)
0049         return T_FALSE;
0050     if (x == T_FALSE)
0051         return T_TRUE;
0052     return T_UNKNOWN;
0053 }
0054
0055 GR_INLINE truth_t gr_in_domain(int status)
0056 {
0057     if (status == GR_SUCCESS)
0058     return T_TRUE;
0059     else if (status & GR_UNABLE)
0060     return T_UNKNOWN;
0061     else if (status & GR_DOMAIN)
0062     return T_FALSE;
0063     else
0064     return T_UNKNOWN;
0065 }
0066
0067 GR_INLINE int gr_check(truth_t t)
0068 {
0069     if (t == T_TRUE)
0070     return GR_SUCCESS;
0071     else if (t == T_FALSE)
0072     return GR_DOMAIN;
0073     else
0074     return GR_UNABLE;
0075 }
0076
0077 GR_INLINE void truth_println(truth_t x)
0078 {
0079     if (x == T_TRUE) flint_printf("T_TRUE\n");
0080     if (x == T_FALSE) flint_printf("T_FALSE\n");
0081     if (x == T_UNKNOWN) flint_printf("T_UNKNOWN\n");
0082 }
0083
0084 #ifdef FLINT_HAVE_FILE
0085 void gr_stream_init_file(gr_stream_t out, FILE * fp);
0086 #endif
0087
0088 void gr_stream_init_str(gr_stream_t out);
0089 WARN_UNUSED_RESULT int gr_stream_write(gr_stream_t out, const char * s);
0090 WARN_UNUSED_RESULT int gr_stream_write_si(gr_stream_t out, slong x);
0091 WARN_UNUSED_RESULT int gr_stream_write_ui(gr_stream_t out, ulong x);
0092 WARN_UNUSED_RESULT int gr_stream_write_free(gr_stream_t out, char * s);
0093 WARN_UNUSED_RESULT int gr_stream_write_fmpz(gr_stream_t out, const fmpz_t x);
0094
0095 #define GR_MUST_SUCCEED(expr) do { if ((expr) != GR_SUCCESS) { flint_throw(FLINT_ERROR, "GR_MUST_SUCCEED failure: %s", __FILE__); } } while (0)
0096 #define GR_IGNORE(expr) do { int ___unused = (expr); (void) ___unused; } while (0)
0097
0098 GR_INLINE int gr_not_implemented(void) { return GR_UNABLE; }
0099 GR_INLINE int gr_not_in_domain(void) { return GR_DOMAIN; }
0100
0101 typedef enum
0102 {
0103     GR_METHOD_CTX_WRITE,
0104     GR_METHOD_CTX_CLEAR,
0105
0106     /* general ring properties */
0107     GR_METHOD_CTX_IS_RING,
0108     GR_METHOD_CTX_IS_COMMUTATIVE_RING,
0109     GR_METHOD_CTX_IS_INTEGRAL_DOMAIN,
0110     GR_METHOD_CTX_IS_FIELD,
0111     GR_METHOD_CTX_IS_UNIQUE_FACTORIZATION_DOMAIN,
0112     GR_METHOD_CTX_IS_FINITE,
0113     GR_METHOD_CTX_IS_FINITE_CHARACTERISTIC,
0114     GR_METHOD_CTX_IS_ALGEBRAICALLY_CLOSED,
0115     GR_METHOD_CTX_IS_ZERO_RING,
0116     GR_METHOD_CTX_IS_RATIONAL_VECTOR_SPACE,
0117     GR_METHOD_CTX_IS_REAL_VECTOR_SPACE,
0118     GR_METHOD_CTX_IS_COMPLEX_VECTOR_SPACE,
0119     GR_METHOD_CTX_IS_ORDERED_RING,
0120
0121     GR_METHOD_CTX_IS_APPROX_COMMUTATIVE_RING,
0122
0123     /* group properties */
0124     GR_METHOD_CTX_IS_MULTIPLICATIVE_GROUP,
0125
0126     /* context properties represented to the representation */
0127     GR_METHOD_CTX_IS_EXACT,            /* we have no inexact elements */
0128     GR_METHOD_CTX_IS_CANONICAL,        /* we have no non-canonical representations */
0129
0130     GR_METHOD_CTX_IS_THREADSAFE,
0131
0132     GR_METHOD_CTX_HAS_REAL_PREC,
0133     GR_METHOD_CTX_SET_REAL_PREC,
0134     GR_METHOD_CTX_GET_REAL_PREC,
0135
0136     GR_METHOD_CTX_SET_IS_FIELD,
0137     GR_METHOD_CTX_SET_GEN_NAME,
0138     GR_METHOD_CTX_SET_GEN_NAMES,
0139     GR_METHOD_CTX_NGENS,
0140     GR_METHOD_CTX_GEN_NAME,
0141
0142     GR_METHOD_CTX_BASE,
0143
0144     GR_METHOD_INIT,
0145     GR_METHOD_CLEAR,
0146     GR_METHOD_SWAP,
0147     GR_METHOD_SET_SHALLOW,
0148
0149     GR_METHOD_WRITE,
0150     GR_METHOD_WRITE_N,
0151
0152     _GR_METHOD_LENGTH,
0153
0154     GR_METHOD_RANDTEST,
0155     GR_METHOD_RANDTEST_NOT_ZERO,
0156     GR_METHOD_RANDTEST_INVERTIBLE,
0157     GR_METHOD_RANDTEST_SMALL,
0158
0159     GR_METHOD_ZERO,
0160     GR_METHOD_ONE,
0161     GR_METHOD_NEG_ONE,
0162
0163     GR_METHOD_IS_ZERO,
0164     GR_METHOD_IS_ONE,
0165     GR_METHOD_IS_NEG_ONE,
0166
0167     GR_METHOD_EQUAL,
0168
0169     GR_METHOD_SET,
0170     GR_METHOD_SET_UI,
0171     GR_METHOD_SET_SI,
0172     GR_METHOD_SET_FMPZ,
0173     GR_METHOD_SET_FMPQ,
0174     GR_METHOD_SET_D,
0175     GR_METHOD_SET_OTHER,
0176     GR_METHOD_SET_STR,
0177
0178     GR_METHOD_GET_SI,
0179     GR_METHOD_GET_UI,
0180     GR_METHOD_GET_FMPZ,
0181     GR_METHOD_GET_FMPQ,
0182     GR_METHOD_GET_D,
0183
0184     GR_METHOD_GET_FEXPR,
0185     GR_METHOD_GET_FEXPR_SERIALIZE,
0186     GR_METHOD_SET_FEXPR,
0187
0188     GR_METHOD_NEG,
0189
0190     GR_METHOD_ADD,
0191     GR_METHOD_ADD_UI,
0192     GR_METHOD_ADD_SI,
0193     GR_METHOD_ADD_FMPZ,
0194     GR_METHOD_ADD_FMPQ,
0195     GR_METHOD_ADD_OTHER,
0196     GR_METHOD_OTHER_ADD,
0197
0198     GR_METHOD_SUB,
0199     GR_METHOD_SUB_UI,
0200     GR_METHOD_SUB_SI,
0201     GR_METHOD_SUB_FMPZ,
0202     GR_METHOD_SUB_FMPQ,
0203     GR_METHOD_SUB_OTHER,
0204     GR_METHOD_OTHER_SUB,
0205
0206     GR_METHOD_MUL,
0207     GR_METHOD_MUL_UI,
0208     GR_METHOD_MUL_SI,
0209     GR_METHOD_MUL_FMPZ,
0210     GR_METHOD_MUL_FMPQ,
0211     GR_METHOD_MUL_OTHER,
0212     GR_METHOD_OTHER_MUL,
0213
0214     GR_METHOD_ADDMUL,
0215     GR_METHOD_ADDMUL_UI,
0216     GR_METHOD_ADDMUL_SI,
0217     GR_METHOD_ADDMUL_FMPZ,
0218     GR_METHOD_ADDMUL_FMPQ,
0219     GR_METHOD_ADDMUL_OTHER,
0220
0221     GR_METHOD_SUBMUL,
0222     GR_METHOD_SUBMUL_UI,
0223     GR_METHOD_SUBMUL_SI,
0224     GR_METHOD_SUBMUL_FMPZ,
0225     GR_METHOD_SUBMUL_FMPQ,
0226     GR_METHOD_SUBMUL_OTHER,
0227
0228     GR_METHOD_FMA,
0229     GR_METHOD_FMS,
0230     GR_METHOD_FMMA,
0231     GR_METHOD_FMMS,
0232
0233     GR_METHOD_MUL_TWO,
0234     GR_METHOD_SQR,
0235
0236     GR_METHOD_MUL_2EXP_SI,
0237     GR_METHOD_MUL_2EXP_FMPZ,
0238     GR_METHOD_SET_FMPZ_2EXP_FMPZ,
0239     GR_METHOD_GET_FMPZ_2EXP_FMPZ,
0240     GR_METHOD_SET_FMPZ_10EXP_FMPZ,
0241     GR_METHOD_GET_D_2EXP_SI,
0242
0243     GR_METHOD_IS_INVERTIBLE,
0244     GR_METHOD_INV,
0245
0246     GR_METHOD_DIV,
0247     GR_METHOD_DIV_UI,
0248     GR_METHOD_DIV_SI,
0249     GR_METHOD_DIV_FMPZ,
0250     GR_METHOD_DIV_FMPQ,
0251     GR_METHOD_DIV_OTHER,
0252     GR_METHOD_OTHER_DIV,
0253
0254     GR_METHOD_DIV_NONUNIQUE,
0255     GR_METHOD_DIVIDES,
0256
0257     GR_METHOD_DIVEXACT,
0258     GR_METHOD_DIVEXACT_UI,
0259     GR_METHOD_DIVEXACT_SI,
0260     GR_METHOD_DIVEXACT_FMPZ,
0261     GR_METHOD_DIVEXACT_FMPQ,
0262     GR_METHOD_DIVEXACT_OTHER,
0263     GR_METHOD_OTHER_DIVEXACT,
0264
0265     GR_METHOD_POW,
0266     GR_METHOD_POW_UI,
0267     GR_METHOD_POW_SI,
0268     GR_METHOD_POW_FMPZ,
0269     GR_METHOD_POW_FMPQ,
0270     GR_METHOD_POW_OTHER,
0271     GR_METHOD_OTHER_POW,
0272
0273     GR_METHOD_DERIVATIVE_GEN,
0274
0275     GR_METHOD_IS_SQUARE,
0276     GR_METHOD_SQRT,
0277     GR_METHOD_RSQRT,
0278     GR_METHOD_HYPOT,
0279
0280     GR_METHOD_IS_PERFECT_POWER,
0281     GR_METHOD_FACTOR_PERFECT_POWER,
0282     GR_METHOD_ROOT_UI,
0283
0284     GR_METHOD_EUCLIDEAN_DIV,
0285     GR_METHOD_EUCLIDEAN_REM,
0286     GR_METHOD_EUCLIDEAN_DIVREM,
0287     GR_METHOD_GCD,
0288     GR_METHOD_LCM,
0289
0290     GR_METHOD_FACTOR,
0291
0292     GR_METHOD_NUMERATOR,
0293     GR_METHOD_DENOMINATOR,
0294
0295     GR_METHOD_FLOOR,
0296     GR_METHOD_CEIL,
0297     GR_METHOD_TRUNC,
0298     GR_METHOD_NINT,
0299
0300     GR_METHOD_CMP,
0301     GR_METHOD_CMPABS,
0302     GR_METHOD_CMP_OTHER,
0303     GR_METHOD_CMPABS_OTHER,
0304     GR_METHOD_MIN,
0305     GR_METHOD_MAX,
0306
0307     GR_METHOD_ABS,
0308     GR_METHOD_ABS2,
0309     GR_METHOD_I,
0310     GR_METHOD_CONJ,
0311     GR_METHOD_RE,
0312     GR_METHOD_IM,
0313     GR_METHOD_SGN,
0314     GR_METHOD_CSGN,
0315     GR_METHOD_ARG,
0316     GR_METHOD_CANONICAL_ASSOCIATE,
0317
0318     GR_METHOD_POS_INF,
0319     GR_METHOD_NEG_INF,
0320     GR_METHOD_UINF,
0321     GR_METHOD_UNDEFINED,
0322     GR_METHOD_UNKNOWN,
0323
0324     GR_METHOD_IS_INTEGER,
0325     GR_METHOD_IS_RATIONAL,
0326     GR_METHOD_IS_REAL,
0327     GR_METHOD_IS_POSITIVE_INTEGER,
0328     GR_METHOD_IS_NONNEGATIVE_INTEGER,
0329     GR_METHOD_IS_NEGATIVE_INTEGER,
0330     GR_METHOD_IS_NONPOSITIVE_INTEGER,
0331     GR_METHOD_IS_POSITIVE_REAL,
0332     GR_METHOD_IS_NONNEGATIVE_REAL,
0333     GR_METHOD_IS_NEGATIVE_REAL,
0334     GR_METHOD_IS_NONPOSITIVE_REAL,
0335
0336     GR_METHOD_SET_INTERVAL_MID_RAD,
0337
0338     /* todo: roots of unity */
0339     GR_METHOD_IS_ROOT_OF_UNITY,
0340     GR_METHOD_ROOT_OF_UNITY_UI,
0341     GR_METHOD_ROOT_OF_UNITY_UI_VEC,
0342
0343     /* Elementary transcendental functions */
0344     GR_METHOD_PI,
0345     GR_METHOD_EXP,
0346     GR_METHOD_EXPM1,
0347     GR_METHOD_EXP_PI_I,
0348     GR_METHOD_EXP2,
0349     GR_METHOD_EXP10,
0350     GR_METHOD_LOG,
0351     GR_METHOD_LOG1P,
0352     GR_METHOD_LOG_PI_I,
0353     GR_METHOD_LOG2,
0354     GR_METHOD_LOG10,
0355     GR_METHOD_SIN,
0356     GR_METHOD_COS,
0357     GR_METHOD_SIN_COS,
0358     GR_METHOD_TAN,
0359     GR_METHOD_COT,
0360     GR_METHOD_SEC,
0361     GR_METHOD_CSC,
0362     GR_METHOD_SIN_PI,
0363     GR_METHOD_COS_PI,
0364     GR_METHOD_SIN_COS_PI,
0365     GR_METHOD_TAN_PI,
0366     GR_METHOD_COT_PI,
0367     GR_METHOD_SEC_PI,
0368     GR_METHOD_CSC_PI,
0369     GR_METHOD_SINC,
0370     GR_METHOD_SINC_PI,
0371     GR_METHOD_SINH,
0372     GR_METHOD_COSH,
0373     GR_METHOD_SINH_COSH,
0374     GR_METHOD_TANH,
0375     GR_METHOD_COTH,
0376     GR_METHOD_SECH,
0377     GR_METHOD_CSCH,
0378     GR_METHOD_ASIN,
0379     GR_METHOD_ACOS,
0380     GR_METHOD_ATAN,
0381     GR_METHOD_ATAN2,
0382     GR_METHOD_ACOT,
0383     GR_METHOD_ASEC,
0384     GR_METHOD_ACSC,
0385     GR_METHOD_ASINH,
0386     GR_METHOD_ACOSH,
0387     GR_METHOD_ATANH,
0388     GR_METHOD_ACOTH,
0389     GR_METHOD_ASECH,
0390     GR_METHOD_ACSCH,
0391     GR_METHOD_ASIN_PI,
0392     GR_METHOD_ACOS_PI,
0393     GR_METHOD_ATAN_PI,
0394     GR_METHOD_ACOT_PI,
0395     GR_METHOD_ASEC_PI,
0396     GR_METHOD_ACSC_PI,
0397
0398     /* Combinatorial and related functions */
0399     GR_METHOD_FAC,
0400     GR_METHOD_FAC_UI,
0401     GR_METHOD_FAC_FMPZ,
0402     GR_METHOD_FAC_VEC,
0403     GR_METHOD_RFAC,
0404     GR_METHOD_RFAC_UI,
0405     GR_METHOD_RFAC_FMPZ,
0406     GR_METHOD_RFAC_VEC,
0407     GR_METHOD_BIN,
0408     GR_METHOD_BIN_UI,
0409     GR_METHOD_BIN_UIUI,
0410     GR_METHOD_BIN_VEC,
0411     GR_METHOD_BIN_UI_VEC,
0412     GR_METHOD_RISING_UI,
0413     GR_METHOD_RISING,
0414     GR_METHOD_FALLING_UI,
0415     GR_METHOD_FALLING,
0416     GR_METHOD_GAMMA,
0417     GR_METHOD_GAMMA_FMPZ,
0418     GR_METHOD_GAMMA_FMPQ,
0419     GR_METHOD_RGAMMA,
0420     GR_METHOD_LGAMMA,
0421     GR_METHOD_DIGAMMA,
0422     GR_METHOD_BETA,
0423     GR_METHOD_DOUBLEFAC,
0424     GR_METHOD_DOUBLEFAC_UI,
0425     GR_METHOD_BARNES_G,
0426     GR_METHOD_LOG_BARNES_G,
0427     GR_METHOD_HARMONIC,
0428     GR_METHOD_HARMONIC_UI,
0429     GR_METHOD_BERNOULLI_UI,
0430     GR_METHOD_BERNOULLI_FMPZ,
0431     GR_METHOD_BERNOULLI_VEC,
0432     GR_METHOD_FIB_UI,
0433     GR_METHOD_FIB_FMPZ,
0434     GR_METHOD_FIB_VEC,
0435     GR_METHOD_STIRLING_S1U_UIUI,
0436     GR_METHOD_STIRLING_S1_UIUI,
0437     GR_METHOD_STIRLING_S2_UIUI,
0438     GR_METHOD_STIRLING_S1U_UI_VEC,
0439     GR_METHOD_STIRLING_S1_UI_VEC,
0440     GR_METHOD_STIRLING_S2_UI_VEC,
0441     GR_METHOD_EULERNUM_UI,
0442     GR_METHOD_EULERNUM_FMPZ,
0443     GR_METHOD_EULERNUM_VEC,
0444     GR_METHOD_BELLNUM_UI,
0445     GR_METHOD_BELLNUM_FMPZ,
0446     GR_METHOD_BELLNUM_VEC,
0447     GR_METHOD_PARTITIONS_UI,
0448     GR_METHOD_PARTITIONS_FMPZ,
0449     GR_METHOD_PARTITIONS_VEC,
0450
0451     /* Orthogonal polynomials */
0452     GR_METHOD_CHEBYSHEV_T_FMPZ,
0453     GR_METHOD_CHEBYSHEV_U_FMPZ,
0454     GR_METHOD_CHEBYSHEV_T,
0455     GR_METHOD_CHEBYSHEV_U,
0456     GR_METHOD_JACOBI_P,
0457     GR_METHOD_GEGENBAUER_C,
0458     GR_METHOD_LAGUERRE_L,
0459     GR_METHOD_HERMITE_H,
0460     GR_METHOD_LEGENDRE_P,
0461     GR_METHOD_LEGENDRE_Q,
0462     GR_METHOD_LEGENDRE_P_ROOT_UI,
0463     GR_METHOD_SPHERICAL_Y_SI,
0464
0465     /* Misc real constants */
0466     GR_METHOD_EULER,
0467     GR_METHOD_CATALAN,
0468     GR_METHOD_KHINCHIN,
0469     GR_METHOD_GLAISHER,
0470
0471     GR_METHOD_LAMBERTW,
0472     GR_METHOD_LAMBERTW_FMPZ,
0473
0474     GR_METHOD_ERF,
0475     GR_METHOD_ERFC,
0476     GR_METHOD_ERFCX,
0477     GR_METHOD_ERFI,
0478     GR_METHOD_ERFINV,
0479     GR_METHOD_ERFCINV,
0480     GR_METHOD_FRESNEL_S,
0481     GR_METHOD_FRESNEL_C,
0482     GR_METHOD_FRESNEL,
0483     GR_METHOD_GAMMA_UPPER,
0484     GR_METHOD_GAMMA_LOWER,
0485     GR_METHOD_BETA_LOWER,
0486     GR_METHOD_EXP_INTEGRAL,
0487     GR_METHOD_EXP_INTEGRAL_EI,
0488     GR_METHOD_SIN_INTEGRAL,
0489     GR_METHOD_COS_INTEGRAL,
0490     GR_METHOD_SINH_INTEGRAL,
0491     GR_METHOD_COSH_INTEGRAL,
0492     GR_METHOD_LOG_INTEGRAL,
0493     GR_METHOD_DILOG,
0494
0495     GR_METHOD_BESSEL_J,
0496     GR_METHOD_BESSEL_Y,
0497     GR_METHOD_BESSEL_J_Y,
0498     GR_METHOD_BESSEL_I,
0499     GR_METHOD_BESSEL_I_SCALED,
0500     GR_METHOD_BESSEL_K,
0501     GR_METHOD_BESSEL_K_SCALED,
0502
0503     GR_METHOD_AIRY,
0504     GR_METHOD_AIRY_AI,
0505     GR_METHOD_AIRY_BI,
0506     GR_METHOD_AIRY_AI_PRIME,
0507     GR_METHOD_AIRY_BI_PRIME,
0508     GR_METHOD_AIRY_AI_ZERO,
0509     GR_METHOD_AIRY_BI_ZERO,
0510     GR_METHOD_AIRY_AI_PRIME_ZERO,
0511     GR_METHOD_AIRY_BI_PRIME_ZERO,
0512
0513     GR_METHOD_COULOMB,
0514     GR_METHOD_COULOMB_F,
0515     GR_METHOD_COULOMB_G,
0516     GR_METHOD_COULOMB_HPOS,
0517     GR_METHOD_COULOMB_HNEG,
0518
0519     GR_METHOD_ZETA,
0520     GR_METHOD_ZETA_UI,
0521     GR_METHOD_HURWITZ_ZETA,
0522     GR_METHOD_LERCH_PHI,
0523     GR_METHOD_STIELTJES,
0524     GR_METHOD_DIRICHLET_ETA,
0525     GR_METHOD_DIRICHLET_BETA,
0526     GR_METHOD_RIEMANN_XI,
0527     GR_METHOD_ZETA_ZERO,
0528     GR_METHOD_ZETA_ZERO_VEC,
0529     GR_METHOD_ZETA_NZEROS,
0530
0531     GR_METHOD_DIRICHLET_CHI_UI,
0532     GR_METHOD_DIRICHLET_CHI_FMPZ,
0533     GR_METHOD_DIRICHLET_L,
0534     GR_METHOD_DIRICHLET_HARDY_THETA,
0535     GR_METHOD_DIRICHLET_HARDY_Z,
0536
0537     GR_METHOD_BERNPOLY_UI,
0538     GR_METHOD_EULERPOLY_UI,
0539     GR_METHOD_POLYLOG,
0540     GR_METHOD_POLYGAMMA,
0541
0542     GR_METHOD_HYPGEOM_0F1,
0543     GR_METHOD_HYPGEOM_1F1,
0544     GR_METHOD_HYPGEOM_2F0,
0545     GR_METHOD_HYPGEOM_2F1,
0546     GR_METHOD_HYPGEOM_U,
0547     GR_METHOD_HYPGEOM_PFQ,
0548
0549     GR_METHOD_JACOBI_THETA,
0550     GR_METHOD_JACOBI_THETA_1,
0551     GR_METHOD_JACOBI_THETA_2,
0552     GR_METHOD_JACOBI_THETA_3,
0553     GR_METHOD_JACOBI_THETA_4,
0554     GR_METHOD_JACOBI_THETA_Q,
0555     GR_METHOD_JACOBI_THETA_Q_1,
0556     GR_METHOD_JACOBI_THETA_Q_2,
0557     GR_METHOD_JACOBI_THETA_Q_3,
0558     GR_METHOD_JACOBI_THETA_Q_4,
0559
0560     GR_METHOD_MODULAR_J,
0561     GR_METHOD_MODULAR_LAMBDA,
0562     GR_METHOD_MODULAR_DELTA,
0563     GR_METHOD_HILBERT_CLASS_POLY,
0564
0565     GR_METHOD_DEDEKIND_ETA,
0566     GR_METHOD_DEDEKIND_ETA_Q,
0567
0568     GR_METHOD_EISENSTEIN_E,
0569     GR_METHOD_EISENSTEIN_G,
0570     GR_METHOD_EISENSTEIN_G_VEC,
0571
0572     GR_METHOD_AGM,
0573     GR_METHOD_AGM1,
0574
0575     GR_METHOD_ELLIPTIC_K,
0576     GR_METHOD_ELLIPTIC_E,
0577     GR_METHOD_ELLIPTIC_PI,
0578     GR_METHOD_ELLIPTIC_F,
0579     GR_METHOD_ELLIPTIC_E_INC,
0580     GR_METHOD_ELLIPTIC_PI_INC,
0581
0582     GR_METHOD_CARLSON_RF,
0583     GR_METHOD_CARLSON_RC,
0584     GR_METHOD_CARLSON_RJ,
0585     GR_METHOD_CARLSON_RG,
0586     GR_METHOD_CARLSON_RD,
0587
0588     GR_METHOD_ELLIPTIC_ROOTS,
0589     GR_METHOD_ELLIPTIC_INVARIANTS,
0590
0591     GR_METHOD_WEIERSTRASS_P,
0592     GR_METHOD_WEIERSTRASS_P_PRIME,
0593     GR_METHOD_WEIERSTRASS_P_INV,
0594     GR_METHOD_WEIERSTRASS_ZETA,
0595     GR_METHOD_WEIERSTRASS_SIGMA,
0596
0597     GR_METHOD_GEN,
0598     GR_METHOD_GENS,
0599     GR_METHOD_GENS_RECURSIVE,
0600
0601     GR_METHOD_BIG_O_BASE_FMPZ,
0602
0603     /* Finite field methods */
0604     GR_METHOD_CTX_FQ_PRIME,
0605     GR_METHOD_CTX_FQ_DEGREE,
0606     GR_METHOD_CTX_FQ_ORDER,
0607     GR_METHOD_FQ_FROBENIUS,
0608     GR_METHOD_FQ_MULTIPLICATIVE_ORDER,
0609     GR_METHOD_FQ_NORM,
0610     GR_METHOD_FQ_TRACE,
0611     GR_METHOD_FQ_IS_PRIMITIVE,
0612     GR_METHOD_FQ_PTH_ROOT,
0613
0614     /* Vector methods */
0615     GR_METHOD_VEC_INIT,
0616     GR_METHOD_VEC_CLEAR,
0617     GR_METHOD_VEC_SWAP,
0618     GR_METHOD_VEC_SET,
0619     GR_METHOD_VEC_ZERO,
0620     GR_METHOD_VEC_EQUAL,
0621     GR_METHOD_VEC_IS_ZERO,
0622     GR_METHOD_VEC_NEG,
0623
0624     GR_METHOD_VEC_NORMALISE,
0625     GR_METHOD_VEC_NORMALISE_WEAK,
0626
0627     GR_METHOD_VEC_ADD, GR_METHOD_VEC_SUB, GR_METHOD_VEC_MUL, GR_METHOD_VEC_DIV, GR_METHOD_VEC_DIVEXACT, GR_METHOD_VEC_POW,
0628     GR_METHOD_VEC_ADD_SCALAR, GR_METHOD_VEC_SUB_SCALAR, GR_METHOD_VEC_MUL_SCALAR, GR_METHOD_VEC_DIV_SCALAR, GR_METHOD_VEC_DIVEXACT_SCALAR, GR_METHOD_VEC_POW_SCALAR,
0629     GR_METHOD_SCALAR_ADD_VEC, GR_METHOD_SCALAR_SUB_VEC, GR_METHOD_SCALAR_MUL_VEC, GR_METHOD_SCALAR_DIV_VEC, GR_METHOD_SCALAR_DIVEXACT_VEC, GR_METHOD_SCALAR_POW_VEC,
0630     GR_METHOD_VEC_ADD_OTHER, GR_METHOD_VEC_SUB_OTHER, GR_METHOD_VEC_MUL_OTHER, GR_METHOD_VEC_DIV_OTHER, GR_METHOD_VEC_DIVEXACT_OTHER, GR_METHOD_VEC_POW_OTHER,
0631     GR_METHOD_OTHER_ADD_VEC, GR_METHOD_OTHER_SUB_VEC, GR_METHOD_OTHER_MUL_VEC, GR_METHOD_OTHER_DIV_VEC, GR_METHOD_OTHER_DIVEXACT_VEC, GR_METHOD_OTHER_POW_VEC,
0632     GR_METHOD_VEC_ADD_SCALAR_OTHER, GR_METHOD_VEC_SUB_SCALAR_OTHER, GR_METHOD_VEC_MUL_SCALAR_OTHER, GR_METHOD_VEC_DIV_SCALAR_OTHER, GR_METHOD_VEC_DIVEXACT_SCALAR_OTHER, GR_METHOD_VEC_POW_SCALAR_OTHER,
0633     GR_METHOD_SCALAR_OTHER_ADD_VEC, GR_METHOD_SCALAR_OTHER_SUB_VEC, GR_METHOD_SCALAR_OTHER_MUL_VEC, GR_METHOD_SCALAR_OTHER_DIV_VEC, GR_METHOD_SCALAR_OTHER_DIVEXACT_VEC, GR_METHOD_SCALAR_OTHER_POW_VEC,
0634
0635     GR_METHOD_VEC_ADD_SCALAR_SI, GR_METHOD_VEC_ADD_SCALAR_UI, GR_METHOD_VEC_ADD_SCALAR_FMPZ, GR_METHOD_VEC_ADD_SCALAR_FMPQ,
0636     GR_METHOD_VEC_SUB_SCALAR_SI, GR_METHOD_VEC_SUB_SCALAR_UI, GR_METHOD_VEC_SUB_SCALAR_FMPZ, GR_METHOD_VEC_SUB_SCALAR_FMPQ,
0637     GR_METHOD_VEC_MUL_SCALAR_SI, GR_METHOD_VEC_MUL_SCALAR_UI, GR_METHOD_VEC_MUL_SCALAR_FMPZ, GR_METHOD_VEC_MUL_SCALAR_FMPQ,
0638     GR_METHOD_VEC_DIV_SCALAR_SI, GR_METHOD_VEC_DIV_SCALAR_UI, GR_METHOD_VEC_DIV_SCALAR_FMPZ, GR_METHOD_VEC_DIV_SCALAR_FMPQ,
0639     GR_METHOD_VEC_DIVEXACT_SCALAR_SI, GR_METHOD_VEC_DIVEXACT_SCALAR_UI, GR_METHOD_VEC_DIVEXACT_SCALAR_FMPZ, GR_METHOD_VEC_DIVEXACT_SCALAR_FMPQ,
0640     GR_METHOD_VEC_POW_SCALAR_SI, GR_METHOD_VEC_POW_SCALAR_UI, GR_METHOD_VEC_POW_SCALAR_FMPZ, GR_METHOD_VEC_POW_SCALAR_FMPQ,
0641
0642     GR_METHOD_VEC_MUL_SCALAR_2EXP_SI,
0643     GR_METHOD_VEC_MUL_SCALAR_2EXP_FMPZ,
0644
0645     GR_METHOD_VEC_ADDMUL_SCALAR,
0646     GR_METHOD_VEC_SUBMUL_SCALAR,
0647     GR_METHOD_VEC_ADDMUL_SCALAR_SI,
0648     GR_METHOD_VEC_SUBMUL_SCALAR_SI,
0649     GR_METHOD_VEC_ADDMUL_SCALAR_FMPZ,
0650
0651     GR_METHOD_VEC_SUM,
0652     GR_METHOD_VEC_PRODUCT,
0653
0654     GR_METHOD_VEC_DOT,
0655     GR_METHOD_VEC_DOT_REV,
0656     GR_METHOD_VEC_DOT_STRIDED,
0657     GR_METHOD_VEC_DOT_UI,
0658     GR_METHOD_VEC_DOT_SI,
0659     GR_METHOD_VEC_DOT_FMPZ,
0660
0661     GR_METHOD_VEC_SET_POWERS,
0662     GR_METHOD_VEC_RECIPROCALS,
0663
0664     /* Polynomial methods (todo: rename -> GR_POLY) */
0665     GR_METHOD_POLY_MULLOW,
0666     GR_METHOD_POLY_MULMID,
0667     GR_METHOD_POLY_DIV,
0668     GR_METHOD_POLY_DIVREM,
0669     GR_METHOD_POLY_DIVEXACT,
0670     GR_METHOD_POLY_GCD,
0671     GR_METHOD_POLY_XGCD,
0672     GR_METHOD_POLY_TAYLOR_SHIFT,
0673     GR_METHOD_POLY_INV_SERIES,
0674     GR_METHOD_POLY_INV_SERIES_BASECASE,
0675     GR_METHOD_POLY_DIV_SERIES,
0676     GR_METHOD_POLY_DIV_SERIES_BASECASE,
0677     GR_METHOD_POLY_RSQRT_SERIES,
0678     GR_METHOD_POLY_SQRT_SERIES,
0679     GR_METHOD_POLY_EXP_SERIES,
0680     GR_METHOD_POLY_FACTOR,
0681     GR_METHOD_POLY_ROOTS,
0682     GR_METHOD_POLY_ROOTS_OTHER,
0683
0684     /* Matrix methods (todo: rename -> GR_MAT) */
0685     GR_METHOD_MAT_MUL,
0686     GR_METHOD_MAT_NONSINGULAR_SOLVE_TRIL,
0687     GR_METHOD_MAT_NONSINGULAR_SOLVE_TRIU,
0688     GR_METHOD_MAT_LU,
0689     GR_METHOD_MAT_DET,
0690     GR_METHOD_MAT_LQ,
0691     GR_METHOD_MAT_EXP,
0692     GR_METHOD_MAT_LOG,
0693     GR_METHOD_MAT_FIND_NONZERO_PIVOT,
0694     GR_METHOD_MAT_DIAGONALIZATION,
0695     GR_METHOD_MAT_CHARPOLY,
0696     GR_METHOD_MAT_REDUCE_ROW,
0697     GR_METHOD_MAT_PERMANENT,
0698
0699     GR_METHOD_TAB_SIZE
0700 }
0701 gr_method;
0702
0703 typedef gr_funcptr gr_static_method_table[GR_METHOD_TAB_SIZE];
0704
0705 typedef struct
0706 {
0707     gr_method index;
0708     gr_funcptr function;
0709 }
0710 gr_method_tab_input;
0711
0712 void gr_method_tab_init(gr_funcptr * methods, gr_method_tab_input * tab);
0713 void gr_method_tab_extend(gr_funcptr * methods, gr_method_tab_input * tab);
0714
0715 /* Identify specific rings/fields. */
0716
0717 typedef enum
0718 {
0719     GR_CTX_FMPZ, GR_CTX_RADIX_INTEGER,
0720     GR_CTX_FMPQ, GR_CTX_FMPZI,
0721     GR_CTX_FMPZ_MOD, GR_CTX_NMOD, GR_CTX_NMOD8, GR_CTX_NMOD32,
0722     GR_CTX_NMOD_REDC, GR_CTX_NMOD_REDC_FAST,
0723     GR_CTX_MPN_MOD,
0724     GR_CTX_FQ, GR_CTX_FQ_NMOD, GR_CTX_FQ_ZECH,
0725     GR_CTX_NF,
0726     GR_CTX_PADIC_RADIX,
0727     GR_CTX_REAL_ALGEBRAIC_QQBAR, GR_CTX_COMPLEX_ALGEBRAIC_QQBAR,
0728     GR_CTX_REAL_ALGEBRAIC_CA, GR_CTX_COMPLEX_ALGEBRAIC_CA,
0729     GR_CTX_RR_CA, GR_CTX_CC_CA,
0730     GR_CTX_COMPLEX_EXTENDED_CA,
0731     GR_CTX_RR_ARB, GR_CTX_CC_ACB,
0732     GR_CTX_REAL_FLOAT_ARF, GR_CTX_COMPLEX_FLOAT_ACF,
0733     GR_CTX_NFLOAT, GR_CTX_NFLOAT_COMPLEX,
0734     GR_CTX_MPF,
0735     GR_CTX_FMPZ_POLY, GR_CTX_FMPQ_POLY, GR_CTX_GR_POLY,
0736     GR_CTX_FMPZ_MPOLY, GR_CTX_FMPQ_MPOLY, GR_CTX_GR_MPOLY,
0737     GR_CTX_FMPZ_MPOLY_Q,
0738     GR_CTX_FMPZ_MOD_MPOLY_Q,
0739     GR_CTX_GR_ORE_POLY,
0740     GR_CTX_GR_FRACTION, GR_CTX_GR_COMPLEX,
0741     GR_CTX_GR_SERIES, GR_CTX_SERIES_MOD_GR_POLY,
0742     GR_CTX_GR_MAT,
0743     GR_CTX_GR_VEC,
0744     GR_CTX_PSL2Z, GR_CTX_DIRICHLET_GROUP, GR_CTX_PERM,
0745     GR_CTX_FEXPR,
0746     GR_CTX_DEBUG,
0747     GR_CTX_UNINITIALIZED,
0748     GR_CTX_UNKNOWN_DOMAIN,
0749     GR_CTX_WHICH_STRUCTURE_TAB_SIZE
0750 }
0751 gr_which_structure;
0752
0753 GR_INLINE void * gr_ctx_data_ptr(gr_ctx_t ctx) { return (void *) ctx->data; }
0754 GR_INLINE void * gr_ctx_data_as_ptr(gr_ctx_t ctx) { return (void *) GR_CTX_DATA_AS_PTR(ctx); }
0755
0756 GR_INLINE slong gr_ctx_sizeof_ctx(void)
0757 {
0758     return sizeof(gr_ctx_struct);
0759 }
0760
0761 GR_INLINE slong gr_ctx_sizeof_elem(gr_ctx_t ctx)
0762 {
0763     return ctx->sizeof_elem;
0764 }
0765
0766 /* Typedefs for method function pointers. */
0767
0768 typedef void ((*gr_method_init_clear_op)(gr_ptr, gr_ctx_ptr));
0769 typedef void ((*gr_method_swap_op)(gr_ptr, gr_ptr, gr_ctx_ptr));
0770 typedef int ((*gr_method_ctx)(gr_ctx_ptr));
0771 typedef void ((*gr_method_ctx_void_op)(gr_ctx_ptr));
0772 typedef gr_ctx_ptr ((*gr_method_ctx_base)(gr_ctx_ptr));
0773 typedef truth_t ((*gr_method_ctx_predicate)(gr_ctx_ptr));
0774 typedef slong ((*gr_method_ctx_size)(gr_ctx_ptr));
0775 typedef int ((*gr_method_ctx_gen_name)(char **, slong, gr_ctx_ptr));
0776 typedef int ((*gr_method_ctx_set_si)(gr_ctx_ptr, slong));
0777 typedef int ((*gr_method_ctx_get_si)(slong *, gr_ctx_ptr));
0778 typedef int ((*gr_method_ctx_set_truth)(gr_ctx_ptr, truth_t));
0779 typedef int ((*gr_method_ctx_stream)(gr_stream_t, gr_ctx_ptr));
0780 typedef int ((*gr_method_ctx_set_str)(gr_ctx_ptr, const char *));
0781 typedef int ((*gr_method_ctx_set_strs)(gr_ctx_ptr, const char **));
0782 typedef int ((*gr_method_stream_in)(gr_stream_t, gr_srcptr, gr_ctx_ptr));
0783 typedef int ((*gr_method_stream_in_si)(gr_stream_t, gr_srcptr, slong, gr_ctx_ptr));
0784 typedef int ((*gr_method_randtest)(gr_ptr, flint_rand_t state, gr_ctx_ptr));
0785 typedef int ((*gr_method_constant_op)(gr_ptr, gr_ctx_ptr));
0786 typedef int ((*gr_method_constant_op_get_si)(slong *, gr_ctx_ptr));
0787 typedef int ((*gr_method_constant_op_get_fmpz)(fmpz_t, gr_ctx_ptr));
0788 typedef void ((*gr_method_void_unary_op)(gr_ptr, gr_srcptr, gr_ctx_ptr));
0789 typedef int ((*gr_method_unary_op)(gr_ptr, gr_srcptr, gr_ctx_ptr));
0790 typedef int ((*gr_method_unary_op_si)(gr_ptr, slong, gr_ctx_ptr));
0791 typedef int ((*gr_method_unary_op_ui)(gr_ptr, ulong, gr_ctx_ptr));
0792 typedef int ((*gr_method_unary_op_fmpz)(gr_ptr, const fmpz_t, gr_ctx_ptr));
0793 typedef int ((*gr_method_unary_op_fmpq)(gr_ptr, const fmpq_t, gr_ctx_ptr));
0794 typedef int ((*gr_method_unary_op_d)(gr_ptr, double, gr_ctx_ptr));
0795 typedef int ((*gr_method_unary_op_other)(gr_ptr, gr_srcptr, gr_ctx_ptr, gr_ctx_ptr));
0796 typedef int ((*gr_method_unary_op_str)(gr_ptr, const char *, gr_ctx_ptr));
0797 typedef int ((*gr_method_unary_op_get_ui)(ulong *, gr_srcptr, gr_ctx_ptr));
0798 typedef int ((*gr_method_unary_op_get_si)(slong *, gr_srcptr, gr_ctx_ptr));
0799 typedef int ((*gr_method_unary_op_get_fmpz)(fmpz_t, gr_srcptr, gr_ctx_ptr));
0800 typedef int ((*gr_method_unary_op_get_fmpq)(fmpq_t, gr_srcptr, gr_ctx_ptr));
0801 typedef int ((*gr_method_unary_op_get_d)(double *, gr_srcptr, gr_ctx_ptr));
0802 typedef int ((*gr_method_unary_op_get_d_si)(double *, slong *, gr_srcptr, gr_ctx_ptr));
0803 typedef int ((*gr_method_unary_op_get_fmpz_fmpz)(fmpz_t, fmpz_t, gr_srcptr, gr_ctx_ptr));
0804 typedef int ((*gr_method_unary_op_with_flag)(gr_ptr, gr_srcptr, int, gr_ctx_ptr));
0805 typedef int ((*gr_method_binary_unary_op)(gr_ptr, gr_ptr, gr_srcptr, gr_ctx_ptr));
0806 typedef int ((*gr_method_binary_unary_op_with_flag)(gr_ptr, gr_ptr, gr_srcptr, int, gr_ctx_ptr));
0807 typedef int ((*gr_method_quaternary_unary_op)(gr_ptr, gr_ptr, gr_ptr, gr_ptr, gr_srcptr, gr_ctx_ptr));
0808 typedef int ((*gr_method_binary_op)(gr_ptr, gr_srcptr, gr_srcptr, gr_ctx_ptr));
0809 typedef int ((*gr_method_binary_op_si)(gr_ptr, gr_srcptr, slong, gr_ctx_ptr));
0810 typedef int ((*gr_method_binary_op_ui)(gr_ptr, gr_srcptr, ulong, gr_ctx_ptr));
0811 typedef int ((*gr_method_binary_op_fmpz)(gr_ptr, gr_srcptr, const fmpz_t, gr_ctx_ptr));
0812 typedef int ((*gr_method_binary_op_fmpz_fmpz)(gr_ptr, const fmpz_t, const fmpz_t, gr_ctx_ptr));
0813 typedef int ((*gr_method_binary_op_fmpz_si)(gr_ptr, const fmpz_t, slong, gr_ctx_ptr));
0814 typedef int ((*gr_method_binary_op_fmpq)(gr_ptr, gr_srcptr, const fmpq_t, gr_ctx_ptr));
0815 typedef int ((*gr_method_binary_op_other)(gr_ptr, gr_srcptr, gr_srcptr, gr_ctx_ptr, gr_ctx_ptr));
0816 typedef int ((*gr_method_other_binary_op)(gr_ptr, gr_srcptr, gr_ctx_ptr, gr_srcptr, gr_ctx_ptr));
0817 typedef int ((*gr_method_si_binary_op)(gr_ptr, slong, gr_srcptr, gr_ctx_ptr));
0818 typedef int ((*gr_method_ui_binary_op)(gr_ptr, ulong, gr_srcptr, gr_ctx_ptr));
0819 typedef int ((*gr_method_fmpz_binary_op)(gr_ptr, const fmpz_t, gr_srcptr, gr_ctx_ptr));
0820 typedef int ((*gr_method_fmpq_binary_op)(gr_ptr, const fmpq_t, gr_srcptr, gr_ctx_ptr));
0821 typedef int ((*gr_method_binary_op_ui_ui)(gr_ptr, ulong, ulong, gr_ctx_ptr));
0822 typedef int ((*gr_method_binary_op_ui_si)(gr_ptr, ulong, slong, gr_ctx_ptr));
0823 typedef int ((*gr_method_binary_op_get_int)(int *, gr_srcptr, gr_srcptr, gr_ctx_ptr));
0824 typedef int ((*gr_method_binary_op_other_get_int)(int *, gr_srcptr, gr_srcptr, gr_ctx_ptr, gr_ctx_ptr));
0825 typedef int ((*gr_method_binary_binary_op)(gr_ptr, gr_ptr, gr_srcptr, gr_srcptr, gr_ctx_ptr));
0826 typedef int ((*gr_method_binary_op_with_flag)(gr_ptr, gr_srcptr, gr_srcptr, int, gr_ctx_ptr));
0827 typedef int ((*gr_method_binary_binary_op_ui_ui)(gr_ptr, gr_ptr, ulong, ulong, gr_ctx_ptr));
0828 typedef int ((*gr_method_ternary_op)(gr_ptr, gr_srcptr, gr_srcptr, gr_srcptr, gr_ctx_ptr));
0829 typedef int ((*gr_method_ternary_op_with_flag)(gr_ptr, gr_srcptr, gr_srcptr, gr_srcptr, int, gr_ctx_ptr));
0830 typedef int ((*gr_method_ternary_unary_op)(gr_ptr, gr_ptr, gr_ptr, gr_srcptr, gr_ctx_ptr));
0831 typedef int ((*gr_method_quaternary_op)(gr_ptr, gr_srcptr, gr_srcptr, gr_srcptr, gr_srcptr, gr_ctx_ptr));
0832 typedef int ((*gr_method_quaternary_op_with_flag)(gr_ptr, gr_srcptr, gr_srcptr, gr_srcptr, gr_srcptr, int, gr_ctx_ptr));
0833 typedef int ((*gr_method_quaternary_binary_op)(gr_ptr, gr_ptr, gr_ptr, gr_ptr, gr_srcptr, gr_srcptr, gr_ctx_ptr));
0834 typedef int ((*gr_method_quaternary_ternary_op)(gr_ptr, gr_ptr, gr_ptr, gr_ptr, gr_srcptr, gr_srcptr, gr_srcptr, gr_ctx_ptr));
0835 typedef int ((*gr_method_si_si_quaternary_op)(gr_ptr, slong, slong, gr_srcptr, gr_srcptr, gr_ctx_ptr));
0836 typedef truth_t ((*gr_method_unary_predicate)(gr_srcptr, gr_ctx_ptr));
0837 typedef truth_t ((*gr_method_binary_predicate)(gr_srcptr, gr_srcptr, gr_ctx_ptr));
0838 typedef void ((*gr_method_vec_init_clear_op)(gr_ptr, slong, gr_ctx_ptr));
0839 typedef void ((*gr_method_vec_swap_op)(gr_ptr, gr_ptr, slong, gr_ctx_ptr));
0840 typedef int ((*gr_method_vec_constant_op)(gr_ptr, slong, gr_ctx_ptr));
0841 typedef int ((*gr_method_vec_op)(gr_ptr, gr_srcptr, slong, gr_ctx_ptr));
0842 typedef int ((*gr_method_vec_vec_op)(gr_ptr, gr_srcptr, gr_srcptr, slong, gr_ctx_ptr));
0843 typedef int ((*gr_method_vec_scalar_op)(gr_ptr, gr_srcptr, slong, gr_srcptr, gr_ctx_ptr));
0844 typedef int ((*gr_method_scalar_vec_op)(gr_ptr, gr_srcptr, gr_srcptr, slong, gr_ctx_ptr));
0845 typedef int ((*gr_method_vec_op_other)(gr_ptr, gr_srcptr, gr_srcptr, gr_ctx_ptr, slong, gr_ctx_ptr));
0846 typedef int ((*gr_method_other_op_vec)(gr_ptr, gr_srcptr, gr_ctx_ptr, gr_srcptr, slong, gr_ctx_ptr));
0847 typedef int ((*gr_method_vec_op_scalar_other)(gr_ptr, gr_srcptr, slong, gr_srcptr, gr_ctx_ptr, gr_ctx_ptr));
0848 typedef int ((*gr_method_scalar_other_op_vec)(gr_ptr, gr_srcptr, gr_ctx_ptr, gr_srcptr, slong, gr_ctx_ptr));
0849 typedef int ((*gr_method_vec_scalar_op_si)(gr_ptr, gr_srcptr, slong, slong, gr_ctx_ptr));
0850 typedef int ((*gr_method_vec_scalar_op_ui)(gr_ptr, gr_srcptr, slong, ulong, gr_ctx_ptr));
0851 typedef int ((*gr_method_vec_scalar_op_fmpz)(gr_ptr, gr_srcptr, slong, const fmpz_t, gr_ctx_ptr));
0852 typedef int ((*gr_method_vec_scalar_op_fmpq)(gr_ptr, gr_srcptr, slong, const fmpq_t, gr_ctx_ptr));
0853 typedef truth_t ((*gr_method_vec_predicate)(gr_srcptr, slong, gr_ctx_ptr));
0854 typedef truth_t ((*gr_method_vec_vec_predicate)(gr_srcptr, gr_srcptr, slong, gr_ctx_ptr));
0855 typedef int ((*gr_method_factor_op)(gr_ptr, gr_vec_t, fmpz_vec_t, gr_srcptr, int, gr_ctx_ptr));
0856 typedef int ((*gr_method_poly_unary_trunc_op)(gr_ptr, gr_srcptr, slong, slong, gr_ctx_ptr));
0857 typedef int ((*gr_method_poly_binary_op)(gr_ptr, gr_srcptr, slong, gr_srcptr, slong, gr_ctx_ptr));
0858 typedef int ((*gr_method_poly_binary_binary_op)(gr_ptr, gr_ptr, gr_srcptr, slong, gr_srcptr, slong, gr_ctx_ptr));
0859 typedef int ((*gr_method_poly_binary_trunc_op)(gr_ptr, gr_srcptr, slong, gr_srcptr, slong, slong, gr_ctx_ptr));
0860 typedef int ((*gr_method_poly_binary_trunc2_op)(gr_ptr, gr_srcptr, slong, gr_srcptr, slong, slong, slong, gr_ctx_ptr));
0861 typedef int ((*gr_method_poly_gcd_op)(gr_ptr, slong *, gr_srcptr, slong, gr_srcptr, slong, gr_ctx_ptr));
0862 typedef int ((*gr_method_poly_xgcd_op)(slong *, gr_ptr, gr_ptr, gr_ptr, gr_srcptr, slong, gr_srcptr, slong, gr_ctx_ptr));
0863 typedef int ((*gr_method_vec_ctx_op)(gr_vec_t, gr_ctx_ptr));
0864 typedef slong ((*_gr_method_get_si_op)(gr_srcptr, gr_ctx_ptr));
0865
0866 #ifdef FEXPR_H
0867 typedef int ((*gr_method_get_fexpr_op)(fexpr_t, gr_srcptr, gr_ctx_ptr));
0868 typedef int ((*gr_method_set_fexpr_op)(gr_ptr, fexpr_vec_t, gr_vec_t, const fexpr_t, gr_ctx_ptr));
0869 #endif
0870
0871 /* Macros to retrieve methods (with correct call signature) from context object. */
0872 #define GR_CTX_OP(ctx, NAME) (((gr_method_ctx *) ctx->methods)[GR_METHOD_ ## NAME])
0873 #define GR_CTX_VOID_OP(ctx, NAME) (((gr_method_ctx_void_op *) ctx->methods)[GR_METHOD_ ## NAME])
0874 #define GR_CTX_STREAM(ctx, NAME) (((gr_method_ctx_stream *) ctx->methods)[GR_METHOD_ ## NAME])
0875 #define GR_CTX_PREDICATE(ctx, NAME) (((gr_method_ctx_predicate *) ctx->methods)[GR_METHOD_ ## NAME])
0876 #define GR_CTX_SIZE(ctx, NAME) (((gr_method_ctx_size *) ctx->methods)[GR_METHOD_ ## NAME])
0877 #define GR_CTX_GEN_NAME(ctx, NAME) (((gr_method_ctx_gen_name *) ctx->methods)[GR_METHOD_ ## NAME])
0878 #define GR_CTX_SET_SI(ctx, NAME) (((gr_method_ctx_set_si *) ctx->methods)[GR_METHOD_ ## NAME])
0879 #define GR_CTX_GET_SI(ctx, NAME) (((gr_method_ctx_get_si *) ctx->methods)[GR_METHOD_ ## NAME])
0880 #define GR_CTX_SET_TRUTH(ctx, NAME) (((gr_method_ctx_set_truth *) ctx->methods)[GR_METHOD_ ## NAME])
0881 #define GR_CTX_SET_STR(ctx, NAME) (((gr_method_ctx_set_str *) ctx->methods)[GR_METHOD_ ## NAME])
0882 #define GR_CTX_SET_STRS(ctx, NAME) (((gr_method_ctx_set_strs *) ctx->methods)[GR_METHOD_ ## NAME])
0883 #define GR_CTX_BASE(ctx, NAME) (((gr_method_ctx_base *) ctx->methods)[GR_METHOD_ ## NAME])
0884 #define GR_STREAM_IN(ctx, NAME) (((gr_method_stream_in *) ctx->methods)[GR_METHOD_ ## NAME])
0885 #define GR_STREAM_IN_SI(ctx, NAME) (((gr_method_stream_in_si *) ctx->methods)[GR_METHOD_ ## NAME])
0886 #define GR_RANDTEST(ctx, NAME) (((gr_method_randtest *) ctx->methods)[GR_METHOD_ ## NAME])
0887 #define GR_INIT_CLEAR_OP(ctx, NAME) (((gr_method_init_clear_op *) ctx->methods)[GR_METHOD_ ## NAME])
0888 #define GR_SWAP_OP(ctx, NAME) (((gr_method_swap_op *) ctx->methods)[GR_METHOD_ ## NAME])
0889 #define GR_CONSTANT_OP(ctx, NAME) (((gr_method_constant_op *) ctx->methods)[GR_METHOD_ ## NAME])
0890 #define GR_CONSTANT_OP_GET_SI(ctx, NAME) (((gr_method_constant_op_get_si *) ctx->methods)[GR_METHOD_ ## NAME])
0891 #define GR_CONSTANT_OP_GET_FMPZ(ctx, NAME) (((gr_method_constant_op_get_fmpz *) ctx->methods)[GR_METHOD_ ## NAME])
0892 #define GR_VOID_UNARY_OP(ctx, NAME) (((gr_method_void_unary_op *) ctx->methods)[GR_METHOD_ ## NAME])
0893 #define GR_UNARY_OP(ctx, NAME) (((gr_method_unary_op *) ctx->methods)[GR_METHOD_ ## NAME])
0894 #define GR_UNARY_OP_SI(ctx, NAME) (((gr_method_unary_op_si *) ctx->methods)[GR_METHOD_ ## NAME])
0895 #define GR_UNARY_OP_UI(ctx, NAME) (((gr_method_unary_op_ui *) ctx->methods)[GR_METHOD_ ## NAME])
0896 #define GR_UNARY_OP_FMPZ(ctx, NAME) (((gr_method_unary_op_fmpz *) ctx->methods)[GR_METHOD_ ## NAME])
0897 #define GR_UNARY_OP_FMPQ(ctx, NAME) (((gr_method_unary_op_fmpq *) ctx->methods)[GR_METHOD_ ## NAME])
0898 #define GR_UNARY_OP_D(ctx, NAME) (((gr_method_unary_op_d *) ctx->methods)[GR_METHOD_ ## NAME])
0899 #define GR_UNARY_OP_OTHER(ctx, NAME) (((gr_method_unary_op_other *) ctx->methods)[GR_METHOD_ ## NAME])
0900 #define GR_UNARY_OP_STR(ctx, NAME) (((gr_method_unary_op_str *) ctx->methods)[GR_METHOD_ ## NAME])
0901 #define GR_UNARY_OP_GET_SI(ctx, NAME) (((gr_method_unary_op_get_si *) ctx->methods)[GR_METHOD_ ## NAME])
0902 #define GR_UNARY_OP_GET_UI(ctx, NAME) (((gr_method_unary_op_get_ui *) ctx->methods)[GR_METHOD_ ## NAME])
0903 #define GR_UNARY_OP_GET_FMPZ(ctx, NAME) (((gr_method_unary_op_get_fmpz *) ctx->methods)[GR_METHOD_ ## NAME])
0904 #define GR_UNARY_OP_GET_FMPQ(ctx, NAME) (((gr_method_unary_op_get_fmpq *) ctx->methods)[GR_METHOD_ ## NAME])
0905 #define GR_UNARY_OP_GET_D(ctx, NAME) (((gr_method_unary_op_get_d *) ctx->methods)[GR_METHOD_ ## NAME])
0906 #define GR_UNARY_OP_GET_D_SI(ctx, NAME) (((gr_method_unary_op_get_d_si *) ctx->methods)[GR_METHOD_ ## NAME])
0907 #define GR_UNARY_OP_GET_FMPZ_FMPZ(ctx, NAME) (((gr_method_unary_op_get_fmpz_fmpz *) ctx->methods)[GR_METHOD_ ## NAME])
0908 #define GR_UNARY_OP_WITH_FLAG(ctx, NAME) (((gr_method_unary_op_with_flag *) ctx->methods)[GR_METHOD_ ## NAME])
0909 #define GR_BINARY_UNARY_OP(ctx, NAME) (((gr_method_binary_unary_op *) ctx->methods)[GR_METHOD_ ## NAME])
0910 #define GR_BINARY_UNARY_OP_WITH_FLAG(ctx, NAME) (((gr_method_binary_unary_op_with_flag *) ctx->methods)[GR_METHOD_ ## NAME])
0911 #define GR_TERNARY_UNARY_OP(ctx, NAME) (((gr_method_ternary_unary_op *) ctx->methods)[GR_METHOD_ ## NAME])
0912 #define GR_QUATERNARY_UNARY_OP(ctx, NAME) (((gr_method_quaternary_unary_op *) ctx->methods)[GR_METHOD_ ## NAME])
0913 #define GR_BINARY_OP(ctx, NAME) (((gr_method_binary_op *) ctx->methods)[GR_METHOD_ ## NAME])
0914 #define GR_BINARY_OP_SI(ctx, NAME) (((gr_method_binary_op_si *) ctx->methods)[GR_METHOD_ ## NAME])
0915 #define GR_BINARY_OP_UI(ctx, NAME) (((gr_method_binary_op_ui *) ctx->methods)[GR_METHOD_ ## NAME])
0916 #define GR_BINARY_OP_FMPZ(ctx, NAME) (((gr_method_binary_op_fmpz *) ctx->methods)[GR_METHOD_ ## NAME])
0917 #define GR_BINARY_OP_FMPQ(ctx, NAME) (((gr_method_binary_op_fmpq *) ctx->methods)[GR_METHOD_ ## NAME])
0918 #define GR_BINARY_OP_OTHER(ctx, NAME) (((gr_method_binary_op_other *) ctx->methods)[GR_METHOD_ ## NAME])
0919 #define GR_BINARY_OP_FMPZ_FMPZ(ctx, NAME) (((gr_method_binary_op_fmpz_fmpz *) ctx->methods)[GR_METHOD_ ## NAME])
0920 #define GR_BINARY_OP_FMPZ_SI(ctx, NAME) (((gr_method_binary_op_fmpz_si *) ctx->methods)[GR_METHOD_ ## NAME])
0921 #define GR_BINARY_OP_UI_UI(ctx, NAME) (((gr_method_binary_op_ui_ui *) ctx->methods)[GR_METHOD_ ## NAME])
0922 #define GR_BINARY_OP_UI_SI(ctx, NAME) (((gr_method_binary_op_ui_si *) ctx->methods)[GR_METHOD_ ## NAME])
0923 #define GR_OTHER_BINARY_OP(ctx, NAME) (((gr_method_other_binary_op *) ctx->methods)[GR_METHOD_ ## NAME])
0924 #define GR_SI_BINARY_OP(ctx, NAME) (((gr_method_si_binary_op *) ctx->methods)[GR_METHOD_ ## NAME])
0925 #define GR_UI_BINARY_OP(ctx, NAME) (((gr_method_ui_binary_op *) ctx->methods)[GR_METHOD_ ## NAME])
0926 #define GR_FMPZ_BINARY_OP(ctx, NAME) (((gr_method_fmpz_binary_op *) ctx->methods)[GR_METHOD_ ## NAME])
0927 #define GR_FMPQ_BINARY_OP(ctx, NAME) (((gr_method_fmpq_binary_op *) ctx->methods)[GR_METHOD_ ## NAME])
0928 #define GR_BINARY_OP_GET_INT(ctx, NAME) (((gr_method_binary_op_get_int *) ctx->methods)[GR_METHOD_ ## NAME])
0929 #define GR_BINARY_OP_OTHER_GET_INT(ctx, NAME) (((gr_method_binary_op_other_get_int *) ctx->methods)[GR_METHOD_ ## NAME])
0930 #define GR_BINARY_BINARY_OP(ctx, NAME) (((gr_method_binary_binary_op *) ctx->methods)[GR_METHOD_ ## NAME])
0931 #define GR_UNARY_PREDICATE(ctx, NAME) (((gr_method_unary_predicate *) ctx->methods)[GR_METHOD_ ## NAME])
0932 #define GR_BINARY_PREDICATE(ctx, NAME) (((gr_method_binary_predicate *) ctx->methods)[GR_METHOD_ ## NAME])
0933 #define GR_BINARY_OP_WITH_FLAG(ctx, NAME) (((gr_method_binary_op_with_flag *) ctx->methods)[GR_METHOD_ ## NAME])
0934 #define GR_BINARY_BINARY_OP_UI_UI(ctx, NAME) (((gr_method_binary_binary_op_ui_ui *) ctx->methods)[GR_METHOD_ ## NAME])
0935 #define GR_TERNARY_OP(ctx, NAME) (((gr_method_ternary_op *) ctx->methods)[GR_METHOD_ ## NAME])
0936 #define GR_TERNARY_OP_WITH_FLAG(ctx, NAME) (((gr_method_ternary_op_with_flag *) ctx->methods)[GR_METHOD_ ## NAME])
0937 #define GR_QUATERNARY_OP(ctx, NAME) (((gr_method_quaternary_op *) ctx->methods)[GR_METHOD_ ## NAME])
0938 #define GR_QUATERNARY_OP_WITH_FLAG(ctx, NAME) (((gr_method_quaternary_op_with_flag *) ctx->methods)[GR_METHOD_ ## NAME])
0939 #define GR_QUATERNARY_BINARY_OP(ctx, NAME) (((gr_method_quaternary_binary_op *) ctx->methods)[GR_METHOD_ ## NAME])
0940 #define GR_QUATERNARY_TERNARY_OP(ctx, NAME) (((gr_method_quaternary_ternary_op *) ctx->methods)[GR_METHOD_ ## NAME])
0941 #define GR_SI_SI_QUATERNARY_OP(ctx, NAME) (((gr_method_si_si_quaternary_op *) ctx->methods)[GR_METHOD_ ## NAME])
0942 #define GR_VEC_INIT_CLEAR_OP(ctx, NAME) (((gr_method_vec_init_clear_op *) ctx->methods)[GR_METHOD_ ## NAME])
0943 #define GR_VEC_SWAP_OP(ctx, NAME) (((gr_method_vec_swap_op *) ctx->methods)[GR_METHOD_ ## NAME])
0944 #define GR_VEC_CONSTANT_OP(ctx, NAME) (((gr_method_vec_constant_op *) ctx->methods)[GR_METHOD_ ## NAME])
0945 #define GR_VEC_OP(ctx, NAME) (((gr_method_vec_op *) ctx->methods)[GR_METHOD_ ## NAME])
0946 #define GR_VEC_VEC_OP(ctx, NAME) (((gr_method_vec_vec_op *) ctx->methods)[GR_METHOD_ ## NAME])
0947 #define GR_VEC_SCALAR_OP(ctx, NAME) (((gr_method_vec_scalar_op *) ctx->methods)[GR_METHOD_ ## NAME])
0948 #define GR_SCALAR_VEC_OP(ctx, NAME) (((gr_method_scalar_vec_op *) ctx->methods)[GR_METHOD_ ## NAME])
0949 #define GR_VEC_OP_OTHER(ctx, NAME) (((gr_method_vec_op_other *) ctx->methods)[GR_METHOD_ ## NAME])
0950 #define GR_OTHER_OP_VEC(ctx, NAME) (((gr_method_other_op_vec *) ctx->methods)[GR_METHOD_ ## NAME])
0951 #define GR_VEC_OP_SCALAR_OTHER(ctx, NAME) (((gr_method_vec_op_scalar_other *) ctx->methods)[GR_METHOD_ ## NAME])
0952 #define GR_SCALAR_OTHER_OP_VEC(ctx, NAME) (((gr_method_scalar_other_op_vec *) ctx->methods)[GR_METHOD_ ## NAME])
0953 #define GR_VEC_SCALAR_OP_SI(ctx, NAME) (((gr_method_vec_scalar_op_si *) ctx->methods)[GR_METHOD_ ## NAME])
0954 #define GR_VEC_SCALAR_OP_UI(ctx, NAME) (((gr_method_vec_scalar_op_ui *) ctx->methods)[GR_METHOD_ ## NAME])
0955 #define GR_VEC_SCALAR_OP_FMPZ(ctx, NAME) (((gr_method_vec_scalar_op_fmpz *) ctx->methods)[GR_METHOD_ ## NAME])
0956 #define GR_VEC_SCALAR_OP_FMPQ(ctx, NAME) (((gr_method_vec_scalar_op_fmpq *) ctx->methods)[GR_METHOD_ ## NAME])
0957 #define GR_VEC_PREDICATE(ctx, NAME) (((gr_method_vec_predicate *) ctx->methods)[GR_METHOD_ ## NAME])
0958 #define GR_VEC_VEC_PREDICATE(ctx, NAME) (((gr_method_vec_vec_predicate *) ctx->methods)[GR_METHOD_ ## NAME])
0959 #define GR_FACTOR_OP(ctx, NAME) (((gr_method_factor_op *) ctx->methods)[GR_METHOD_ ## NAME])
0960 #define GR_POLY_BINARY_OP(ctx, NAME) (((gr_method_poly_binary_op *) ctx->methods)[GR_METHOD_ ## NAME])
0961 #define GR_POLY_UNARY_TRUNC_OP(ctx, NAME) (((gr_method_poly_unary_trunc_op *) ctx->methods)[GR_METHOD_ ## NAME])
0962 #define GR_POLY_BINARY_BINARY_OP(ctx, NAME) (((gr_method_poly_binary_binary_op *) ctx->methods)[GR_METHOD_ ## NAME])
0963 #define GR_POLY_BINARY_TRUNC_OP(ctx, NAME) (((gr_method_poly_binary_trunc_op *) ctx->methods)[GR_METHOD_ ## NAME])
0964 #define GR_POLY_BINARY_TRUNC2_OP(ctx, NAME) (((gr_method_poly_binary_trunc2_op *) ctx->methods)[GR_METHOD_ ## NAME])
0965 #define GR_POLY_GCD_OP(ctx, NAME) (((gr_method_poly_gcd_op *) ctx->methods)[GR_METHOD_ ## NAME])
0966 #define GR_POLY_XGCD_OP(ctx, NAME) (((gr_method_poly_xgcd_op *) ctx->methods)[GR_METHOD_ ## NAME])
0967 #define GR_VEC_CTX_OP(ctx, NAME) (((gr_method_vec_ctx_op *) ctx->methods)[GR_METHOD_ ## NAME])
0968 #define _GR_GET_SI_OP(ctx, NAME) (((_gr_method_get_si_op *) ctx->methods)[_GR_METHOD_ ## NAME])
0969 #ifdef FEXPR_H
0970 #define GR_GET_FEXPR_OP(ctx, NAME) (((gr_method_get_fexpr_op *) ctx->methods)[GR_METHOD_ ## NAME])
0971 #define GR_SET_FEXPR_OP(ctx, NAME) (((gr_method_set_fexpr_op *) ctx->methods)[GR_METHOD_ ## NAME])
0972 #endif
0973
0974 /* Wrappers to call methods. */
0975
0976 GR_INLINE void gr_ctx_clear(gr_ctx_t ctx) { GR_CTX_VOID_OP(ctx, CTX_CLEAR)(ctx); }
0977 GR_INLINE int gr_ctx_write(gr_stream_t out, gr_ctx_t ctx) { return GR_CTX_STREAM(ctx, CTX_WRITE)(out, ctx); }
0978
0979 GR_INLINE truth_t gr_ctx_is_ring(gr_ctx_t ctx) { return GR_CTX_PREDICATE(ctx, CTX_IS_RING)(ctx); }
0980 GR_INLINE truth_t gr_ctx_is_commutative_ring(gr_ctx_t ctx) { return GR_CTX_PREDICATE(ctx, CTX_IS_COMMUTATIVE_RING)(ctx); }
0981 GR_INLINE truth_t gr_ctx_is_integral_domain(gr_ctx_t ctx) { return GR_CTX_PREDICATE(ctx, CTX_IS_INTEGRAL_DOMAIN)(ctx); }
0982 GR_INLINE truth_t gr_ctx_is_field(gr_ctx_t ctx) { return GR_CTX_PREDICATE(ctx, CTX_IS_FIELD)(ctx); }
0983 GR_INLINE truth_t gr_ctx_is_zero_ring(gr_ctx_t ctx) { return GR_CTX_PREDICATE(ctx, CTX_IS_ZERO_RING)(ctx); }
0984 GR_INLINE truth_t gr_ctx_is_rational_vector_space(gr_ctx_t ctx) { return GR_CTX_PREDICATE(ctx, CTX_IS_RATIONAL_VECTOR_SPACE)(ctx); }
0985 GR_INLINE truth_t gr_ctx_is_real_vector_space(gr_ctx_t ctx) { return GR_CTX_PREDICATE(ctx, CTX_IS_REAL_VECTOR_SPACE)(ctx); }
0986 GR_INLINE truth_t gr_ctx_is_complex_vector_space(gr_ctx_t ctx) { return GR_CTX_PREDICATE(ctx, CTX_IS_COMPLEX_VECTOR_SPACE)(ctx); }
0987 GR_INLINE truth_t gr_ctx_is_unique_factorization_domain(gr_ctx_t ctx) { return GR_CTX_PREDICATE(ctx, CTX_IS_UNIQUE_FACTORIZATION_DOMAIN)(ctx); }
0988 GR_INLINE truth_t gr_ctx_is_finite(gr_ctx_t ctx) { return GR_CTX_PREDICATE(ctx, CTX_IS_FINITE)(ctx); }
0989 GR_INLINE truth_t gr_ctx_is_finite_characteristic(gr_ctx_t ctx) { return GR_CTX_PREDICATE(ctx, CTX_IS_FINITE_CHARACTERISTIC)(ctx); }
0990 GR_INLINE truth_t gr_ctx_is_algebraically_closed(gr_ctx_t ctx) { return GR_CTX_PREDICATE(ctx, CTX_IS_ALGEBRAICALLY_CLOSED)(ctx); }
0991 GR_INLINE truth_t gr_ctx_is_ordered_ring(gr_ctx_t ctx) { return GR_CTX_PREDICATE(ctx, CTX_IS_ORDERED_RING)(ctx); }
0992
0993 GR_INLINE truth_t gr_ctx_is_approx_commutative_ring(gr_ctx_t ctx) { return GR_CTX_PREDICATE(ctx, CTX_IS_APPROX_COMMUTATIVE_RING)(ctx); }
0994
0995 GR_INLINE truth_t gr_ctx_is_multiplicative_group(gr_ctx_t ctx) { return GR_CTX_PREDICATE(ctx, CTX_IS_MULTIPLICATIVE_GROUP)(ctx); }
0996
0997 GR_INLINE truth_t gr_ctx_is_exact(gr_ctx_t ctx) { return GR_CTX_PREDICATE(ctx, CTX_IS_EXACT)(ctx); }
0998 GR_INLINE truth_t gr_ctx_is_canonical(gr_ctx_t ctx) { return GR_CTX_PREDICATE(ctx, CTX_IS_CANONICAL)(ctx); }
0999
1000 GR_INLINE truth_t gr_ctx_is_threadsafe(gr_ctx_t ctx) { return GR_CTX_PREDICATE(ctx, CTX_IS_THREADSAFE)(ctx); }
1001
1002 GR_INLINE truth_t gr_ctx_has_real_prec(gr_ctx_t ctx) { return GR_CTX_PREDICATE(ctx, CTX_HAS_REAL_PREC)(ctx); }
1003 GR_INLINE WARN_UNUSED_RESULT int gr_ctx_set_real_prec(gr_ctx_t ctx, slong prec) { return GR_CTX_SET_SI(ctx, CTX_SET_REAL_PREC)(ctx, prec); }
1004 GR_INLINE WARN_UNUSED_RESULT int gr_ctx_get_real_prec(slong * prec, gr_ctx_t ctx) { return GR_CTX_GET_SI(ctx, CTX_GET_REAL_PREC)(prec, ctx); }
1005
1006 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); }
1007 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); }
1008 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); }
1009 GR_INLINE int gr_ctx_ngens(slong * ngens, gr_ctx_t ctx) { return GR_CTX_GET_SI(ctx, CTX_NGENS)(ngens, ctx); }
1010 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); }
1011
1012 GR_INLINE slong _gr_ctx_get_real_prec(gr_ctx_t ctx)
1013 {
1014     slong res = 0;
1015     GR_IGNORE(gr_ctx_get_real_prec(&res, ctx));
1016     return res;
1017 }
1018
1019 GR_INLINE gr_ptr gr_ctx_base(gr_ctx_t ctx) { return GR_CTX_BASE(ctx, CTX_BASE)(ctx); }
1020
1021
1022 GR_INLINE void gr_init(gr_ptr res, gr_ctx_t ctx) { GR_INIT_CLEAR_OP(ctx, INIT)(res, ctx); }
1023 GR_INLINE void gr_clear(gr_ptr res, gr_ctx_t ctx) { GR_INIT_CLEAR_OP(ctx, CLEAR)(res, ctx); }
1024 GR_INLINE void gr_swap(gr_ptr x, gr_ptr y, gr_ctx_t ctx) { GR_SWAP_OP(ctx, SWAP)(x, y, ctx); }
1025 GR_INLINE void gr_set_shallow(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) { GR_VOID_UNARY_OP(ctx, SET_SHALLOW)(res, x, ctx); }
1026
1027 GR_INLINE void _gr_length(gr_srcptr x, gr_ctx_t ctx) { _GR_GET_SI_OP(ctx, LENGTH)(x, ctx); }
1028
1029 GR_INLINE WARN_UNUSED_RESULT int gr_randtest(gr_ptr x, flint_rand_t state, gr_ctx_t ctx) { return GR_RANDTEST(ctx, RANDTEST)(x, state, ctx); }
1030 GR_INLINE WARN_UNUSED_RESULT int gr_randtest_not_zero(gr_ptr x, flint_rand_t state, gr_ctx_t ctx) { return GR_RANDTEST(ctx, RANDTEST_NOT_ZERO)(x, state, ctx); }
1031 GR_INLINE WARN_UNUSED_RESULT int gr_randtest_invertible(gr_ptr x, flint_rand_t state, gr_ctx_t ctx) { return GR_RANDTEST(ctx, RANDTEST_INVERTIBLE)(x, state, ctx); }
1032 GR_INLINE WARN_UNUSED_RESULT int gr_randtest_small(gr_ptr x, flint_rand_t state, gr_ctx_t ctx) { return GR_RANDTEST(ctx, RANDTEST_SMALL)(x, state, ctx); }
1033 GR_INLINE /* todo: warn? */ int gr_write(gr_stream_t out, gr_srcptr x, gr_ctx_t ctx) { return GR_STREAM_IN(ctx, WRITE)(out, x, ctx); }
1034 GR_INLINE /* todo: warn? */ int gr_write_n(gr_stream_t out, gr_srcptr x, slong n, gr_ctx_t ctx) { return GR_STREAM_IN_SI(ctx, WRITE_N)(out, x, n, ctx); }
1035 GR_INLINE WARN_UNUSED_RESULT int gr_zero(gr_ptr res, gr_ctx_t ctx) { return GR_CONSTANT_OP(ctx, ZERO)(res, ctx); }
1036 GR_INLINE WARN_UNUSED_RESULT int gr_one(gr_ptr res, gr_ctx_t ctx) { return GR_CONSTANT_OP(ctx, ONE)(res, ctx); }
1037 GR_INLINE WARN_UNUSED_RESULT int gr_neg_one(gr_ptr res, gr_ctx_t ctx) { return GR_CONSTANT_OP(ctx, NEG_ONE)(res, ctx); }
1038
1039 GR_INLINE WARN_UNUSED_RESULT int gr_set(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) { return GR_UNARY_OP(ctx, SET)(res, x, ctx); }
1040 GR_INLINE WARN_UNUSED_RESULT int gr_set_si(gr_ptr res, slong x, gr_ctx_t ctx) { return GR_UNARY_OP_SI(ctx, SET_SI)(res, x, ctx); }
1041 GR_INLINE WARN_UNUSED_RESULT int gr_set_ui(gr_ptr res, ulong x, gr_ctx_t ctx) { return GR_UNARY_OP_SI(ctx, SET_UI)(res, x, ctx); }
1042 GR_INLINE WARN_UNUSED_RESULT int gr_set_fmpz(gr_ptr res, const fmpz_t x, gr_ctx_t ctx) { return GR_UNARY_OP_FMPZ(ctx, SET_FMPZ)(res, x, ctx); }
1043 GR_INLINE WARN_UNUSED_RESULT int gr_set_fmpq(gr_ptr res, const fmpq_t x, gr_ctx_t ctx) { return GR_UNARY_OP_FMPQ(ctx, SET_FMPQ)(res, x, ctx); }
1044 GR_INLINE WARN_UNUSED_RESULT int gr_set_d(gr_ptr res, double x, gr_ctx_t ctx) { return GR_UNARY_OP_D(ctx, SET_D)(res, x, ctx); }
1045 GR_INLINE WARN_UNUSED_RESULT int gr_set_other(gr_ptr res, gr_srcptr x, gr_ctx_t x_ctx, gr_ctx_t ctx) { return GR_UNARY_OP_OTHER(ctx, SET_OTHER)(res, x, x_ctx, ctx); }
1046 GR_INLINE WARN_UNUSED_RESULT int gr_set_str(gr_ptr res, const char * x, gr_ctx_t ctx) { return GR_UNARY_OP_STR(ctx, SET_STR)(res, x, ctx); }
1047
1048 GR_INLINE WARN_UNUSED_RESULT int gr_get_si(slong * res, gr_srcptr x, gr_ctx_t ctx) { return GR_UNARY_OP_GET_SI(ctx, GET_SI)(res, x, ctx); }
1049 GR_INLINE WARN_UNUSED_RESULT int gr_get_ui(ulong * res, gr_srcptr x, gr_ctx_t ctx) { return GR_UNARY_OP_GET_UI(ctx, GET_UI)(res, x, ctx); }
1050 GR_INLINE WARN_UNUSED_RESULT int gr_get_fmpz(fmpz_t res, gr_srcptr x, gr_ctx_t ctx) { return GR_UNARY_OP_GET_FMPZ(ctx, GET_FMPZ)(res, x, ctx); }
1051 GR_INLINE WARN_UNUSED_RESULT int gr_get_fmpq(fmpq_t res, gr_srcptr x, gr_ctx_t ctx) { return GR_UNARY_OP_GET_FMPQ(ctx, GET_FMPQ)(res, x, ctx); }
1052 GR_INLINE WARN_UNUSED_RESULT int gr_get_d(double * res, gr_srcptr x, gr_ctx_t ctx) { return GR_UNARY_OP_GET_D(ctx, GET_D)(res, x, ctx); }
1053
1054 #define GR_FEXPR_SERIALIZE (UWORD(1) << 31)
1055 #define GR_FEXPR_COMPACT (UWORD(1) << 30)
1056
1057 #ifdef FEXPR_H
1058 GR_INLINE WARN_UNUSED_RESULT int gr_get_fexpr(fexpr_t res, gr_srcptr x, gr_ctx_t ctx) { return GR_GET_FEXPR_OP(ctx, GET_FEXPR)(res, x, ctx); }
1059 GR_INLINE WARN_UNUSED_RESULT int gr_get_fexpr_serialize(fexpr_t res, gr_srcptr x, gr_ctx_t ctx) { return GR_GET_FEXPR_OP(ctx, GET_FEXPR_SERIALIZE)(res, x, ctx); }
1060 GR_INLINE WARN_UNUSED_RESULT int gr_set_fexpr(gr_ptr res, fexpr_vec_t inputs, gr_vec_t outputs, const fexpr_t x, gr_ctx_t ctx) { return GR_SET_FEXPR_OP(ctx, SET_FEXPR)(res, inputs, outputs, x, ctx); }
1061 #endif
1062
1063 GR_INLINE truth_t gr_is_zero(gr_srcptr x, gr_ctx_t ctx) { return GR_UNARY_PREDICATE(ctx, IS_ZERO)(x, ctx); }
1064 GR_INLINE truth_t gr_is_one(gr_srcptr x, gr_ctx_t ctx) { return GR_UNARY_PREDICATE(ctx, IS_ONE)(x, ctx); }
1065 GR_INLINE truth_t gr_is_neg_one(gr_srcptr x, gr_ctx_t ctx) { return GR_UNARY_PREDICATE(ctx, IS_NEG_ONE)(x, ctx); }
1066
1067 GR_INLINE truth_t gr_equal(gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) { return GR_BINARY_PREDICATE(ctx, EQUAL)(x, y, ctx); }
1068 GR_INLINE truth_t gr_not_equal(gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) { return truth_not(GR_BINARY_PREDICATE(ctx, EQUAL)(x, y, ctx)); }
1069
1070 GR_INLINE WARN_UNUSED_RESULT int gr_neg(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) { return GR_UNARY_OP(ctx, NEG)(res, x, ctx); }
1071
1072 GR_INLINE WARN_UNUSED_RESULT int gr_add(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) { return GR_BINARY_OP(ctx, ADD)(res, x, y, ctx); }
1073 GR_INLINE WARN_UNUSED_RESULT int gr_add_ui(gr_ptr res, gr_srcptr x, ulong y, gr_ctx_t ctx) { return GR_BINARY_OP_UI(ctx, ADD_UI)(res, x, y, ctx); }
1074 GR_INLINE WARN_UNUSED_RESULT int gr_add_si(gr_ptr res, gr_srcptr x, slong y, gr_ctx_t ctx) { return GR_BINARY_OP_SI(ctx, ADD_SI)(res, x, y, ctx); }
1075 GR_INLINE WARN_UNUSED_RESULT int gr_add_fmpz(gr_ptr res, gr_srcptr x, const fmpz_t y, gr_ctx_t ctx) { return GR_BINARY_OP_FMPZ(ctx, ADD_FMPZ)(res, x, y, ctx); }
1076 GR_INLINE WARN_UNUSED_RESULT int gr_add_fmpq(gr_ptr res, gr_srcptr x, const fmpq_t y, gr_ctx_t ctx) { return GR_BINARY_OP_FMPQ(ctx, ADD_FMPQ)(res, x, y, ctx); }
1077 GR_INLINE WARN_UNUSED_RESULT int gr_add_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, ADD_OTHER)(res, x, y, y_ctx, ctx); }
1078 GR_INLINE WARN_UNUSED_RESULT int gr_other_add(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_ADD)(res, x, x_ctx, y, ctx); }
1079
1080 GR_INLINE WARN_UNUSED_RESULT int gr_sub(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) { return GR_BINARY_OP(ctx, SUB)(res, x, y, ctx); }
1081 GR_INLINE WARN_UNUSED_RESULT int gr_sub_ui(gr_ptr res, gr_srcptr x, ulong y, gr_ctx_t ctx) { return GR_BINARY_OP_UI(ctx, SUB_UI)(res, x, y, ctx); }
1082 GR_INLINE WARN_UNUSED_RESULT int gr_sub_si(gr_ptr res, gr_srcptr x, slong y, gr_ctx_t ctx) { return GR_BINARY_OP_SI(ctx, SUB_SI)(res, x, y, ctx); }
1083 GR_INLINE WARN_UNUSED_RESULT int gr_sub_fmpz(gr_ptr res, gr_srcptr x, const fmpz_t y, gr_ctx_t ctx) { return GR_BINARY_OP_FMPZ(ctx, SUB_FMPZ)(res, x, y, ctx); }
1084 GR_INLINE WARN_UNUSED_RESULT int gr_sub_fmpq(gr_ptr res, gr_srcptr x, const fmpq_t y, gr_ctx_t ctx) { return GR_BINARY_OP_FMPQ(ctx, SUB_FMPQ)(res, x, y, ctx); }
1085 GR_INLINE WARN_UNUSED_RESULT int gr_sub_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, SUB_OTHER)(res, x, y, y_ctx, ctx); }
1086 GR_INLINE WARN_UNUSED_RESULT int gr_other_sub(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_SUB)(res, x, x_ctx, y, ctx); }
1087
1088 GR_INLINE WARN_UNUSED_RESULT int gr_mul(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) { return GR_BINARY_OP(ctx, MUL)(res, x, y, ctx); }
1089 GR_INLINE WARN_UNUSED_RESULT int gr_mul_ui(gr_ptr res, gr_srcptr x, ulong y, gr_ctx_t ctx) { return GR_BINARY_OP_UI(ctx, MUL_UI)(res, x, y, ctx); }
1090 GR_INLINE WARN_UNUSED_RESULT int gr_mul_si(gr_ptr res, gr_srcptr x, slong y, gr_ctx_t ctx) { return GR_BINARY_OP_SI(ctx, MUL_SI)(res, x, y, ctx); }
1091 GR_INLINE WARN_UNUSED_RESULT int gr_mul_fmpz(gr_ptr res, gr_srcptr x, const fmpz_t y, gr_ctx_t ctx) { return GR_BINARY_OP_FMPZ(ctx, MUL_FMPZ)(res, x, y, ctx); }
1092 GR_INLINE WARN_UNUSED_RESULT int gr_mul_fmpq(gr_ptr res, gr_srcptr x, const fmpq_t y, gr_ctx_t ctx) { return GR_BINARY_OP_FMPQ(ctx, MUL_FMPQ)(res, x, y, ctx); }
1093 GR_INLINE WARN_UNUSED_RESULT int gr_mul_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, MUL_OTHER)(res, x, y, y_ctx, ctx); }
1094 GR_INLINE WARN_UNUSED_RESULT int gr_other_mul(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_MUL)(res, x, x_ctx, y, ctx); }
1095
1096 GR_INLINE WARN_UNUSED_RESULT int gr_addmul(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) { return GR_BINARY_OP(ctx, ADDMUL)(res, x, y, ctx); }
1097 GR_INLINE WARN_UNUSED_RESULT int gr_addmul_ui(gr_ptr res, gr_srcptr x, ulong y, gr_ctx_t ctx) { return GR_BINARY_OP_UI(ctx, ADDMUL_UI)(res, x, y, ctx); }
1098 GR_INLINE WARN_UNUSED_RESULT int gr_addmul_si(gr_ptr res, gr_srcptr x, slong y, gr_ctx_t ctx) { return GR_BINARY_OP_SI(ctx, ADDMUL_SI)(res, x, y, ctx); }
1099 GR_INLINE WARN_UNUSED_RESULT int gr_addmul_fmpz(gr_ptr res, gr_srcptr x, const fmpz_t y, gr_ctx_t ctx) { return GR_BINARY_OP_FMPZ(ctx, ADDMUL_FMPZ)(res, x, y, ctx); }
1100 GR_INLINE WARN_UNUSED_RESULT int gr_addmul_fmpq(gr_ptr res, gr_srcptr x, const fmpq_t y, gr_ctx_t ctx) { return GR_BINARY_OP_FMPQ(ctx, ADDMUL_FMPQ)(res, x, y, ctx); }
1101 GR_INLINE WARN_UNUSED_RESULT int gr_addmul_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, ADDMUL_OTHER)(res, x, y, y_ctx, ctx); }
1102
1103 GR_INLINE WARN_UNUSED_RESULT int gr_submul(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) { return GR_BINARY_OP(ctx, SUBMUL)(res, x, y, ctx); }
1104 GR_INLINE WARN_UNUSED_RESULT int gr_submul_ui(gr_ptr res, gr_srcptr x, ulong y, gr_ctx_t ctx) { return GR_BINARY_OP_UI(ctx, SUBMUL_UI)(res, x, y, ctx); }
1105 GR_INLINE WARN_UNUSED_RESULT int gr_submul_si(gr_ptr res, gr_srcptr x, slong y, gr_ctx_t ctx) { return GR_BINARY_OP_SI(ctx, SUBMUL_SI)(res, x, y, ctx); }
1106 GR_INLINE WARN_UNUSED_RESULT int gr_submul_fmpz(gr_ptr res, gr_srcptr x, const fmpz_t y, gr_ctx_t ctx) { return GR_BINARY_OP_FMPZ(ctx, SUBMUL_FMPZ)(res, x, y, ctx); }
1107 GR_INLINE WARN_UNUSED_RESULT int gr_submul_fmpq(gr_ptr res, gr_srcptr x, const fmpq_t y, gr_ctx_t ctx) { return GR_BINARY_OP_FMPQ(ctx, SUBMUL_FMPQ)(res, x, y, ctx); }
1108 GR_INLINE WARN_UNUSED_RESULT int gr_submul_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, SUBMUL_OTHER)(res, x, y, y_ctx, ctx); }
1109
1110 GR_INLINE WARN_UNUSED_RESULT int gr_mul_two(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) { return GR_UNARY_OP(ctx, MUL_TWO)(res, x, ctx); }
1111 GR_INLINE WARN_UNUSED_RESULT int gr_sqr(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) { return GR_UNARY_OP(ctx, SQR)(res, x, ctx); }
1112
1113 GR_INLINE WARN_UNUSED_RESULT int gr_mul_2exp_si(gr_ptr res, gr_srcptr x, slong y, gr_ctx_t ctx) { return GR_BINARY_OP_SI(ctx, MUL_2EXP_SI)(res, x, y, ctx); }
1114 GR_INLINE WARN_UNUSED_RESULT int gr_mul_2exp_fmpz(gr_ptr res, gr_srcptr x, const fmpz_t y, gr_ctx_t ctx) { return GR_BINARY_OP_FMPZ(ctx, MUL_2EXP_FMPZ)(res, x, y, ctx); }
1115 GR_INLINE WARN_UNUSED_RESULT int gr_set_fmpz_2exp_fmpz(gr_ptr res, const fmpz_t x, const fmpz_t y, gr_ctx_t ctx) { return GR_BINARY_OP_FMPZ_FMPZ(ctx, SET_FMPZ_2EXP_FMPZ)(res, x, y, ctx); }
1116 GR_INLINE WARN_UNUSED_RESULT int gr_get_fmpz_2exp_fmpz(fmpz_t res1, fmpz_t res2, gr_srcptr x, gr_ctx_t ctx) { return GR_UNARY_OP_GET_FMPZ_FMPZ(ctx, GET_FMPZ_2EXP_FMPZ)(res1, res2, x, ctx); }
1117 GR_INLINE WARN_UNUSED_RESULT int gr_set_fmpz_10exp_fmpz(gr_ptr res, const fmpz_t x, const fmpz_t y, gr_ctx_t ctx) { return GR_BINARY_OP_FMPZ_FMPZ(ctx, SET_FMPZ_10EXP_FMPZ)(res, x, y, ctx); }
1118 GR_INLINE WARN_UNUSED_RESULT int gr_get_d_2exp_si(double * res, slong * exp, gr_srcptr x, gr_ctx_t ctx) { return GR_UNARY_OP_GET_D_SI(ctx, GET_D_2EXP_SI)(res, exp, x, ctx); }
1119
1120 GR_INLINE WARN_UNUSED_RESULT int gr_inv(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) { return GR_UNARY_OP(ctx, INV)(res, x, ctx); }
1121 GR_INLINE truth_t gr_is_invertible(gr_srcptr x, gr_ctx_t ctx) { return GR_UNARY_PREDICATE(ctx, IS_INVERTIBLE)(x, ctx); }
1122
1123 GR_INLINE WARN_UNUSED_RESULT int gr_div(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) { return GR_BINARY_OP(ctx, DIV)(res, x, y, ctx); }
1124 GR_INLINE WARN_UNUSED_RESULT int gr_div_ui(gr_ptr res, gr_srcptr x, ulong y, gr_ctx_t ctx) { return GR_BINARY_OP_UI(ctx, DIV_UI)(res, x, y, ctx); }
1125 GR_INLINE WARN_UNUSED_RESULT int gr_div_si(gr_ptr res, gr_srcptr x, slong y, gr_ctx_t ctx) { return GR_BINARY_OP_SI(ctx, DIV_SI)(res, x, y, ctx); }
1126 GR_INLINE WARN_UNUSED_RESULT int gr_div_fmpz(gr_ptr res, gr_srcptr x, const fmpz_t y, gr_ctx_t ctx) { return GR_BINARY_OP_FMPZ(ctx, DIV_FMPZ)(res, x, y, ctx); }
1127 GR_INLINE WARN_UNUSED_RESULT int gr_div_fmpq(gr_ptr res, gr_srcptr x, const fmpq_t y, gr_ctx_t ctx) { return GR_BINARY_OP_FMPQ(ctx, DIV_FMPQ)(res, x, y, ctx); }
1128 GR_INLINE WARN_UNUSED_RESULT int gr_div_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, DIV_OTHER)(res, x, y, y_ctx, ctx); }
1129 GR_INLINE WARN_UNUSED_RESULT int gr_other_div(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_DIV)(res, x, x_ctx, y, ctx); }
1130
1131 GR_INLINE WARN_UNUSED_RESULT int gr_div_nonunique(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) { return GR_BINARY_OP(ctx, DIV_NONUNIQUE)(res, x, y, ctx); }
1132 GR_INLINE truth_t gr_divides(gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) { return GR_BINARY_PREDICATE(ctx, DIVIDES)(x, y, ctx); }
1133
1134 GR_INLINE WARN_UNUSED_RESULT int gr_divexact(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) { return GR_BINARY_OP(ctx, DIVEXACT)(res, x, y, ctx); }
1135 GR_INLINE WARN_UNUSED_RESULT int gr_divexact_ui(gr_ptr res, gr_srcptr x, ulong y, gr_ctx_t ctx) { return GR_BINARY_OP_UI(ctx, DIVEXACT_UI)(res, x, y, ctx); }
1136 GR_INLINE WARN_UNUSED_RESULT int gr_divexact_si(gr_ptr res, gr_srcptr x, slong y, gr_ctx_t ctx) { return GR_BINARY_OP_SI(ctx, DIVEXACT_SI)(res, x, y, ctx); }
1137 GR_INLINE WARN_UNUSED_RESULT int gr_divexact_fmpz(gr_ptr res, gr_srcptr x, const fmpz_t y, gr_ctx_t ctx) { return GR_BINARY_OP_FMPZ(ctx, DIVEXACT_FMPZ)(res, x, y, ctx); }
1138 GR_INLINE WARN_UNUSED_RESULT int gr_divexact_fmpq(gr_ptr res, gr_srcptr x, const fmpq_t y, gr_ctx_t ctx) { return GR_BINARY_OP_FMPQ(ctx, DIVEXACT_FMPQ)(res, x, y, ctx); }
1139 GR_INLINE WARN_UNUSED_RESULT int gr_divexact_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, DIVEXACT_OTHER)(res, x, y, y_ctx, ctx); }
1140 GR_INLINE WARN_UNUSED_RESULT int gr_other_divexact(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_DIVEXACT)(res, x, x_ctx, y, ctx); }
1141
1142 GR_INLINE WARN_UNUSED_RESULT int gr_euclidean_div(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) { return GR_BINARY_OP(ctx, EUCLIDEAN_DIV)(res, x, y, ctx); }
1143 GR_INLINE WARN_UNUSED_RESULT int gr_euclidean_rem(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) { return GR_BINARY_OP(ctx, EUCLIDEAN_REM)(res, x, y, ctx); }
1144 GR_INLINE WARN_UNUSED_RESULT int gr_euclidean_divrem(gr_ptr res1, gr_ptr res2, gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) { return GR_BINARY_BINARY_OP(ctx, EUCLIDEAN_DIVREM)(res1, res2, x, y, ctx); }
1145 GR_INLINE WARN_UNUSED_RESULT int gr_gcd(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) { return GR_BINARY_OP(ctx, GCD)(res, x, y, ctx); }
1146 GR_INLINE WARN_UNUSED_RESULT int gr_lcm(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) { return GR_BINARY_OP(ctx, LCM)(res, x, y, ctx); }
1147
1148 GR_INLINE WARN_UNUSED_RESULT int gr_numerator(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) { return GR_UNARY_OP(ctx, NUMERATOR)(res, x, ctx); }
1149 GR_INLINE WARN_UNUSED_RESULT int gr_denominator(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) { return GR_UNARY_OP(ctx, DENOMINATOR)(res, x, ctx); }
1150
1151 GR_INLINE WARN_UNUSED_RESULT int gr_factor(gr_ptr c, gr_vec_t factors, fmpz_vec_t exponents, gr_srcptr x, int flags, gr_ctx_t ctx) { return GR_FACTOR_OP(ctx, FACTOR)(c, factors, exponents, x, flags, ctx); }
1152
1153 GR_INLINE WARN_UNUSED_RESULT int gr_pow(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) { return GR_BINARY_OP(ctx, POW)(res, x, y, ctx); }
1154 GR_INLINE WARN_UNUSED_RESULT int gr_pow_ui(gr_ptr res, gr_srcptr x, ulong y, gr_ctx_t ctx) { return GR_BINARY_OP_UI(ctx, POW_UI)(res, x, y, ctx); }
1155 GR_INLINE WARN_UNUSED_RESULT int gr_pow_si(gr_ptr res, gr_srcptr x, slong y, gr_ctx_t ctx) { return GR_BINARY_OP_SI(ctx, POW_SI)(res, x, y, ctx); }
1156 GR_INLINE WARN_UNUSED_RESULT int gr_pow_fmpz(gr_ptr res, gr_srcptr x, const fmpz_t y, gr_ctx_t ctx) { return GR_BINARY_OP_FMPZ(ctx, POW_FMPZ)(res, x, y, ctx); }
1157 GR_INLINE WARN_UNUSED_RESULT int gr_pow_fmpq(gr_ptr res, gr_srcptr x, const fmpq_t y, gr_ctx_t ctx) { return GR_BINARY_OP_FMPQ(ctx, POW_FMPQ)(res, x, y, ctx); }
1158 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); }
1159 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); }
1160
1161 GR_INLINE WARN_UNUSED_RESULT int gr_derivative_gen(gr_ptr res, gr_srcptr x, slong var, gr_ctx_t ctx) { return GR_BINARY_OP_SI(ctx, DERIVATIVE_GEN)(res, x, var, ctx); }
1162
1163 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); }
1164 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); }
1165 GR_INLINE truth_t gr_is_square(gr_srcptr x, gr_ctx_t ctx) { return GR_UNARY_PREDICATE(ctx, IS_SQUARE)(x, ctx); }
1166
1167 GR_INLINE WARN_UNUSED_RESULT int gr_floor(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) { return GR_UNARY_OP(ctx, FLOOR)(res, x, ctx); }
1168 GR_INLINE WARN_UNUSED_RESULT int gr_ceil(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) { return GR_UNARY_OP(ctx, CEIL)(res, x, ctx); }
1169 GR_INLINE WARN_UNUSED_RESULT int gr_trunc(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) { return GR_UNARY_OP(ctx, TRUNC)(res, x, ctx); }
1170 GR_INLINE WARN_UNUSED_RESULT int gr_nint(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) { return GR_UNARY_OP(ctx, NINT)(res, x, ctx); }
1171
1172 GR_INLINE WARN_UNUSED_RESULT int gr_abs(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) { return GR_UNARY_OP(ctx, ABS)(res, x, ctx); }
1173 GR_INLINE WARN_UNUSED_RESULT int gr_i(gr_ptr res, gr_ctx_t ctx) { return GR_CONSTANT_OP(ctx, I)(res, ctx); }
1174 GR_INLINE WARN_UNUSED_RESULT int gr_conj(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) { return GR_UNARY_OP(ctx, CONJ)(res, x, ctx); }
1175 GR_INLINE WARN_UNUSED_RESULT int gr_re(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) { return GR_UNARY_OP(ctx, RE)(res, x, ctx); }
1176 GR_INLINE WARN_UNUSED_RESULT int gr_im(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) { return GR_UNARY_OP(ctx, IM)(res, x, ctx); }
1177 GR_INLINE WARN_UNUSED_RESULT int gr_sgn(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) { return GR_UNARY_OP(ctx, SGN)(res, x, ctx); }
1178 GR_INLINE WARN_UNUSED_RESULT int gr_csgn(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) { return GR_UNARY_OP(ctx, CSGN)(res, x, ctx); }
1179 GR_INLINE WARN_UNUSED_RESULT int gr_arg(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) { return GR_UNARY_OP(ctx, ARG)(res, x, ctx); }
1180 GR_INLINE WARN_UNUSED_RESULT int gr_canonical_associate(gr_ptr res1, gr_ptr res2, gr_srcptr x, gr_ctx_t ctx) { return GR_BINARY_UNARY_OP(ctx, CANONICAL_ASSOCIATE)(res1, res2, x, ctx); }
1181
1182 GR_INLINE WARN_UNUSED_RESULT int gr_pos_inf(gr_ptr res, gr_ctx_t ctx) { return GR_CONSTANT_OP(ctx, POS_INF)(res, ctx); }
1183 GR_INLINE WARN_UNUSED_RESULT int gr_neg_inf(gr_ptr res, gr_ctx_t ctx) { return GR_CONSTANT_OP(ctx, NEG_INF)(res, ctx); }
1184 GR_INLINE WARN_UNUSED_RESULT int gr_uinf(gr_ptr res, gr_ctx_t ctx) { return GR_CONSTANT_OP(ctx, UINF)(res, ctx); }
1185 GR_INLINE WARN_UNUSED_RESULT int gr_undefined(gr_ptr res, gr_ctx_t ctx) { return GR_CONSTANT_OP(ctx, UNDEFINED)(res, ctx); }
1186 GR_INLINE WARN_UNUSED_RESULT int gr_unknown(gr_ptr res, gr_ctx_t ctx) { return GR_CONSTANT_OP(ctx, UNKNOWN)(res, ctx); }
1187
1188 GR_INLINE WARN_UNUSED_RESULT int gr_cmp(int * res, gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) { return GR_BINARY_OP_GET_INT(ctx, CMP)(res, x, y, ctx); }
1189 GR_INLINE WARN_UNUSED_RESULT int gr_cmpabs(int * res, gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) { return GR_BINARY_OP_GET_INT(ctx, CMPABS)(res, x, y, ctx); }
1190 GR_INLINE WARN_UNUSED_RESULT int gr_cmp_other(int * res, gr_srcptr x, gr_srcptr y, gr_ctx_t y_ctx, gr_ctx_t ctx) { return GR_BINARY_OP_OTHER_GET_INT(ctx, CMP_OTHER)(res, x, y, y_ctx, ctx); }
1191 GR_INLINE WARN_UNUSED_RESULT int gr_cmpabs_other(int * res, gr_srcptr x, gr_srcptr y, gr_ctx_t y_ctx, gr_ctx_t ctx) { return GR_BINARY_OP_OTHER_GET_INT(ctx, CMPABS_OTHER)(res, x, y, y_ctx, ctx); }
1192
1193 #define __GR_CMP(cfun, expr) \
1194     int cmp; \
1195     if ((cfun)(&cmp, x, y, ctx) != GR_SUCCESS) \
1196         return T_UNKNOWN; \
1197     return (expr) ? T_TRUE : T_FALSE; \
1198
1199 GR_INLINE WARN_UNUSED_RESULT truth_t gr_le(gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) { __GR_CMP(gr_cmp, cmp <= 0) }
1200 GR_INLINE WARN_UNUSED_RESULT truth_t gr_lt(gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) { __GR_CMP(gr_cmp, cmp < 0) }
1201 GR_INLINE WARN_UNUSED_RESULT truth_t gr_ge(gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) { __GR_CMP(gr_cmp, cmp >= 0) }
1202 GR_INLINE WARN_UNUSED_RESULT truth_t gr_gt(gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) { __GR_CMP(gr_cmp, cmp > 0) }
1203
1204 GR_INLINE WARN_UNUSED_RESULT truth_t gr_abs_le(gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) { __GR_CMP(gr_cmpabs, cmp <= 0) }
1205 GR_INLINE WARN_UNUSED_RESULT truth_t gr_abs_lt(gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) { __GR_CMP(gr_cmpabs, cmp < 0) }
1206 GR_INLINE WARN_UNUSED_RESULT truth_t gr_abs_ge(gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) { __GR_CMP(gr_cmpabs, cmp >= 0) }
1207 GR_INLINE WARN_UNUSED_RESULT truth_t gr_abs_gt(gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) { __GR_CMP(gr_cmpabs, cmp > 0) }
1208
1209 GR_INLINE WARN_UNUSED_RESULT int gr_min(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) { return GR_BINARY_OP(ctx, MIN)(res, x, y, ctx); }
1210 GR_INLINE WARN_UNUSED_RESULT int gr_max(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) { return GR_BINARY_OP(ctx, MAX)(res, x, y, ctx); }
1211
1212 GR_INLINE WARN_UNUSED_RESULT int gr_gen(gr_ptr res, gr_ctx_t ctx) { return GR_CONSTANT_OP(ctx, GEN)(res, ctx); }
1213 GR_INLINE WARN_UNUSED_RESULT int gr_gens(gr_vec_t res, gr_ctx_t ctx) { return GR_VEC_CTX_OP(ctx, GENS)(res, ctx); }
1214 GR_INLINE WARN_UNUSED_RESULT int gr_gens_recursive(gr_vec_t res, gr_ctx_t ctx) { return GR_VEC_CTX_OP(ctx, GENS_RECURSIVE)(res, ctx); }
1215
1216 GR_INLINE WARN_UNUSED_RESULT int gr_big_o_base_fmpz(gr_ptr res, gr_srcptr base, const fmpz_t exp, gr_ctx_t ctx) { return GR_BINARY_OP_FMPZ(ctx, BIG_O_BASE_FMPZ)(res, base, exp, ctx); }
1217
1218 GR_INLINE WARN_UNUSED_RESULT int gr_ctx_fq_prime(fmpz_t res, gr_ctx_t ctx) { return GR_CONSTANT_OP_GET_FMPZ(ctx, CTX_FQ_PRIME)(res, ctx); }
1219 GR_INLINE WARN_UNUSED_RESULT int gr_ctx_fq_degree(slong * res, gr_ctx_t ctx) { return GR_CONSTANT_OP_GET_SI(ctx, CTX_FQ_DEGREE)(res, ctx); }
1220 GR_INLINE WARN_UNUSED_RESULT int gr_ctx_fq_order(fmpz_t res, gr_ctx_t ctx) { return GR_CONSTANT_OP_GET_FMPZ(ctx, CTX_FQ_ORDER)(res, ctx); }
1221
1222 GR_INLINE WARN_UNUSED_RESULT int gr_fq_frobenius(gr_ptr res, gr_srcptr x, slong e, gr_ctx_t ctx) { return GR_BINARY_OP_SI(ctx, FQ_FROBENIUS)(res, x, e, ctx); }
1223 GR_INLINE WARN_UNUSED_RESULT int gr_fq_multiplicative_order(fmpz_t res, gr_srcptr x, gr_ctx_t ctx) { return GR_UNARY_OP_GET_FMPZ(ctx, FQ_MULTIPLICATIVE_ORDER)(res, x, ctx); }
1224 GR_INLINE WARN_UNUSED_RESULT int gr_fq_norm(fmpz_t res, gr_srcptr x, gr_ctx_t ctx) { return GR_UNARY_OP_GET_FMPZ(ctx, FQ_NORM)(res, x, ctx); }
1225 GR_INLINE WARN_UNUSED_RESULT int gr_fq_trace(fmpz_t res, gr_srcptr x, gr_ctx_t ctx) { return GR_UNARY_OP_GET_FMPZ(ctx, FQ_TRACE)(res, x, ctx); }
1226 GR_INLINE WARN_UNUSED_RESULT truth_t gr_fq_is_primitive(gr_srcptr x, gr_ctx_t ctx) { return GR_UNARY_PREDICATE(ctx, FQ_IS_PRIMITIVE)(x, ctx); }
1227 GR_INLINE WARN_UNUSED_RESULT int gr_fq_pth_root(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) { return GR_UNARY_OP(ctx, FQ_PTH_ROOT)(res, x, ctx); }
1228
1229 GR_INLINE WARN_UNUSED_RESULT int gr_set_interval_mid_rad(gr_ptr res, gr_srcptr m, gr_srcptr r, gr_ctx_t ctx) { return GR_BINARY_OP(ctx, SET_INTERVAL_MID_RAD)(res, m, r, ctx); }
1230
1231 GR_INLINE void _gr_vec_init(gr_ptr vec, slong len, gr_ctx_t ctx) { GR_VEC_INIT_CLEAR_OP(ctx, VEC_INIT)(vec, len, ctx); }
1232 GR_INLINE void _gr_vec_clear(gr_ptr vec, slong len, gr_ctx_t ctx) { GR_VEC_INIT_CLEAR_OP(ctx, VEC_CLEAR)(vec, len, ctx); }
1233 GR_INLINE void _gr_vec_swap(gr_ptr vec1, gr_ptr vec2, slong len, gr_ctx_t ctx) { GR_VEC_SWAP_OP(ctx, VEC_SWAP)(vec1, vec2, len, ctx); }
1234
1235 /* todo: warn unused? */
1236 int gr_ctx_print(gr_ctx_t ctx);
1237 int gr_ctx_println(gr_ctx_t ctx);
1238 int gr_print(gr_srcptr x, gr_ctx_t ctx);
1239 int gr_println(gr_srcptr x, gr_ctx_t ctx);
1240 int gr_ctx_get_str(char ** s, gr_ctx_t ctx);
1241 int gr_get_str(char ** s, gr_srcptr x, gr_ctx_t ctx);
1242 int gr_get_str_n(char ** s, gr_srcptr x, slong n, gr_ctx_t ctx);
1243
1244 /* Macros for allocating temporary variables on the stack. */
1245 /* todo: use vector init/clear functions when provided */
1246
1247 #define GR_TMP_VEC_ALLOC_MAX_STACK 1024
1248 #define GR_TMP_ALLOC(size) (((size) <= GR_TMP_VEC_ALLOC_MAX_STACK) ? alloca(size) : flint_malloc(size))
1249 #define GR_TMP_FREE(ptr, size) do { if ((size) > GR_TMP_VEC_ALLOC_MAX_STACK) flint_free(ptr); } while (0)
1250 #define GR_TMP_ALLOC_SMALL(size) alloca(size)
1251
1252 #define GR_TMP_INIT_VEC(vec, len, ctx) \
1253     do { \
1254         gr_method_vec_init_clear_op vec_init = GR_VEC_INIT_CLEAR_OP(ctx, VEC_INIT); \
1255         slong _gr_elem_size = (ctx)->sizeof_elem; \
1256         (vec) = (gr_ptr) GR_TMP_ALLOC((len) * _gr_elem_size); \
1257         vec_init((vec), (len), (ctx)); \
1258     } while (0)
1259
1260 #define GR_TMP_CLEAR_VEC(vec, len, ctx) \
1261     do { \
1262         gr_method_vec_init_clear_op vec_clear = GR_VEC_INIT_CLEAR_OP(ctx, VEC_CLEAR); \
1263         slong _gr_elem_size = (ctx)->sizeof_elem; \
1264         vec_clear((vec), (len), (ctx)); \
1265         GR_TMP_FREE(vec, (len) * _gr_elem_size); \
1266     } while (0)
1267
1268 #define GR_TMP_INIT(x1, ctx) \
1269     do { \
1270         gr_method_init_clear_op init = GR_INIT_CLEAR_OP(ctx, INIT); \
1271         slong _gr_elem_size = (ctx)->sizeof_elem; \
1272         x1 = (gr_ptr) GR_TMP_ALLOC_SMALL(1 * _gr_elem_size); \
1273         init(x1, (ctx)); \
1274     } while (0)
1275
1276 #define GR_TMP_INIT2(x1, x2, ctx) \
1277     do { \
1278         gr_method_init_clear_op init = GR_INIT_CLEAR_OP(ctx, INIT); \
1279         slong _gr_elem_size = (ctx)->sizeof_elem; \
1280         x1 = (gr_ptr) GR_TMP_ALLOC_SMALL(2 * _gr_elem_size); \
1281         x2 = (gr_ptr) ((char *) x1 + _gr_elem_size); \
1282         init(x1, (ctx)); \
1283         init(x2, (ctx)); \
1284     } while (0)
1285
1286 #define GR_TMP_INIT3(x1, x2, x3, ctx) \
1287     do { \
1288         gr_method_init_clear_op init = GR_INIT_CLEAR_OP(ctx, INIT); \
1289         slong _gr_elem_size = (ctx)->sizeof_elem; \
1290         x1 = (gr_ptr) GR_TMP_ALLOC_SMALL(3 * _gr_elem_size); \
1291         x2 = (gr_ptr) ((char *) x1 + _gr_elem_size); \
1292         x3 = (gr_ptr) ((char *) x2 + _gr_elem_size); \
1293         init(x1, (ctx)); \
1294         init(x2, (ctx)); \
1295         init(x3, (ctx)); \
1296     } while (0)
1297
1298 #define GR_TMP_INIT4(x1, x2, x3, x4, ctx) \
1299     do { \
1300         gr_method_init_clear_op init = GR_INIT_CLEAR_OP(ctx, INIT); \
1301         slong _gr_elem_size = (ctx)->sizeof_elem; \
1302         x1 = (gr_ptr) GR_TMP_ALLOC_SMALL(4 * _gr_elem_size); \
1303         x2 = (gr_ptr) ((char *) x1 + _gr_elem_size); \
1304         x3 = (gr_ptr) ((char *) x2 + _gr_elem_size); \
1305         x4 = (gr_ptr) ((char *) x3 + _gr_elem_size); \
1306         init(x1, (ctx)); \
1307         init(x2, (ctx)); \
1308         init(x3, (ctx)); \
1309         init(x4, (ctx)); \
1310     } while (0)
1311
1312 #define GR_TMP_INIT5(x1, x2, x3, x4, x5, ctx) \
1313     do { \
1314         gr_method_init_clear_op init = GR_INIT_CLEAR_OP(ctx, INIT); \
1315         slong _gr_elem_size = (ctx)->sizeof_elem; \
1316         x1 = (gr_ptr) GR_TMP_ALLOC_SMALL(5 * _gr_elem_size); \
1317         x2 = (gr_ptr) ((char *) x1 + _gr_elem_size); \
1318         x3 = (gr_ptr) ((char *) x2 + _gr_elem_size); \
1319         x4 = (gr_ptr) ((char *) x3 + _gr_elem_size); \
1320         x5 = (gr_ptr) ((char *) x4 + _gr_elem_size); \
1321         init(x1, (ctx)); \
1322         init(x2, (ctx)); \
1323         init(x3, (ctx)); \
1324         init(x4, (ctx)); \
1325         init(x5, (ctx)); \
1326     } while (0)
1327
1328 #define GR_TMP_CLEAR(x1, ctx) \
1329     do { \
1330         gr_method_init_clear_op clear = GR_INIT_CLEAR_OP(ctx, CLEAR); \
1331         clear(x1, (ctx)); \
1332     } while (0)
1333
1334 #define GR_TMP_CLEAR2(x1, x2, ctx) \
1335     do { \
1336         gr_method_init_clear_op clear = GR_INIT_CLEAR_OP(ctx, CLEAR); \
1337         clear(x1, (ctx)); \
1338         clear(x2, (ctx)); \
1339     } while (0)
1340
1341 #define GR_TMP_CLEAR3(x1, x2, x3, ctx) \
1342     do { \
1343         gr_method_init_clear_op clear = GR_INIT_CLEAR_OP(ctx, CLEAR); \
1344         clear(x1, (ctx)); \
1345         clear(x2, (ctx)); \
1346         clear(x3, (ctx)); \
1347     } while (0)
1348
1349 #define GR_TMP_CLEAR4(x1, x2, x3, x4, ctx) \
1350     do { \
1351         gr_method_init_clear_op clear = GR_INIT_CLEAR_OP(ctx, CLEAR); \
1352         clear(x1, (ctx)); \
1353         clear(x2, (ctx)); \
1354         clear(x3, (ctx)); \
1355         clear(x4, (ctx)); \
1356     } while (0)
1357
1358 #define GR_TMP_CLEAR5(x1, x2, x3, x4, x5, ctx) \
1359     do { \
1360         gr_method_init_clear_op clear = GR_INIT_CLEAR_OP(ctx, CLEAR); \
1361         clear(x1, (ctx)); \
1362         clear(x2, (ctx)); \
1363         clear(x3, (ctx)); \
1364         clear(x4, (ctx)); \
1365         clear(x5, (ctx)); \
1366     } while (0)
1367
1368 GR_INLINE gr_ptr gr_heap_init(gr_ctx_t ctx)
1369 {
1370     gr_ptr ptr;
1371     ptr = (gr_ptr) flint_malloc(ctx->sizeof_elem);
1372     gr_init(ptr, ctx);
1373     return ptr;
1374 }
1375
1376 GR_INLINE void gr_heap_clear(gr_ptr x, gr_ctx_t ctx)
1377 {
1378     gr_clear(x, ctx);
1379     flint_free(x);
1380 }
1381
1382 GR_INLINE gr_ptr gr_heap_init_vec(slong len, gr_ctx_t ctx)
1383 {
1384     gr_ptr ptr;
1385     ptr = (gr_ptr) flint_malloc(len * ctx->sizeof_elem);
1386     _gr_vec_init(ptr, len, ctx);
1387     return ptr;
1388 }
1389
1390 GR_INLINE void gr_heap_clear_vec(gr_ptr x, slong len, gr_ctx_t ctx)
1391 {
1392     _gr_vec_clear(x, len, ctx);
1393     flint_free(x);
1394 }
1395
1396 truth_t gr_generic_ctx_predicate(gr_ctx_t ctx);
1397 truth_t gr_generic_ctx_predicate_true(gr_ctx_t ctx);
1398 truth_t gr_generic_ctx_predicate_false(gr_ctx_t ctx);
1399
1400 /* Some base rings */
1401
1402 void gr_ctx_uninitialized(gr_ctx_t ctx);
1403
1404 void gr_ctx_init_random(gr_ctx_t ctx, flint_rand_t state);
1405 void gr_ctx_init_random_commutative_ring(gr_ctx_t ctx, flint_rand_t state);
1406 void gr_ctx_init_random_field(gr_ctx_t ctx, flint_rand_t state);
1407 void gr_ctx_init_random_finite_field(gr_ctx_t ctx, flint_rand_t state);
1408 void gr_ctx_init_random_poly(gr_ctx_t ctx, flint_rand_t state);
1409 void gr_ctx_init_random_mpoly(gr_ctx_t ctx, flint_rand_t state);
1410 void gr_ctx_init_random_series(gr_ctx_t ctx, flint_rand_t state);
1411
1412 void gr_ctx_init_fmpz(gr_ctx_t ctx);
1413 void gr_ctx_init_fmpq(gr_ctx_t ctx);
1414 void gr_ctx_init_fmpzi(gr_ctx_t ctx);
1415
1416 void gr_ctx_init_fmpz_mod(gr_ctx_t ctx, const fmpz_t n);
1417 void _gr_ctx_init_fmpz_mod_from_ref(gr_ctx_t ctx, const void * fmod_ctx);
1418
1419 int gr_ctx_init_nmod(gr_ctx_t ctx, ulong n);
1420 void _gr_ctx_init_nmod(gr_ctx_t ctx, void * nmod_t_ref);
1421
1422 int gr_ctx_init_nmod8(gr_ctx_t ctx, ulong n);
1423 int gr_ctx_init_nmod32(gr_ctx_t ctx, ulong n);
1424
1425 int gr_ctx_init_mpn_mod(gr_ctx_t ctx, const fmpz_t n);
1426
1427 void gr_ctx_init_real_qqbar(gr_ctx_t ctx);
1428 void gr_ctx_init_complex_qqbar(gr_ctx_t ctx);
1429 void _gr_ctx_qqbar_set_limits(gr_ctx_t ctx, slong deg_limit, slong bits_limit);
1430
1431 void gr_ctx_init_real_arb(gr_ctx_t ctx, slong prec);
1432 void gr_ctx_init_complex_acb(gr_ctx_t ctx, slong prec);
1433
1434 void gr_ctx_init_real_float_arf(gr_ctx_t ctx, slong prec);
1435 void gr_ctx_init_complex_float_acf(gr_ctx_t ctx, slong prec);
1436
1437 void gr_ctx_init_mpf(gr_ctx_t ctx, slong prec);
1438
1439 void gr_ctx_init_real_ca(gr_ctx_t ctx);
1440 void gr_ctx_init_complex_ca(gr_ctx_t ctx);
1441 void gr_ctx_init_real_algebraic_ca(gr_ctx_t ctx);
1442 void gr_ctx_init_complex_algebraic_ca(gr_ctx_t ctx);
1443 void gr_ctx_init_complex_extended_ca(gr_ctx_t ctx);
1444 void _gr_ctx_init_ca_from_ref(gr_ctx_t ctx, int which_ring, void * ca_ctx);
1445 void gr_ctx_ca_set_option(gr_ctx_t ctx, slong option, slong value);
1446 slong gr_ctx_ca_get_option(gr_ctx_t ctx, slong option);
1447
1448 void gr_ctx_init_fq(gr_ctx_t ctx, const fmpz_t p, slong d, const char * var);
1449 void gr_ctx_init_fq_nmod(gr_ctx_t ctx, ulong p, slong d, const char * var);
1450 void gr_ctx_init_fq_zech(gr_ctx_t ctx, ulong p, slong d, const char * var);
1451
1452 void _gr_ctx_init_fq_from_ref(gr_ctx_t ctx, const void * fq_ctx);
1453 void _gr_ctx_init_fq_nmod_from_ref(gr_ctx_t ctx, const void * fq_nmod_ctx);
1454 void _gr_ctx_init_fq_zech_from_ref(gr_ctx_t ctx, const void * fq_zech_ctx);
1455
1456 void gr_ctx_init_fmpz_poly(gr_ctx_t ctx);
1457 void gr_ctx_init_fmpq_poly(gr_ctx_t ctx);
1458
1459 #ifdef FMPQ_POLY_H
1460 void gr_ctx_init_nf(gr_ctx_t ctx, const fmpq_poly_t poly);
1461 void gr_ctx_init_nf_fmpz_poly(gr_ctx_t ctx, const fmpz_poly_t poly);
1462 void _gr_ctx_init_nf_from_ref(gr_ctx_t ctx, const void * nfctx);
1463 #endif
1464
1465 /* Groups */
1466
1467 void gr_ctx_init_perm(gr_ctx_t ctx, ulong n);
1468 void gr_ctx_init_psl2z(gr_ctx_t ctx);
1469 int gr_ctx_init_dirichlet_group(gr_ctx_t ctx, ulong q);
1470
1471 /* Generic polynomial ring */
1472
1473 typedef struct
1474 {
1475     gr_ctx_struct * base_ring;
1476     slong degree_limit;
1477     char * var;
1478 }
1479 polynomial_ctx_t;
1480
1481 #define POLYNOMIAL_CTX(ring_ctx) ((polynomial_ctx_t *)((ring_ctx)))
1482 #define POLYNOMIAL_ELEM_CTX(ring_ctx) (POLYNOMIAL_CTX(ring_ctx)->base_ring)
1483
1484 void gr_ctx_init_gr_poly(gr_ctx_t ctx, gr_ctx_t base_ring);
1485
1486 /* Multivariate */
1487
1488 #ifdef MPOLY_H
1489 void gr_ctx_init_fmpz_mpoly(gr_ctx_t ctx, slong nvars, const ordering_t ord);
1490 void gr_ctx_init_fmpq_mpoly(gr_ctx_t ctx, slong nvars, const ordering_t ord);
1491 void gr_ctx_init_gr_mpoly(gr_ctx_t ctx, gr_ctx_t base_ring, slong nvars, const ordering_t ord);
1492 #endif
1493
1494 #ifdef FMPZ_MPOLY_Q_H
1495 void gr_ctx_init_fmpz_mpoly_q(gr_ctx_t ctx, slong nvars, const ordering_t ord);
1496 #endif
1497
1498 #ifdef FMPZ_MOD_MPOLY_Q_H
1499 void gr_ctx_init_fmpz_mod_mpoly_q(gr_ctx_t ctx, slong nvars, const ordering_t ord, const fmpz_t mod);
1500 #endif
1501
1502 /* Generic fractions */
1503
1504 #define GR_FRACTION_NO_REDUCTION        1
1505 #define GR_FRACTION_STRONGLY_CANONICAL  2
1506
1507 void gr_ctx_init_gr_fraction(gr_ctx_t ctx, gr_ctx_t domain, int flags);
1508
1509 /* Generic complex numbers */
1510
1511 void gr_ctx_init_gr_complex(gr_ctx_t ctx, gr_ctx_t real_ctx);
1512
1513 /* Generic series - moved to gr_series.h */
1514
1515 void gr_ctx_init_gr_series(gr_ctx_t ctx, gr_ctx_t base_ring, slong prec);
1516 void gr_ctx_init_series_mod_gr_poly(gr_ctx_t ctx, gr_ctx_t base_ring, slong n);
1517
1518 /* Generic vectors */
1519
1520 typedef struct
1521 {
1522     gr_ctx_struct * base_ring;
1523     int all_sizes;
1524     slong n;
1525 }
1526 vector_ctx_t;
1527
1528 #define VECTOR_CTX(ring_ctx) ((vector_ctx_t *)((ring_ctx)))
1529
1530 void gr_ctx_init_vector_gr_vec(gr_ctx_t ctx, gr_ctx_t base_ring);
1531 void gr_ctx_init_vector_space_gr_vec(gr_ctx_t ctx, gr_ctx_t base_ring, slong n);
1532
1533 /* Generic matrix ring */
1534
1535 typedef struct
1536 {
1537     gr_ctx_struct * base_ring;
1538     int all_sizes;
1539     slong nrows;
1540     slong ncols;
1541 }
1542 matrix_ctx_t;
1543
1544 #define MATRIX_CTX(ring_ctx) ((matrix_ctx_t *)((ring_ctx)))
1545
1546 void gr_ctx_init_matrix_domain(gr_ctx_t ctx, gr_ctx_t base_ring);
1547 void gr_ctx_init_matrix_space(gr_ctx_t ctx, gr_ctx_t base_ring, slong nrows, slong ncols);
1548 truth_t gr_ctx_matrix_is_fixed_size(gr_ctx_t ctx);
1549
1550 GR_INLINE void gr_ctx_init_matrix_ring(gr_ctx_t ctx, gr_ctx_t base_ring, slong n)
1551 {
1552     gr_ctx_init_matrix_space(ctx, base_ring, n, n);
1553 }
1554
1555 /* Expressions */
1556
1557 void gr_ctx_init_fexpr(gr_ctx_t ctx);
1558
1559 /* Coercions */
1560
1561 int gr_ctx_cmp_coercion(gr_ctx_t ctx1, gr_ctx_t ctx2);
1562
1563 /* Testing */
1564
1565 #define GR_DEBUG_WRAP                     1
1566 #define GR_DEBUG_VERBOSE                  2
1567 #define GR_DEBUG_CHECK_ALWAYS_ABLE        4
1568 #define GR_DEBUG_TIMING                   8
1569
1570 void gr_ctx_init_debug(gr_ctx_t ctx, gr_ctx_t elem_ctx, int flags, double unable_probability);
1571
1572 #define GR_TEST_VERBOSE 8
1573 #define GR_TEST_ALWAYS_ABLE 16
1574
1575 /* todo: just have gr_test_structure() */
1576 void gr_test_ring(gr_ctx_t R, slong iters, int test_flags);
1577 void gr_test_multiplicative_group(gr_ctx_t R, slong iters, int test_flags);
1578 void gr_test_floating_point(gr_ctx_t R, slong iters, int test_flags);
1579
1580 int gr_test_cmp_fun(gr_ctx_t R, gr_method_binary_op_get_int op, gr_ctx_t R_ref, flint_rand_t state, int test_flags);
1581 int gr_test_approx_unary_op(gr_ctx_t R, gr_method_unary_op op, gr_ctx_t R_ref, gr_srcptr rel_tol, flint_rand_t state, int test_flags);
1582 int gr_test_approx_binary_op(gr_ctx_t R, gr_method_binary_op op, gr_ctx_t R_ref, gr_srcptr rel_tol, flint_rand_t state, int test_flags);
1583 int gr_test_approx_binary_op_type_variants(gr_ctx_t R, const char * opname,
1584     gr_method_binary_op gr_op,
1585     gr_method_binary_op_ui gr_op_ui,
1586     gr_method_binary_op_si gr_op_si,
1587     gr_method_binary_op_fmpz gr_op_fmpz,
1588     gr_method_binary_op_fmpq gr_op_fmpq,
1589     int fused,
1590     int small_test_values,
1591     gr_srcptr rel_tol, flint_rand_t state, int test_flags);
1592 int gr_test_approx_dot(gr_ctx_t R, gr_ctx_t R_ref, slong maxlen, gr_srcptr rel_tol, flint_rand_t state, int test_flags);
1593 int gr_test_factor(gr_ctx_t R, flint_rand_t state, int test_flags);
1594 int gr_test_pow_ui_exponent_addition(gr_ctx_t R, flint_rand_t state, int test_flags);
1595 int gr_test_pow_ui_base_scalar_multiplication(gr_ctx_t R, flint_rand_t state, int test_flags);
1596 int gr_test_pow_ui_base_multiplication(gr_ctx_t R, flint_rand_t state, int test_flags);
1597 int gr_test_pow_ui_aliasing(gr_ctx_t R, flint_rand_t state, int test_flags);
1598 int gr_test_pow_fmpz_exponent_addition(gr_ctx_t R, flint_rand_t state, int test_flags);
1599
1600 #ifdef __cplusplus
1601 }
1602 #endif
1603
1604 #endif