gr.h

Initialises ctx to the ring of integers \mathbb{Z} with elements of type fmpz.

Initialises ctx to the field of rational numbers \mathbb{Q} with elements of type fmpq.

Initialises ctx to the ring of Gaussian integers \mathbb{Z}[i] with elements of type fmpzi_struct (see fmpzi).

Initialises ctx to \mathbb{Z}/n\mathbb{Z} for any modulus n \ge 1, with elements of type fmpz reduced to [0, n). The context allocates an fmpz_mod_ctx_t. Primality of n is not tested: gr_ctx_is_field returns T_UNKNOWN until it is declared with gr_ctx_set_is_field. For moduli between 2^{64} and 2^{1024}, gr_ctx_init_mpn_mod is faster.

Initialises ctx to \mathbb{Z}/n\mathbb{Z} using an existing fmpz_mod_ctx_t, which is not copied and must outlive ctx. Used by fmpz_mod_poly and related modules to call generic algorithms.

Initialise ctx to the finite field \mathbb{F}_q with q = p^d, using a Conway polynomial if one is in the database and otherwise an irreducible polynomial of minimal weight (see Defining polynomials). The prime p is assumed and not checked. The generator is printed as var, or a if var is NULL. The element types are fq_struct, fq_nmod_struct and fq_zech_struct; the fq_zech field stores discrete logarithm tables of size q, so it is only practical for small q (and requires q < 2^{\mathtt{FLINT\_BITS}}). The contexts allocate the underlying fq_ctx_t. The context of fq_default, which chooses one of these representations from the size of q, is itself a gr context.

Initialise ctx to the finite field described by an existing fq_ctx_t, fq_nmod_ctx_t or fq_zech_ctx_t, which is not copied and must outlive ctx. The constructors with a given modulus (gr_ctx_init_fq_nmod_modulus_nmod_poly and similar) are documented in the finite field modules.

Initialise ctx to the number field \mathbb{Q}[a]/(f) defined by the polynomial f = poly, with elements of type nf_elem_struct (see nf_elem). The polynomial must be irreducible; this is not checked. The context allocates an nf_t with precomputed data, so it is more expensive to create than most contexts. Declared only if fmpq_poly.h is included before gr.h.

Initialises ctx to the number field described by an existing nf_t, which is not copied and must outlive ctx.

Initialise ctx to the field of real algebraic numbers \overline{\mathbb{Q}} \cap \mathbb{R}, respectively all algebraic numbers \overline{\mathbb{Q}}, with elements of type qqbar_struct (a minimal polynomial and an isolating ball; see qqbar and the guide to qqbar). Arithmetic is exact and equality is decidable, but the degree of results can grow quickly.

Limits the degrees of intermediate algebraic numbers of a qqbar context to deg_limit and their bit sizes to about bits_limit; a negative value removes the limit (the default). An operation that would exceed a limit returns GR_UNABLE. The limits refer to the sizes of resultants before factorisation (see qqbar_binop_within_limits), so adding two numbers of degree 100 needs a degree limit of at least 10000. Not all methods respect the limits.

Initialise ctx to the field of real or complex numbers represented by balls of type arb_struct and acb_struct, computing with a working precision of prec bits. The precision can be changed with gr_ctx_set_real_prec. Every result is an enclosure of the exact result; predicates return T_UNKNOWN when the balls do not decide them.

Initialise ctx to the field of real numbers, complex numbers, real algebraic numbers or complex algebraic numbers, represented exactly by elements of type ca_struct (see ca and the guide to ca). Operations whose result is not in the field (for example \sqrt{-1} in the reals, \pi in the algebraic numbers) return GR_DOMAIN, and predicates that cannot be decided return T_UNKNOWN. The context allocates a ca_ctx_t; it is not thread-safe (gr_ctx_is_threadsafe returns T_FALSE).

As gr_ctx_init_complex_ca, also allowing the special values of ca: signed and unsigned infinities, Undefined and Unknown. This is not a field.

Initialises ctx to one of the ca structures, selected by which_ring (GR_CTX_RR_CA, GR_CTX_CC_CA, GR_CTX_REAL_ALGEBRAIC_CA, GR_CTX_COMPLEX_ALGEBRAIC_CA or GR_CTX_COMPLEX_EXTENDED_CA), using an existing ca_ctx_t that is not copied and must outlive ctx.

Set or get an option (such as CA_OPT_PREC_LIMIT) of the ca_ctx_t of a ca context, as ca_ctx_set_option and ca_ctx_get_option.

Initialises ctx to the algebra R[i] with i^2 = -1 over the ring R given by real_ctx. An element a + bi is stored as the pair (a, b) of elements of R, contiguously.

Initialise ctx to binary floating-point numbers with elements of type arf_struct, respectively complex floating-point numbers of type acf_struct, with precision prec bits.

Initialises ctx to the GMP floating-point numbers mpf_t with precision prec bits. Only basic arithmetic, comparisons and a few conversions are implemented; this context exists mainly for comparison with the mpf-based algorithms of fmpz_lll.

Initialises ctx to the set of vectors of any length over base_ring, with elements of type gr_vec_struct and componentwise arithmetic. Operations on vectors of different lengths return GR_DOMAIN. This is not a ring.

Initialises ctx to the space R^n of vectors of length n over base_ring, with elements of type gr_vec_struct. With componentwise multiplication this is the ring R^n, a product of rings.

Initialises ctx to the set of matrices of any shape over base_ring, with elements of type gr_mat_struct. Operations on matrices of incompatible shapes return GR_DOMAIN, as does gr_one, since there is no single identity.

Initialise ctx to the space of nrows by ncols matrices over base_ring, respectively the ring M_n(R) of n \times n matrices, with elements of type gr_mat_struct.

Returns T_TRUE for a matrix space or ring of fixed shape and T_FALSE for the domain of matrices of all shapes. ctx must be a matrix context.

Initialise ctx to the ring of univariate polynomials \mathbb{Z}[x], respectively \mathbb{Q}[x], with elements of type fmpz_poly_struct and fmpq_poly_struct, using the arithmetic of fmpz_poly and fmpq_poly.

Initialises ctx to the ring R[x] of densely represented univariate polynomials over base_ring, with elements of type gr_poly_struct; see gr_poly. The generator is named x by default (gr_ctx_set_gen_name changes it). Over inexact rings the length of a polynomial is only an upper bound for its degree (Weak normalisation).

Initialise ctx to the ring of sparse multivariate polynomials in nvars variables with the monomial ordering ord, over \mathbb{Z} (fmpz_mpoly_struct elements), over \mathbb{Q} (fmpq_mpoly_struct), or over base_ring (gr_mpoly_struct, see gr_mpoly). The variables are named x1, x2, ... by default. Declared only if mpoly.h is included before gr.h.

Aliases of gr_series_ctx_init (power series R[[x]] with an error term O(x^{\mathit{prec}}) tracked per element) and gr_series_mod_ctx_init (the exact ring R[x]/(x^n)).

Initialises ctx to the quotient ring F[x] / (m) of the polynomial ring over the commutative ring F = base by the monic polynomial m = modulus. Elements have type gr_poly_struct and are kept reduced modulo m. Throws an exception if m is zero or not monic. The context stores precomputed data for reduction modulo m, a gr_poly_preinv_t whose representation is chosen by the method GR_METHOD_POLY_PREINV_SET of the base ring, which is used for multiplication and for powers.

Return the current modulus, the base ring, and the degree of the modulus.

Replaces the modulus by new_modulus, which must be monic of degree at least 1, and returns GR_DOMAIN otherwise. If the new modulus divides the old one (for instance a factor recovered from a zero divisor), existing elements remain valid representatives of their images in the new ring: they are reduced by subsequent operations, so no conversion is needed. Previous moduli are kept until the context is cleared, so that a pointer obtained from gr_poly_quotient_ctx_modulus stays valid.

Returns a counter that is incremented by each refinement.

Access the table of nontrivial monic factors of the modulus discovered by failed inversions while the ring pretends to be a field: the number of entries, entry i, and clearing the table. Recording is thread-safe, but these accessors must not be used concurrently with operations that may record a new factor.

Convert between elements of the quotient ring and polynomials over the base ring; the result is reduced modulo the current modulus.

Initialises ctx to the fraction field of the integral domain domain. A fraction is stored as two consecutive elements of the domain (numerator, denominator). By default fractions are reduced by removing the common content with gr_gcd and the denominator is normalised by gr_canonical_associate. flags is a combination of GR_FRACTION_NO_REDUCTION and GR_FRACTION_STRONGLY_CANONICAL, or 0.

Initialises ctx to the field \mathbb{Q}(x_1, \ldots, x_n) of multivariate rational functions with n = nvars, with elements of type fmpz_mpoly_q_struct (see fmpz_mpoly_q). Declared only if fmpz_mpoly_q.h is included before gr.h.

Initialises ctx to the same field \mathbb{Q}(x_1, \ldots, x_n), with elements of type fmpz_mpoly_q_factored_struct in which denominators are kept fully factored: addition and multiplication then avoid polynomial GCDs, while division requires factorisation. Elements can be converted to and from the contexts of gr_ctx_init_fmpz_mpoly_q and gr_ctx_init_fmpz_mpoly with the same number of variables and ordering using gr_set_other.

Initialises ctx to the field \mathbb{F}_p(x_1, \ldots, x_n) of rational functions over \mathbb{F}_p with p = mod, with elements of type fmpz_mod_mpoly_q_struct. The modulus must be prime; this is not checked and a composite modulus gives undefined behaviour. Declared only if fmpz_mod_mpoly_q.h is included before gr.h.

Initialises ctx to the symmetric group S_n of permutations of \{0, 1, \ldots, n - 1\}. Elements are currently pointers to arrays (the representation may change).

Initialises ctx to the modular group \mathrm{PSL}(2, \mathbb{Z}) with elements of type psl2z_struct.

Initialises ctx to the group G_q of Dirichlet characters modulo q, with elements of type dirichlet_char_struct. Returns GR_DOMAIN if q = 0 and GR_UNABLE if q has a prime factor larger than 10^{16}, which dirichlet_group_init does not support; in both cases ctx is not initialised.

Initialises ctx to the set of symbolic expressions of type fexpr_struct (see fexpr). Arithmetic builds expression trees without simplification. Elements of any ring can be converted to expressions with gr_get_fexpr, and expressions can be evaluated in a ring with gr_set_fexpr or gr_set_other.

Initialise ctx to a random ring, commutative ring, field or finite field. The rings are drawn from the built-in base rings (\mathbb{Z}, \mathbb{Q}, \mathbb{Z}[i], \mathbb{Z}/n\mathbb{Z} in its various representations, finite fields, number fields, balls, Calcium fields) and from rings built over some of them (polynomials, multivariate polynomials, series, vectors, matrices and debug wrappers). The base rings of the composite rings are kept in static storage, so only ctx is cleared by the caller.

Initialise ctx to a random ring of univariate polynomials, multivariate polynomials or power series over a random base ring. The random series rings (also those among the composite rings of gr_ctx_init_random) have precision 1 to 5, and only with probability 1/20 precision 0, in which every element is O(x^0).

Initialises ctx to a wrapper around the ring elem_ctx that computes as elem_ctx but adds checks. Only a few methods are wrapped (memory management, printing, gr_zero, gr_one, gr_is_zero, gr_is_one, gr_equal, gr_set, gr_neg, gr_add, gr_sub, gr_mul, gr_div, gr_inv, gr_is_invertible, gr_sqrt, gr_rsqrt, gr_pow); the others use the generic defaults. If unable_probability is positive, the wrapped methods randomly return GR_UNABLE and predicates randomly return T_UNKNOWN with that probability, which tests the error handling of algorithms. flags is a combination of the GR_DEBUG_* flags.

Returns 1 if elements should be coerced into ctx1 and -1 if into ctx2, when an operation combines elements of both. The rule compares the implementation codes (gr_which_structure, in which structures built on other structures come later), recursing into the base rings of two gr_poly or two matrix contexts; for equal codes it returns 1.