gr_generic.h

Does nothing: the default for rings whose context owns no memory.

The default of GR_METHOD_CTX_IS_PRETEND_FIELD: returns gr_ctx_is_field, since a ring without a pretence mechanism pretends only if it is a field.

Set *ngens to 0 (the default of gr_ctx_ngens) or 1, and return GR_SUCCESS. Declared with return type slong but used as methods returning int.

Returns NULL: the default of gr_ctx_base for rings without a base ring.

For rings \mathbb{Z}/n\mathbb{Z}, which are finite fields exactly when n is prime: set the degree to 1, respectively the order to p (obtained with gr_ctx_fq_prime), if gr_ctx_is_field returns T_TRUE, and return GR_UNABLE otherwise. Installed by the nmod, fmpz_mod and mpn_mod contexts.

Copies the sizeof_elem bytes of x to res with memcpy.

Ignores the number of digits and calls gr_write.

Tries gr_randtest five times until the element is known to be nonzero, then falls back to \pm 1; returns GR_DOMAIN if even \pm 1 is zero (the zero ring) and GR_UNABLE if this cannot be decided.

Sets x to a g + b with random integers a, b \in [-3, 3], where g is the generator of the ring if gr_gen succeeds and 0 otherwise, divided with probability 1/4 by a random integer in [1, 4] when the division succeeds; falls back to a small integer and then to zero.

Set vec to the generators of the ring: the empty vector (the default of gr_gens), the single generator returned by gr_gen (for rings with one generator), or the result of gr_gens (the default of gr_gens_recursive, for rings without base rings).

Compare x with a newly initialised element (which is zero), with the result of gr_one, or with the result of gr_neg_one, using gr_equal; T_UNKNOWN if the constant cannot be constructed.

Sets res to -1 by gr_one and gr_neg.

Parse the expression s and evaluate it in the ring. gr_generic_set_str is gr_generic_set_str_expr with no flags and the default of gr_set_str; the other two set one flag each.

Evaluates the symbolic expression expr in the ring, using the vectors inputs and outputs as a table of symbols and their values (the default of gr_set_fexpr). Declared only if fexpr.h is included first.

Sets res to m \pm \infty with gr_pos_inf and gr_set_interval_mid_rad; returns GR_UNABLE if the ring has no infinity.

The default conversion from another ring: gr_set if xctx is ctx, gr_set_fmpz from \mathbb{Z}, gr_set_fmpq from \mathbb{Q}, gr_set_fexpr from symbolic expressions, and GR_UNABLE from any other ring. Rings override it to accept their base rings and related types.

Sets res to p/q by converting p and q with gr_set_fmpz, inverting q and multiplying; returns GR_DOMAIN if q is not invertible in the ring.

Set res to x \cdot 2^y by powering 2 in the ring, respectively write x as m \cdot 2^e with m odd by converting it to a rational number with gr_get_fmpq (failing with GR_DOMAIN if its denominator is not a power of 2).

Sets res to x \cdot 10^y, by multiplying or dividing by a power of 10 computed in the ring.

Defaults of the type variants of gr_add.

Defaults of the type variants of gr_sub.

Defaults of the type variants of gr_mul.

Compute the product x y in a temporary with the corresponding multiplication and add it to, or subtract it from, res.

Compute 2x as x + x and x^2 as x \cdot x.

Multiply by 2^y computed in the ring with gr_pow_ui (or gr_pow_fmpz), or divide by 2^{-y} for negative y.

Handle x = 1 and x = -1 (invertible, their own inverses) and x = 0 (not invertible, GR_DOMAIN), and return GR_UNABLE or T_UNKNOWN for every other element.

Convert the operand to the ring and call gr_div, returning the conversion status if it fails.

Multiplies by 1/y with gr_mul_fmpq; for y = 0 it converts 0 and calls gr_div, so that the ring decides (the zero ring allows it).

Calls gr_div. The type variants of gr_divexact default to those of gr_div.

Compute x^e for e \ge 0 by left-to-right binary exponentiation, with special code for e \le 4; gr_generic_pow_fmpz_binexp returns GR_DOMAIN for negative e. The output may alias the input.

Compute x^e for e \ge 0 by the sliding window method with a window size k between 1 and 11 bits chosen from the bit length of e, using fewer multiplications than binary exponentiation for large exponents at the cost of a table of 2^{k-1} odd powers. gr_generic_pow_fmpz_sliding returns GR_DOMAIN for negative e. The output may alias the input.

The defaults of gr_pow_ui, gr_pow_si and gr_pow_fmpz: binary exponentiation; for a negative exponent, invert x with gr_inv first, so that the result fails exactly when x is not invertible.

The default of gr_pow_fmpq: an integer exponent p/1 uses gr_pow_fmpz; an exponent p/2 uses gr_sqrt (or gr_rsqrt for p < 0) followed by an integer power; any other exponent is converted to the ring and passed to gr_pow. Failures of the square root are reported as GR_UNABLE, since the result may still exist for another choice of root.

Defaults of gr_pow_other and gr_other_pow: an exponent in \mathbb{Z} or \mathbb{Q} is passed to gr_pow_fmpz or gr_pow_fmpq; otherwise the operand is converted with gr_set_other and gr_pow is called.

Handle 0 and 1 (and for gr_generic_rsqrt, compute 1/\sqrt{x} from gr_sqrt and gr_inv when both succeed; 1/\sqrt{0} is GR_DOMAIN), and return GR_UNABLE or T_UNKNOWN otherwise.

Return x as its own numerator and 1 as its denominator.

gr_generic_cmp returns GR_UNABLE. The others compare absolute values computed with gr_abs with gr_cmp, or convert y with gr_set_other and call gr_cmp or gr_cmpabs.

Defaults of gr_bernoulli_ui and the related functions: in \mathbb{Q}, the exact Bernoulli numbers from bernoulli_fmpq_ui and the global cache of bernoulli; in rings with a real precision, numerical values computed with arb_bernoulli_ui (or arb_bernoulli_fmpz) and converted; otherwise exact rational values converted with gr_set_fmpq, which fails if a denominator is not invertible. gr_generic_bernoulli_fmpz returns GR_UNABLE for huge n in exact rings.

Defaults for the Euler numbers E_n: exact integers from arb_fmpz_euler_number_ui, converted to the ring, or numerical values computed with ball arithmetic in rings with a real precision.

Defaults for the unsigned and signed Stirling numbers of the first kind and the Stirling numbers of the second kind S(x, y), and for the rows S(x, 0), \ldots, S(x, \mathit{len} - 1): computed as integers with the functions of arith and converted to the ring.

Defaults of _gr_vec_init, _gr_vec_clear, _gr_vec_swap, _gr_vec_zero, _gr_vec_set and _gr_vec_neg.

Defaults of _gr_vec_normalise and _gr_vec_normalise_weak: scan from the end with gr_is_zero.

Defaults of the elementwise binary operations _gr_vec_add and the others.

Defaults of the operations between a vector and a scalar.

Defaults of the operations with an operand in another ring.

Default of _gr_vec_mul_scalar_2exp_si.

Defaults of _gr_vec_addmul_scalar and the related functions: multiply into a temporary and add or subtract.

Defaults of _gr_vec_equal and _gr_vec_is_zero: return T_FALSE at the first entry known to differ, otherwise T_UNKNOWN if some comparison was unknown and T_TRUE if not. gr_generic_vec_is_zero is declared as returning int but returns a truth_t.

Defaults of the dot products (Dot products): multiply and add term by term in a temporary. The strided version gathers the entries by shallow copies and calls _gr_vec_dot when the ring has its own VEC_DOT method.

Defaults of _gr_vec_set_powers and _gr_vec_reciprocals.

Defaults of _gr_vec_set_other, _gr_vec_gather and _gr_vec_scatter: loops over gr_set_other and gr_set.

Defaults of the elementwise elementary functions of gr_vec: loops over gr_sqrt, gr_exp and the others.

Defaults of gr_get_interval_mid_rad (sets m = x and r = 0, for exact rings) and of its vector version (loops over the method).

Defaults of the methods GR_METHOD_POLY_FACTOR and GR_METHOD_POLY_ROOTS (factorisation and root finding of polynomials over the ring): implemented generically for finite fields (gr_ctx_is_field and gr_ctx_is_finite both T_TRUE), and GR_UNABLE for other rings.

Factors a polynomial over an integral domain that splits into linear factors, by computing its roots with gr_poly_roots: sets c to the leading coefficient (as a constant polynomial) and the factors to x - r with the multiplicities of the roots. Returns GR_DOMAIN for the zero polynomial and GR_UNABLE if the leading coefficient is not known to be nonzero or if the multiplicities do not add up to the degree (not all roots found). It is the polynomial factorisation method of complex balls (acb) and complex floating-point numbers (acf), and is called by the qqbar and ca contexts for polynomials over algebraically closed fields.

Set res to f(x) for the integer polynomial f (as an fmpz array of length len, or an fmpz_poly_t): by Horner's rule, by rectangular splitting, or (_gr_fmpz_poly_evaluate) by Horner's rule for length at most 6 and rectangular splitting otherwise. Declared only if fmpz_poly.h is included first.

Set res to the value of the multivariate integer polynomial f (with context mctx) at the vector of values x, one entry for each variable: term by term, or by a multivariate Horner scheme that chooses the variable to factor out greedily; gr_fmpz_mpoly_evaluate uses the first method for polynomials with at most one term and word-size exponents and the second otherwise. Declared only if fmpz_mpoly.h is included first.