diff --git a/doc/source/ca_vec.rst b/doc/source/ca_vec.rst index ac4ce9960c..3d6436429a 100644 --- a/doc/source/ca_vec.rst +++ b/doc/source/ca_vec.rst @@ -111,7 +111,7 @@ Input and output Prints *vec* to standard output. The coefficients are printed on separate lines. -.. function:: void ca_vec_printn(const ca_vec_t poly, slong digits, ca_ctx_t ctx) +.. function:: void ca_vec_printn(const ca_vec_t vec, slong digits, ca_ctx_t ctx) Prints a decimal representation of *vec* with precision specified by *digits*. The coefficients are comma-separated and the whole list is enclosed in square brackets. diff --git a/doc/source/gr_poly.rst b/doc/source/gr_poly.rst index f0b10bc8d0..0e6512c8e3 100644 --- a/doc/source/gr_poly.rst +++ b/doc/source/gr_poly.rst @@ -498,9 +498,9 @@ Division uses the Karp-Markstein algorithm. .. function:: int _gr_poly_div_series_newton(gr_ptr res, gr_srcptr A, slong Alen, gr_srcptr B, slong Blen, slong len, slong cutoff, gr_ctx_t ctx) int gr_poly_div_series_newton(gr_poly_t res, const gr_poly_t A, const gr_poly_t B, slong len, slong cutoff, gr_ctx_t ctx) - int _gr_poly_div_series_divconquer(gr_ptr res, gr_srcptr B, slong Blen, gr_srcptr A, slong Alen, slong len, slong cutoff, gr_ctx_t ctx) + int _gr_poly_div_series_divconquer(gr_ptr res, gr_srcptr A, slong Alen, gr_srcptr B, slong Blen, slong len, slong cutoff, gr_ctx_t ctx) int gr_poly_div_series_divconquer(gr_poly_t Q, const gr_poly_t A, const gr_poly_t B, slong len, slong cutoff, gr_ctx_t ctx) - int _gr_poly_div_series_invmul(gr_ptr res, gr_srcptr B, slong Blen, gr_srcptr A, slong Alen, slong len, gr_ctx_t ctx) + int _gr_poly_div_series_invmul(gr_ptr res, gr_srcptr A, slong Alen, gr_srcptr B, slong Blen, slong len, gr_ctx_t ctx) int gr_poly_div_series_invmul(gr_poly_t res, const gr_poly_t A, const gr_poly_t B, slong len, gr_ctx_t ctx) int _gr_poly_div_series_basecase_preinv1(gr_ptr Q, gr_srcptr A, slong Alen, gr_srcptr B, slong Blen, gr_srcptr Binv, slong len, gr_ctx_t ctx) int _gr_poly_div_series_basecase_noinv(gr_ptr Q, gr_srcptr A, slong Alen, gr_srcptr B, slong Blen, slong len, gr_ctx_t ctx) diff --git a/doc/source/nmod_mat.rst b/doc/source/nmod_mat.rst index 8edfa966d2..2cf4a4e792 100644 --- a/doc/source/nmod_mat.rst +++ b/doc/source/nmod_mat.rst @@ -311,7 +311,7 @@ Addition and subtraction Computes `C = A - B`. Dimensions must be identical. -.. function:: void nmod_mat_neg(nmod_mat_t A, const nmod_mat_t B) +.. function:: void nmod_mat_neg(nmod_mat_t B, const nmod_mat_t A) Sets `B = -A`. Dimensions must be identical. diff --git a/doc/source/padic_poly.rst b/doc/source/padic_poly.rst index 9d7c8c657b..47b3600707 100644 --- a/doc/source/padic_poly.rst +++ b/doc/source/padic_poly.rst @@ -232,10 +232,10 @@ Getting and setting coefficients Sets `c` to the coefficient of `x^n` in the polynomial, reduced modulo the precision of `c`. -.. function:: void padic_poly_set_coeff_padic(padic_poly_t f, slong n, const padic_t c, const padic_ctx_t ctx) +.. function:: void padic_poly_set_coeff_padic(padic_poly_t poly, slong n, const padic_t c, const padic_ctx_t ctx) - Sets the coefficient of `x^n` in the polynomial `f` to `c`, - reduced to the precision of the polynomial `f`. + Sets the coefficient of `x^n` in the polynomial `poly` to `c`, + reduced to the precision of the polynomial `poly`. Note that this operation can take linear time in the length of the polynomial. @@ -528,9 +528,9 @@ Input and output In the current implementation, always returns `1`. -.. function:: int _padic_poly_fprint_pretty(FILE * file, const fmpz * poly, slong val, slong len, const char * var, const padic_ctx_t ctx) +.. function:: int _padic_poly_fprint_pretty(FILE * file, const fmpz * poly, slong len, slong val, const char * var, const padic_ctx_t ctx) int padic_poly_fprint_pretty(FILE * file, const padic_poly_t poly, const char * var, const padic_ctx_t ctx) - int _padic_poly_print_pretty(const fmpz * poly, slong val, slong len, const char * var, const padic_ctx_t ctx) + int _padic_poly_print_pretty(const fmpz * poly, slong len, slong val, const char * var, const padic_ctx_t ctx) int padic_poly_print_pretty(const padic_poly_t poly, const char * var, const padic_ctx_t ctx) diff --git a/src/arb.h b/src/arb.h index 669270886d..b9353d6d0c 100644 --- a/src/arb.h +++ b/src/arb.h @@ -123,7 +123,7 @@ void arb_indeterminate(arb_t x); int arb_is_finite(const arb_t x); -void arb_set(arb_t x, const arb_t y); +void arb_set(arb_t y, const arb_t x); ARB_INLINE void arb_swap(arb_t x, arb_t y) @@ -137,7 +137,7 @@ void arb_trim(arb_t y, const arb_t x); void arb_neg(arb_t y, const arb_t x); -void arb_neg_round(arb_t x, const arb_t y, slong prec); +void arb_neg_round(arb_t y, const arb_t x, slong prec); void arb_abs(arb_t y, const arb_t x); void arb_nonnegative_abs(arb_t y, const arb_t x); @@ -163,13 +163,13 @@ arb_set_arf(arb_t x, const arf_t y) mag_zero(arb_radref(x)); } -void arb_set_si(arb_t x, slong y); +void arb_set_si(arb_t y, slong x); -void arb_set_ui(arb_t x, ulong y); +void arb_set_ui(arb_t y, ulong x); -void arb_set_d(arb_t x, double y); +void arb_set_d(arb_t y, double x); -void arb_set_fmpz(arb_t x, const fmpz_t y); +void arb_set_fmpz(arb_t y, const fmpz_t x); ARB_INLINE void arb_set_fmpz_2exp(arb_t x, const fmpz_t y, const fmpz_t exp) diff --git a/src/arb/neg_round.c b/src/arb/neg_round.c index 537e92df44..9bbaf1e5b6 100644 --- a/src/arb/neg_round.c +++ b/src/arb/neg_round.c @@ -12,8 +12,8 @@ #include "arb.h" void -arb_neg_round(arb_t x, const arb_t y, slong prec) +arb_neg_round(arb_t y, const arb_t x, slong prec) { - arb_set_round(x, y, prec); - arb_neg(x, x); + arb_set_round(y, x, prec); + arb_neg(y, y); } diff --git a/src/arb/set.c b/src/arb/set.c index d1333d6c76..fabaf842b3 100644 --- a/src/arb/set.c +++ b/src/arb/set.c @@ -43,39 +43,39 @@ _arf_set_inline(arf_t y, const arf_t x) } void -arb_set(arb_t x, const arb_t y) +arb_set(arb_t y, const arb_t x) { - if (x != y) + if (y != x) { - _arf_set_inline(arb_midref(x), arb_midref(y)); - mag_set(arb_radref(x), arb_radref(y)); + _arf_set_inline(arb_midref(y), arb_midref(x)); + mag_set(arb_radref(y), arb_radref(x)); } } void -arb_set_d(arb_t x, double y) +arb_set_d(arb_t y, double x) { - arf_set_d(arb_midref(x), y); - mag_zero(arb_radref(x)); + arf_set_d(arb_midref(y), x); + mag_zero(arb_radref(y)); } void -arb_set_fmpz(arb_t x, const fmpz_t y) +arb_set_fmpz(arb_t y, const fmpz_t x) { - arf_set_fmpz(arb_midref(x), y); - mag_zero(arb_radref(x)); + arf_set_fmpz(arb_midref(y), x); + mag_zero(arb_radref(y)); } void -arb_set_si(arb_t x, slong y) +arb_set_si(arb_t y, slong x) { - arf_set_si(arb_midref(x), y); - mag_zero(arb_radref(x)); + arf_set_si(arb_midref(y), x); + mag_zero(arb_radref(y)); } void -arb_set_ui(arb_t x, ulong y) +arb_set_ui(arb_t y, ulong x) { - arf_set_ui(arb_midref(x), y); - mag_zero(arb_radref(x)); + arf_set_ui(arb_midref(y), x); + mag_zero(arb_radref(y)); } diff --git a/src/arb_calc.h b/src/arb_calc.h index 69fdf1c7b4..a9f0af1b22 100644 --- a/src/arb_calc.h +++ b/src/arb_calc.h @@ -95,9 +95,9 @@ void arf_interval_printd(const arf_interval_t v, slong n); int arb_calc_partition(arf_interval_t L, arf_interval_t R, arb_calc_func_t func, void * param, const arf_interval_t block, slong prec); -slong arb_calc_isolate_roots(arf_interval_ptr * blocks, int ** flags, +slong arb_calc_isolate_roots(arf_interval_ptr * found, int ** flags, arb_calc_func_t func, void * param, - const arf_interval_t block, slong maxdepth, slong maxeval, slong maxfound, + const arf_interval_t interval, slong maxdepth, slong maxeval, slong maxfound, slong prec); int arb_calc_refine_root_bisect(arf_interval_t r, arb_calc_func_t func, diff --git a/src/arb_calc/isolate_roots.c b/src/arb_calc/isolate_roots.c index f2c5e4656b..204b8f4d82 100644 --- a/src/arb_calc/isolate_roots.c +++ b/src/arb_calc/isolate_roots.c @@ -144,16 +144,16 @@ isolate_roots_recursive(arf_interval_ptr * blocks, int ** flags, } slong -arb_calc_isolate_roots(arf_interval_ptr * blocks, int ** flags, +arb_calc_isolate_roots(arf_interval_ptr * found, int ** flags, arb_calc_func_t func, void * param, - const arf_interval_t block, slong maxdepth, slong maxeval, slong maxfound, + const arf_interval_t interval, slong maxdepth, slong maxeval, slong maxfound, slong prec) { int asign, bsign; slong length, alloc; arb_t m, v; - *blocks = NULL; + *found = NULL; *flags = NULL; length = 0; alloc = 0; @@ -161,22 +161,22 @@ arb_calc_isolate_roots(arf_interval_ptr * blocks, int ** flags, arb_init(m); arb_init(v); - arb_set_arf(m, &block->a); + arb_set_arf(m, &interval->a); func(v, m, param, 1, prec); asign = arb_sgn_nonzero(v); - arb_set_arf(m, &block->b); + arb_set_arf(m, &interval->b); func(v, m, param, 1, prec); bsign = arb_sgn_nonzero(v); arb_clear(m); arb_clear(v); - isolate_roots_recursive(blocks, flags, &length, &alloc, - func, param, block, asign, bsign, + isolate_roots_recursive(found, flags, &length, &alloc, + func, param, interval, asign, bsign, maxdepth, &maxeval, &maxfound, prec); - *blocks = flint_realloc(*blocks, length * sizeof(arf_interval_struct)); + *found = flint_realloc(*found, length * sizeof(arf_interval_struct)); *flags = flint_realloc(*flags, length * sizeof(int)); return length; diff --git a/src/ca_vec.h b/src/ca_vec.h index c537eae607..6046626333 100644 --- a/src/ca_vec.h +++ b/src/ca_vec.h @@ -39,7 +39,7 @@ ca_vec_entry_ptr(ca_vec_t vec, slong i) ca_ptr _ca_vec_init(slong len, ca_ctx_t ctx); void ca_vec_init(ca_vec_t vec, slong len, ca_ctx_t ctx); -void _ca_vec_clear(ca_ptr v, slong len, ca_ctx_t ctx); +void _ca_vec_clear(ca_ptr vec, slong len, ca_ctx_t ctx); void ca_vec_clear(ca_vec_t vec, ca_ctx_t ctx); void _ca_vec_swap(ca_ptr vec1, ca_ptr vec2, slong len, ca_ctx_t ctx); @@ -59,7 +59,7 @@ slong ca_vec_length(const ca_vec_t vec, ca_ctx_t ctx) } void _ca_vec_fit_length(ca_vec_t vec, slong len, ca_ctx_t ctx); -void ca_vec_set_length(ca_vec_t res, slong len, ca_ctx_t ctx); +void ca_vec_set_length(ca_vec_t vec, slong len, ca_ctx_t ctx); /* Assignment */ @@ -111,8 +111,8 @@ void _ca_vec_add(ca_ptr res, ca_srcptr vec1, ca_srcptr vec2, slong len, ca_ctx_t void _ca_vec_sub(ca_ptr res, ca_srcptr vec1, ca_srcptr vec2, slong len, ca_ctx_t ctx); void _ca_vec_scalar_mul_ca(ca_ptr res, ca_srcptr src, slong len, const ca_t c, ca_ctx_t ctx); void _ca_vec_scalar_div_ca(ca_ptr res, ca_srcptr src, slong len, const ca_t c, ca_ctx_t ctx); -void _ca_vec_scalar_addmul_ca(ca_ptr res, ca_srcptr vec, slong len, const ca_t c, ca_ctx_t ctx); -void _ca_vec_scalar_submul_ca(ca_ptr res, ca_srcptr vec, slong len, const ca_t c, ca_ctx_t ctx); +void _ca_vec_scalar_addmul_ca(ca_ptr res, ca_srcptr src, slong len, const ca_t c, ca_ctx_t ctx); +void _ca_vec_scalar_submul_ca(ca_ptr res, ca_srcptr src, slong len, const ca_t c, ca_ctx_t ctx); /* Comparisons and predicates */ diff --git a/src/ca_vec/ca_vec.c b/src/ca_vec/ca_vec.c index 7b33dd684a..ef7a9c2501 100644 --- a/src/ca_vec/ca_vec.c +++ b/src/ca_vec/ca_vec.c @@ -46,12 +46,12 @@ _ca_vec_check_is_zero(ca_srcptr vec, slong len, ca_ctx_t ctx) } void -_ca_vec_clear(ca_ptr v, slong n, ca_ctx_t ctx) +_ca_vec_clear(ca_ptr vec, slong len, ca_ctx_t ctx) { slong i; - for (i = 0; i < n; i++) - ca_clear(v + i, ctx); - flint_free(v); + for (i = 0; i < len; i++) + ca_clear(vec + i, ctx); + flint_free(vec); } void @@ -64,31 +64,31 @@ ca_vec_clear(ca_vec_t vec, ca_ctx_t ctx) } ca_ptr -_ca_vec_init(slong n, ca_ctx_t ctx) +_ca_vec_init(slong len, ca_ctx_t ctx) { slong i; - ca_ptr v = (ca_ptr) flint_malloc(sizeof(ca_struct) * n); + ca_ptr v = (ca_ptr) flint_malloc(sizeof(ca_struct) * len); - for (i = 0; i < n; i++) + for (i = 0; i < len; i++) ca_init(v + i, ctx); return v; } void -ca_vec_init(ca_vec_t res, slong len, ca_ctx_t ctx) +ca_vec_init(ca_vec_t vec, slong len, ca_ctx_t ctx) { if (len == 0) { - res->entries = NULL; - res->length = 0; - res->alloc = 0; + vec->entries = NULL; + vec->length = 0; + vec->alloc = 0; } else { - res->entries = _ca_vec_init(len, ctx); - res->length = len; - res->alloc = len; + vec->entries = _ca_vec_init(len, ctx); + vec->length = len; + vec->alloc = len; } } @@ -149,7 +149,7 @@ ca_vec_printn(const ca_vec_t vec, slong digits, ca_ctx_t ctx) } void -_ca_vec_scalar_addmul_ca(ca_ptr res, ca_srcptr vec, slong len, const ca_t c, ca_ctx_t ctx) +_ca_vec_scalar_addmul_ca(ca_ptr res, ca_srcptr src, slong len, const ca_t c, ca_ctx_t ctx) { slong i; ca_t t; @@ -159,7 +159,7 @@ _ca_vec_scalar_addmul_ca(ca_ptr res, ca_srcptr vec, slong len, const ca_t c, ca_ ca_init(t, ctx); for (i = 0; i < len; i++) { - ca_mul(t, vec + i, c, ctx); + ca_mul(t, src + i, c, ctx); ca_add(res + i, res + i, t, ctx); } ca_clear(t, ctx); @@ -193,7 +193,7 @@ _ca_vec_scalar_mul_ca(ca_ptr res, ca_srcptr src, slong len, const ca_t c, ca_ctx } void -_ca_vec_scalar_submul_ca(ca_ptr res, ca_srcptr vec, slong len, const ca_t c, ca_ctx_t ctx) +_ca_vec_scalar_submul_ca(ca_ptr res, ca_srcptr src, slong len, const ca_t c, ca_ctx_t ctx) { slong i; ca_t t; @@ -203,7 +203,7 @@ _ca_vec_scalar_submul_ca(ca_ptr res, ca_srcptr vec, slong len, const ca_t c, ca_ ca_init(t, ctx); for (i = 0; i < len; i++) { - ca_mul(t, vec + i, c, ctx); + ca_mul(t, src + i, c, ctx); ca_sub(res + i, res + i, t, ctx); } ca_clear(t, ctx); diff --git a/src/fmpz_extras.h b/src/fmpz_extras.h index 420d7d6033..764dee756c 100644 --- a/src/fmpz_extras.h +++ b/src/fmpz_extras.h @@ -186,7 +186,7 @@ fmpz_min(fmpz_t z, const fmpz_t x, const fmpz_t y) (zn) = FLINT_ABS(zn); \ } -void fmpz_lshift_mpn(fmpz_t z, nn_srcptr d, slong dn, int sgnbit, flint_bitcnt_t shift); +void fmpz_lshift_mpn(fmpz_t z, nn_srcptr src, slong n, int negative, flint_bitcnt_t shift); static inline slong fmpz_allocated_bytes(const fmpz_t x) diff --git a/src/fmpz_extras/lshift_mpn.c b/src/fmpz_extras/lshift_mpn.c index cf8cf75402..084476cf4a 100644 --- a/src/fmpz_extras/lshift_mpn.c +++ b/src/fmpz_extras/lshift_mpn.c @@ -13,7 +13,7 @@ #include "fmpz_extras.h" void -fmpz_lshift_mpn(fmpz_t z, nn_srcptr d, slong dn, int sgnbit, flint_bitcnt_t shift) +fmpz_lshift_mpn(fmpz_t z, nn_srcptr src, slong n, int negative, flint_bitcnt_t shift) { mpz_ptr zmpz; nn_ptr zp; @@ -24,22 +24,22 @@ fmpz_lshift_mpn(fmpz_t z, nn_srcptr d, slong dn, int sgnbit, flint_bitcnt_t shif shift_limbs = shift / FLINT_BITS; shift_bits = shift % FLINT_BITS; - zn = dn + shift_limbs + (shift_bits != 0); + zn = n + shift_limbs + (shift_bits != 0); zp = FLINT_MPZ_REALLOC(zmpz, zn); flint_mpn_zero(zp, shift_limbs); if (shift_bits == 0) { - flint_mpn_copyi(zp + shift_limbs, d, dn); + flint_mpn_copyi(zp + shift_limbs, src, n); } else { - zp[zn - 1] = mpn_lshift(zp + shift_limbs, d, dn, shift_bits); + zp[zn - 1] = mpn_lshift(zp + shift_limbs, src, n, shift_bits); while (zp[zn - 1] == 0) zn--; } - zmpz->_mp_size = sgnbit ? -(slong) zn : zn; + zmpz->_mp_size = negative ? -(slong) zn : zn; _fmpz_demote_val(z); } diff --git a/src/gr_poly.h b/src/gr_poly.h index eccd3b0468..e5ef8747a5 100644 --- a/src/gr_poly.h +++ b/src/gr_poly.h @@ -266,9 +266,9 @@ GR_POLY_INLINE WARN_UNUSED_RESULT int _gr_poly_inv_series(gr_ptr res, gr_srcptr WARN_UNUSED_RESULT int _gr_poly_inv_series_generic(gr_ptr Qinv, gr_srcptr Q, slong Qlen, slong len, gr_ctx_t ctx); WARN_UNUSED_RESULT int gr_poly_inv_series(gr_poly_t Qinv, const gr_poly_t Q, slong len, gr_ctx_t ctx); -WARN_UNUSED_RESULT int _gr_poly_div_series_newton(gr_ptr res, gr_srcptr B, slong Blen, gr_srcptr A, slong Alen, slong len, slong cutoff, gr_ctx_t ctx); +WARN_UNUSED_RESULT int _gr_poly_div_series_newton(gr_ptr res, gr_srcptr A, slong Alen, gr_srcptr B, slong Blen, slong len, slong cutoff, gr_ctx_t ctx); WARN_UNUSED_RESULT int gr_poly_div_series_newton(gr_poly_t Q, const gr_poly_t A, const gr_poly_t B, slong len, slong cutoff, gr_ctx_t ctx); -WARN_UNUSED_RESULT int _gr_poly_div_series_divconquer(gr_ptr res, gr_srcptr B, slong Blen, gr_srcptr A, slong Alen, slong len, slong cutoff, gr_ctx_t ctx); +WARN_UNUSED_RESULT int _gr_poly_div_series_divconquer(gr_ptr res, gr_srcptr A, slong Alen, gr_srcptr B, slong Blen, slong len, slong cutoff, gr_ctx_t ctx); WARN_UNUSED_RESULT int gr_poly_div_series_divconquer(gr_poly_t Q, const gr_poly_t A, const gr_poly_t B, slong len, slong cutoff, gr_ctx_t ctx); WARN_UNUSED_RESULT int _gr_poly_div_series_basecase_generic(gr_ptr Q, gr_srcptr A, slong Alen, gr_srcptr B, slong Blen, slong len, gr_ctx_t ctx); WARN_UNUSED_RESULT int gr_poly_div_series_basecase(gr_poly_t Q, const gr_poly_t A, const gr_poly_t B, slong len, gr_ctx_t ctx); diff --git a/src/gr_poly/div_series_invmul.c b/src/gr_poly/div_series_invmul.c index b1cf139a55..a1523221e6 100644 --- a/src/gr_poly/div_series_invmul.c +++ b/src/gr_poly/div_series_invmul.c @@ -15,18 +15,18 @@ #include "gr_poly.h" int -_gr_poly_div_series_invmul(gr_ptr res, gr_srcptr B, slong Blen, gr_srcptr A, slong Alen, slong len, gr_ctx_t ctx) +_gr_poly_div_series_invmul(gr_ptr res, gr_srcptr A, slong Alen, gr_srcptr B, slong Blen, slong len, gr_ctx_t ctx) { - gr_ptr Ainv; + gr_ptr Binv; int status = GR_SUCCESS; - GR_TMP_INIT_VEC(Ainv, len, ctx); + GR_TMP_INIT_VEC(Binv, len, ctx); - status |= _gr_poly_inv_series(Ainv, A, Alen, len, ctx); + status |= _gr_poly_inv_series(Binv, B, Blen, len, ctx); if (status == GR_SUCCESS) - status |= _gr_poly_mullow(res, Ainv, len, B, Blen, len, ctx); + status |= _gr_poly_mullow(res, Binv, len, A, Alen, len, ctx); - GR_TMP_CLEAR_VEC(Ainv, len, ctx); + GR_TMP_CLEAR_VEC(Binv, len, ctx); return status; } diff --git a/src/gr_poly/div_series_newton.c b/src/gr_poly/div_series_newton.c index c93d247a32..8aac94c678 100644 --- a/src/gr_poly/div_series_newton.c +++ b/src/gr_poly/div_series_newton.c @@ -15,26 +15,26 @@ #include "gr_poly.h" int -_gr_poly_div_series_newton(gr_ptr res, gr_srcptr B, slong Blen, gr_srcptr A, slong Alen, slong len, slong cutoff, gr_ctx_t ctx) +_gr_poly_div_series_newton(gr_ptr res, gr_srcptr A, slong Alen, gr_srcptr B, slong Blen, slong len, slong cutoff, gr_ctx_t ctx) { slong sz = ctx->sizeof_elem; int status = GR_SUCCESS; - slong i, m, n, Anlen, Wlen, W2len, alloc; + slong i, m, n, Bnlen, Wlen, W2len, alloc; gr_ptr W, T; slong a[FLINT_BITS]; if (len == 0) return GR_SUCCESS; - if (Alen == 0) + if (Blen == 0) return GR_DOMAIN; - Alen = FLINT_MIN(Alen, len); Blen = FLINT_MIN(Blen, len); + Alen = FLINT_MIN(Alen, len); /* not supported by the following code */ - if (Alen == 1) - return _gr_poly_div_series_basecase(res, B, Blen, A, Alen, len, ctx); + if (Blen == 1) + return _gr_poly_div_series_basecase(res, A, Alen, B, Blen, len, ctx); cutoff = FLINT_MAX(cutoff, 2); @@ -42,7 +42,7 @@ _gr_poly_div_series_newton(gr_ptr res, gr_srcptr B, slong Blen, gr_srcptr A, slo while (n >= cutoff) a[++i] = (n = (n + 1) / 2); - status |= _gr_poly_inv_series_basecase(res, A, Alen, n, ctx); + status |= _gr_poly_inv_series_basecase(res, B, Blen, n, ctx); if (status != GR_SUCCESS) return status; @@ -56,10 +56,10 @@ _gr_poly_div_series_newton(gr_ptr res, gr_srcptr B, slong Blen, gr_srcptr A, slo m = n; n = a[i]; - Anlen = FLINT_MIN(Alen, n); - Wlen = FLINT_MIN(Anlen + m - 1, n); + Bnlen = FLINT_MIN(Blen, n); + Wlen = FLINT_MIN(Bnlen + m - 1, n); W2len = Wlen - m; - status |= _gr_poly_mullow(W, A, Anlen, res, m, Wlen, ctx); + status |= _gr_poly_mullow(W, B, Bnlen, res, m, Wlen, ctx); if (W2len != 0) status |= _gr_poly_mullow(GR_ENTRY(res, m, sz), res, m, GR_ENTRY(W, m, sz), W2len, n - m, ctx); status |= _gr_vec_neg(GR_ENTRY(res, m, sz), GR_ENTRY(res, m, sz), n - m, ctx); @@ -68,13 +68,13 @@ _gr_poly_div_series_newton(gr_ptr res, gr_srcptr B, slong Blen, gr_srcptr A, slo m = (len + 1) / 2; n = len; - Anlen = FLINT_MIN(Alen, n); - Wlen = FLINT_MIN(Anlen + m - 1, n); + Bnlen = FLINT_MIN(Blen, n); + Wlen = FLINT_MIN(Bnlen + m - 1, n); /* Karp-Markstein */ - status |= _gr_poly_mullow(T, res, m, B, Blen, m, ctx); - status |= _gr_poly_mullow(W, A, Anlen, T, m, Wlen, ctx); - status |= _gr_poly_sub(GR_ENTRY(W, m, sz), GR_ENTRY(B, m, sz), FLINT_MAX(0, FLINT_MIN(Blen - m, n - m)), GR_ENTRY(W, m, sz), n - m, ctx); + status |= _gr_poly_mullow(T, res, m, A, Alen, m, ctx); + status |= _gr_poly_mullow(W, B, Bnlen, T, m, Wlen, ctx); + status |= _gr_poly_sub(GR_ENTRY(W, m, sz), GR_ENTRY(A, m, sz), FLINT_MAX(0, FLINT_MIN(Alen - m, n - m)), GR_ENTRY(W, m, sz), n - m, ctx); status |= _gr_poly_mullow(GR_ENTRY(res, m, sz), res, m, GR_ENTRY(W, m, sz), n - m, n - m, ctx); _gr_vec_swap(res, T, m, ctx); diff --git a/src/padic_poly.h b/src/padic_poly.h index d552845444..73f4f2f128 100644 --- a/src/padic_poly.h +++ b/src/padic_poly.h @@ -67,9 +67,9 @@ void padic_poly_init2(padic_poly_t poly, slong alloc, slong prec); void padic_poly_clear(padic_poly_t poly); -void padic_poly_realloc(padic_poly_t f, slong alloc, const fmpz_t p); +void padic_poly_realloc(padic_poly_t poly, slong alloc, const fmpz_t p); -void padic_poly_fit_length(padic_poly_t f, slong len); +void padic_poly_fit_length(padic_poly_t poly, slong len); PADIC_POLY_INLINE void _padic_poly_set_length(padic_poly_t poly, slong len) @@ -84,13 +84,13 @@ void _padic_poly_set_length(padic_poly_t poly, slong len) poly->length = len; } -void _padic_poly_normalise(padic_poly_t f); +void _padic_poly_normalise(padic_poly_t poly); void _padic_poly_canonicalise(fmpz *poly, slong *v, slong len, const fmpz_t p); void padic_poly_canonicalise(padic_poly_t poly, const fmpz_t p); -void padic_poly_reduce(padic_poly_t f, const padic_ctx_t ctx); +void padic_poly_reduce(padic_poly_t poly, const padic_ctx_t ctx); PADIC_POLY_INLINE void padic_poly_truncate(padic_poly_t poly, slong n, const fmpz_t p) @@ -141,7 +141,7 @@ void padic_poly_randtest_val(padic_poly_t f, flint_rand_t state, /* Assignment and basic manipulation ***************************************/ -void padic_poly_set(padic_poly_t f, const padic_poly_t g, +void padic_poly_set(padic_poly_t poly1, const padic_poly_t poly2, const padic_ctx_t ctx); void padic_poly_set_padic(padic_poly_t poly, const padic_t x, @@ -197,12 +197,12 @@ void padic_poly_swap(padic_poly_t poly1, padic_poly_t poly2); void padic_poly_get_coeff_padic(padic_t c, const padic_poly_t poly, slong n, const padic_ctx_t ctx); -void padic_poly_set_coeff_padic(padic_poly_t f, slong n, const padic_t c, +void padic_poly_set_coeff_padic(padic_poly_t poly, slong n, const padic_t c, const padic_ctx_t ctx); /* Comparison **************************************************************/ -int padic_poly_equal(const padic_poly_t f, const padic_poly_t g); +int padic_poly_equal(const padic_poly_t poly1, const padic_poly_t poly2); PADIC_POLY_INLINE int padic_poly_is_zero(const padic_poly_t poly) { @@ -254,8 +254,8 @@ void _padic_poly_mul(fmpz *rop, slong *rval, slong N, const fmpz *op2, slong val2, slong len2, const padic_ctx_t ctx); -void padic_poly_mul(padic_poly_t f, - const padic_poly_t g, const padic_poly_t h, +void padic_poly_mul(padic_poly_t res, + const padic_poly_t poly1, const padic_poly_t poly2, const padic_ctx_t ctx); /* Powering ****************************************************************/ @@ -269,7 +269,7 @@ void padic_poly_pow(padic_poly_t rop, const padic_poly_t op, ulong e, /* Series inversion ********************************************************/ -void padic_poly_inv_series(padic_poly_t Qinv, const padic_poly_t Q, slong n, +void padic_poly_inv_series(padic_poly_t g, const padic_poly_t f, slong n, const padic_ctx_t ctx); /* Derivative **************************************************************/ @@ -296,7 +296,7 @@ void _padic_poly_evaluate_padic(fmpz_t u, slong *v, slong N, const fmpz_t a, slong b, const padic_ctx_t ctx); void padic_poly_evaluate_padic(padic_t y, const padic_poly_t poly, - const padic_t x, const padic_ctx_t ctx); + const padic_t a, const padic_ctx_t ctx); /* Composition *************************************************************/ @@ -321,13 +321,13 @@ void padic_poly_compose_pow(padic_poly_t rop, const padic_poly_t op, slong k, #ifdef FLINT_HAVE_FILE int _padic_poly_fprint(FILE * file, const fmpz * poly, slong val, slong len, const padic_ctx_t ctx); int padic_poly_fprint(FILE * file, const padic_poly_t poly, const padic_ctx_t ctx); -int _padic_poly_fprint_pretty(FILE * file, const fmpz * poly, slong val, slong len, const char * var, const padic_ctx_t ctx); +int _padic_poly_fprint_pretty(FILE * file, const fmpz * poly, slong len, slong val, const char * var, const padic_ctx_t ctx); int padic_poly_fprint_pretty(FILE * file, const padic_poly_t poly, const char * var, const padic_ctx_t ctx); #endif int _padic_poly_print(const fmpz * poly, slong val, slong len, const padic_ctx_t ctx); int padic_poly_print(const padic_poly_t poly, const padic_ctx_t ctx); -int _padic_poly_print_pretty(const fmpz * poly, slong val, slong len, const char * var, const padic_ctx_t ctx); +int _padic_poly_print_pretty(const fmpz * poly, slong len, slong val, const char * var, const padic_ctx_t ctx); int padic_poly_print_pretty(const padic_poly_t poly, const char * var, const padic_ctx_t ctx); int padic_poly_debug(const padic_poly_t poly); diff --git a/src/padic_poly/add.c b/src/padic_poly/add.c index 3689a1f57f..4d6d9f21da 100644 --- a/src/padic_poly/add.c +++ b/src/padic_poly/add.c @@ -14,19 +14,19 @@ #include "padic.h" #include "padic_poly.h" -void _padic_poly_add(fmpz *rop, slong *val, slong N, +void _padic_poly_add(fmpz *rop, slong *rval, slong N, const fmpz *op1, slong val1, slong len1, slong FLINT_UNUSED(N1), const fmpz *op2, slong val2, slong len2, slong FLINT_UNUSED(N2), const padic_ctx_t ctx) { const slong len = FLINT_MAX(len1, len2); - *val = FLINT_MIN(val1, val2); + *rval = FLINT_MIN(val1, val2); if (val1 == val2) { _fmpz_poly_add(rop, op1, len1, op2, len2); - _padic_poly_canonicalise(rop, val, len, ctx->p); + _padic_poly_canonicalise(rop, rval, len, ctx->p); } else /* => (op1 != op2) */ { @@ -67,17 +67,17 @@ void _padic_poly_add(fmpz *rop, slong *val, slong N, } /* Reduce */ - if (N - *val > 0) + if (N - *rval > 0) { fmpz_t pow; int alloc; - alloc = _padic_ctx_pow_ui(pow, N - *val, ctx); + alloc = _padic_ctx_pow_ui(pow, N - *rval, ctx); _fmpz_vec_scalar_mod_fmpz(rop, rop, len, pow); if (_fmpz_vec_is_zero(rop, len)) - *val = 0; + *rval = 0; if (alloc) fmpz_clear(pow); @@ -85,7 +85,7 @@ void _padic_poly_add(fmpz *rop, slong *val, slong N, else { _fmpz_vec_zero(rop, len); - *val = 0; + *rval = 0; } } diff --git a/src/padic_poly/equal.c b/src/padic_poly/equal.c index 699a0a09aa..c74203f0eb 100644 --- a/src/padic_poly/equal.c +++ b/src/padic_poly/equal.c @@ -12,17 +12,17 @@ #include "fmpz_vec.h" #include "padic_poly.h" -int padic_poly_equal(const padic_poly_t f, const padic_poly_t g) +int padic_poly_equal(const padic_poly_t poly1, const padic_poly_t poly2) { - if (f == g) + if (poly1 == poly2) { return 1; } - if (f->length != g->length || f->val != g->val) + if (poly1->length != poly2->length || poly1->val != poly2->val) { return 0; } - return _fmpz_vec_equal(f->coeffs, g->coeffs, f->length); + return _fmpz_vec_equal(poly1->coeffs, poly2->coeffs, poly1->length); } diff --git a/src/padic_poly/evaluate_padic.c b/src/padic_poly/evaluate_padic.c index 2ab12feee1..1e26325bb7 100644 --- a/src/padic_poly/evaluate_padic.c +++ b/src/padic_poly/evaluate_padic.c @@ -184,16 +184,16 @@ void _padic_poly_evaluate_padic(fmpz_t u, slong *v, slong N, } void padic_poly_evaluate_padic(padic_t y, const padic_poly_t poly, - const padic_t x, const padic_ctx_t ctx) + const padic_t a, const padic_ctx_t ctx) { - if (y == x) + if (y == a) { padic_t t; padic_init2(t, padic_prec(y)); _padic_poly_evaluate_padic(padic_unit(t), &padic_val(t), padic_prec(t), poly->coeffs, poly->val, poly->length, - padic_unit(x), padic_val(x), ctx); + padic_unit(a), padic_val(a), ctx); padic_swap(y, t); padic_clear(t); } @@ -201,6 +201,6 @@ void padic_poly_evaluate_padic(padic_t y, const padic_poly_t poly, { _padic_poly_evaluate_padic(padic_unit(y), &padic_val(y), padic_prec(y), poly->coeffs, poly->val, poly->length, - padic_unit(x), padic_val(x), ctx); + padic_unit(a), padic_val(a), ctx); } } diff --git a/src/padic_poly/get_coeff_padic.c b/src/padic_poly/get_coeff_padic.c index f6bdf6d86d..8e9dff53e2 100644 --- a/src/padic_poly/get_coeff_padic.c +++ b/src/padic_poly/get_coeff_padic.c @@ -12,18 +12,18 @@ #include "padic.h" #include "padic_poly.h" -void padic_poly_get_coeff_padic(padic_t x, const padic_poly_t f, slong n, +void padic_poly_get_coeff_padic(padic_t c, const padic_poly_t poly, slong n, const padic_ctx_t ctx) { - if (n < f->length && !fmpz_is_zero(f->coeffs + n)) + if (n < poly->length && !fmpz_is_zero(poly->coeffs + n)) { - fmpz_set(padic_unit(x), f->coeffs + n); - padic_val(x) = f->val; - padic_prec(x) = f->N; - padic_reduce(x, ctx); + fmpz_set(padic_unit(c), poly->coeffs + n); + padic_val(c) = poly->val; + padic_prec(c) = poly->N; + padic_reduce(c, ctx); } else { - padic_zero(x); + padic_zero(c); } } diff --git a/src/padic_poly/inv_series.c b/src/padic_poly/inv_series.c index 2343543a5c..a717bb18c9 100644 --- a/src/padic_poly/inv_series.c +++ b/src/padic_poly/inv_series.c @@ -62,7 +62,7 @@ _fmpz_mod_poly_inv_series_pure_newton(fmpz * Qinv, const fmpz * Q, slong n, } } -void padic_poly_inv_series(padic_poly_t Qinv, const padic_poly_t Q, slong n, +void padic_poly_inv_series(padic_poly_t g, const padic_poly_t f, slong n, const padic_ctx_t ctx) { fmpz_t cinv; @@ -73,24 +73,24 @@ void padic_poly_inv_series(padic_poly_t Qinv, const padic_poly_t Q, slong n, fmpz *Qcopy; int Qalloc; - if (Q->length == 0 || fmpz_is_zero(Q->coeffs + 0)) + if (f->length == 0 || fmpz_is_zero(f->coeffs + 0)) { flint_throw(FLINT_ERROR, "Exception (padic_poly_inv_series): Constant term is zero.\n"); } - if (fmpz_divisible(Q->coeffs + 0, ctx->p)) + if (fmpz_divisible(f->coeffs + 0, ctx->p)) { flint_throw(FLINT_ERROR, "Exception (padic_poly_inv_series):\nValuation of constant term is not minimal.\n"); } - if (- Q->val >= Qinv->N) + if (- f->val >= g->N) { - padic_poly_zero(Qinv); + padic_poly_zero(g); return; } - if (Q->length >= n) + if (f->length >= n) { - Qcopy = Q->coeffs; + Qcopy = f->coeffs; Qalloc = 0; } else @@ -98,8 +98,8 @@ void padic_poly_inv_series(padic_poly_t Qinv, const padic_poly_t Q, slong n, slong i; Qcopy = (fmpz *) flint_malloc(n * sizeof(fmpz)); - for (i = 0; i < Q->length; i++) - Qcopy[i] = Q->coeffs[i]; + for (i = 0; i < f->length; i++) + Qcopy[i] = f->coeffs[i]; mpn_zero((nn_ptr) Qcopy + i, n - i); Qalloc = 1; } @@ -107,15 +107,15 @@ void padic_poly_inv_series(padic_poly_t Qinv, const padic_poly_t Q, slong n, fmpz_init(cinv); fmpz_init(pow); - _padic_inv(cinv, Q->coeffs, ctx->p, Qinv->N + Q->val); - palloc = _padic_ctx_pow_ui(pow, Qinv->N + Q->val, ctx); + _padic_inv(cinv, f->coeffs, ctx->p, g->N + f->val); + palloc = _padic_ctx_pow_ui(pow, g->N + f->val, ctx); - if (Qinv != Q) + if (g != f) { - padic_poly_fit_length(Qinv, n); + padic_poly_fit_length(g, n); /* fails: _fmpz_vec_scalar_mod_fmpz(Qcopy, Qcopy, n, pow); */ - _fmpz_mod_poly_inv_series_pure_newton(Qinv->coeffs, Qcopy, n, cinv, pow); + _fmpz_mod_poly_inv_series_pure_newton(g->coeffs, Qcopy, n, cinv, pow); } else { @@ -123,16 +123,16 @@ void padic_poly_inv_series(padic_poly_t Qinv, const padic_poly_t Q, slong n, /* fails: _fmpz_vec_scalar_mod_fmpz(Qcopy, Qcopy, n, pow); */ _fmpz_mod_poly_inv_series_pure_newton(t, Qcopy, n, cinv, pow); - _fmpz_vec_clear(Qinv->coeffs, Qinv->alloc); - Qinv->coeffs = t; - Qinv->alloc = n; - Qinv->length = n; + _fmpz_vec_clear(g->coeffs, g->alloc); + g->coeffs = t; + g->alloc = n; + g->length = n; } - Qinv->val = - Q->val; + g->val = - f->val; - _padic_poly_set_length(Qinv, n); - _padic_poly_normalise(Qinv); + _padic_poly_set_length(g, n); + _padic_poly_normalise(g); fmpz_clear(cinv); if (palloc) diff --git a/src/padic_poly/io.c b/src/padic_poly/io.c index da49222a52..75135dd7b1 100644 --- a/src/padic_poly/io.c +++ b/src/padic_poly/io.c @@ -194,7 +194,7 @@ int padic_poly_fprint(FILE *file, const padic_poly_t poly, const padic_ctx_t ctx int padic_poly_fprint_pretty(FILE * file, const padic_poly_t poly, const char * var, const padic_ctx_t ctx) { return _padic_poly_fprint_pretty(file, poly->coeffs, poly->length, poly->val, var, ctx); } int _padic_poly_print(const fmpz *poly, slong val, slong len, const padic_ctx_t ctx) { return _padic_poly_fprint(stdout, poly, val, len, ctx); } int padic_poly_print(const padic_poly_t poly, const padic_ctx_t ctx) { return padic_poly_fprint(stdout, poly, ctx); } -int _padic_poly_print_pretty(const fmpz *poly, slong val, slong len, const char *var, const padic_ctx_t ctx) { return _padic_poly_fprint_pretty(stdout, poly, val, len, var, ctx); } +int _padic_poly_print_pretty(const fmpz *poly, slong len, slong val, const char *var, const padic_ctx_t ctx) { return _padic_poly_fprint_pretty(stdout, poly, len, val, var, ctx); } int padic_poly_print_pretty(const padic_poly_t poly, const char *var, const padic_ctx_t ctx) { return padic_poly_fprint_pretty(stdout, poly, var, ctx); } int padic_poly_debug(const padic_poly_t poly) diff --git a/src/padic_poly/mul.c b/src/padic_poly/mul.c index be2fd53df9..0879394ab1 100644 --- a/src/padic_poly/mul.c +++ b/src/padic_poly/mul.c @@ -33,47 +33,47 @@ void _padic_poly_mul(fmpz *rop, slong *rval, slong N, fmpz_clear(pow); } -void padic_poly_mul(padic_poly_t f, - const padic_poly_t g, const padic_poly_t h, +void padic_poly_mul(padic_poly_t res, + const padic_poly_t poly1, const padic_poly_t poly2, const padic_ctx_t ctx) { - const slong lenG = g->length; - const slong lenH = h->length; + const slong lenG = poly1->length; + const slong lenH = poly2->length; const slong lenF = lenG + lenH - 1; - if (lenG == 0 || lenH == 0 || g->val + h->val >= f->N) + if (lenG == 0 || lenH == 0 || poly1->val + poly2->val >= res->N) { - padic_poly_zero(f); + padic_poly_zero(res); } else { fmpz *t; - if (f == g || f == h) + if (res == poly1 || res == poly2) { t = _fmpz_vec_init(lenF); } else { - padic_poly_fit_length(f, lenF); - t = f->coeffs; + padic_poly_fit_length(res, lenF); + t = res->coeffs; } if (lenG >= lenH) - _padic_poly_mul(t, &(f->val), f->N, g->coeffs, g->val, lenG, - h->coeffs, h->val, lenH, ctx); + _padic_poly_mul(t, &(res->val), res->N, poly1->coeffs, poly1->val, lenG, + poly2->coeffs, poly2->val, lenH, ctx); else - _padic_poly_mul(t, &(f->val), f->N, h->coeffs, h->val, lenH, - g->coeffs, g->val, lenG, ctx); + _padic_poly_mul(t, &(res->val), res->N, poly2->coeffs, poly2->val, lenH, + poly1->coeffs, poly1->val, lenG, ctx); - if (f == g || f == h) + if (res == poly1 || res == poly2) { - _fmpz_vec_clear(f->coeffs, f->alloc); - f->coeffs = t; - f->alloc = lenF; + _fmpz_vec_clear(res->coeffs, res->alloc); + res->coeffs = t; + res->alloc = lenF; } - _padic_poly_set_length(f, lenF); - _padic_poly_normalise(f); + _padic_poly_set_length(res, lenF); + _padic_poly_normalise(res); } } diff --git a/src/padic_poly/set_coeff_padic.c b/src/padic_poly/set_coeff_padic.c index 8ee1224d4f..51791cf581 100644 --- a/src/padic_poly/set_coeff_padic.c +++ b/src/padic_poly/set_coeff_padic.c @@ -14,10 +14,10 @@ #include "padic.h" #include "padic_poly.h" -void padic_poly_set_coeff_padic(padic_poly_t poly, slong n, const padic_t x, +void padic_poly_set_coeff_padic(padic_poly_t poly, slong n, const padic_t c, const padic_ctx_t ctx) { - if (padic_is_zero(x) || padic_val(x) >= padic_poly_prec(poly)) + if (padic_is_zero(c) || padic_val(c) >= padic_poly_prec(poly)) { if (n < poly->length) { @@ -35,41 +35,41 @@ void padic_poly_set_coeff_padic(padic_poly_t poly, slong n, const padic_t x, poly->length = n + 1; } - if (padic_val(x) == poly->val) + if (padic_val(c) == poly->val) { - fmpz_set(poly->coeffs + n, padic_unit(x)); + fmpz_set(poly->coeffs + n, padic_unit(c)); } - else if (poly->val < padic_val(x)) + else if (poly->val < padic_val(c)) { fmpz_t y; fmpz_init(y); - fmpz_pow_ui(y, ctx->p, padic_val(x) - poly->val); - fmpz_mul(poly->coeffs + n, padic_unit(x), y); + fmpz_pow_ui(y, ctx->p, padic_val(c) - poly->val); + fmpz_mul(poly->coeffs + n, padic_unit(c), y); fmpz_clear(y); padic_poly_canonicalise(poly, ctx->p); } - else /* poly->val > x->val */ + else /* poly->val > c->val */ { fmpz_t pow; fmpz_init(pow); - fmpz_pow_ui(pow, ctx->p, poly->val - padic_val(x)); + fmpz_pow_ui(pow, ctx->p, poly->val - padic_val(c)); _fmpz_vec_scalar_mul_fmpz(poly->coeffs, poly->coeffs, poly->length, pow); - fmpz_set(poly->coeffs + n, padic_unit(x)); + fmpz_set(poly->coeffs + n, padic_unit(c)); fmpz_clear(pow); - poly->val = padic_val(x); + poly->val = padic_val(c); } - if (padic_poly_prec(poly) < padic_prec(x)) /* Reduction? */ + if (padic_poly_prec(poly) < padic_prec(c)) /* Reduction? */ { - int c; + int alloc; fmpz_t pow; - c = _padic_ctx_pow_ui(pow, padic_poly_prec(poly) - padic_poly_val(poly), ctx); + alloc = _padic_ctx_pow_ui(pow, padic_poly_prec(poly) - padic_poly_val(poly), ctx); fmpz_mod(poly->coeffs + n, poly->coeffs + n, pow); - if (c) + if (alloc) fmpz_clear(pow); } diff --git a/src/padic_poly/set_fmpq_poly.c b/src/padic_poly/set_fmpq_poly.c index e9cb205de1..747aa59336 100644 --- a/src/padic_poly/set_fmpq_poly.c +++ b/src/padic_poly/set_fmpq_poly.c @@ -13,39 +13,39 @@ #include "padic.h" #include "padic_poly.h" -void padic_poly_set_fmpq_poly(padic_poly_t f, - const fmpq_poly_t g, const padic_ctx_t ctx) +void padic_poly_set_fmpq_poly(padic_poly_t rop, + const fmpq_poly_t op, const padic_ctx_t ctx) { - const slong len = g->length; + const slong len = op->length; if (len == 0) { - padic_poly_zero(f); + padic_poly_zero(rop); } else { - const slong N = padic_poly_prec(f); + const slong N = padic_poly_prec(rop); fmpz_t t; fmpz_init(t); - f->val = - fmpz_remove(t, g->den, ctx->p); + rop->val = - fmpz_remove(t, op->den, ctx->p); - if (f->val < N) + if (rop->val < N) { - padic_poly_fit_length(f, len); - _padic_poly_set_length(f, len); + padic_poly_fit_length(rop, len); + _padic_poly_set_length(rop, len); - _padic_inv(t, t, ctx->p, N - f->val); - _fmpz_vec_scalar_mul_fmpz(f->coeffs, g->coeffs, len, t); - if (f->val == 0) - padic_poly_canonicalise(f, ctx->p); + _padic_inv(t, t, ctx->p, N - rop->val); + _fmpz_vec_scalar_mul_fmpz(rop->coeffs, op->coeffs, len, t); + if (rop->val == 0) + padic_poly_canonicalise(rop, ctx->p); - padic_poly_reduce(f, ctx); + padic_poly_reduce(rop, ctx); } else { - padic_poly_zero(f); + padic_poly_zero(rop); } fmpz_clear(t); diff --git a/src/padic_poly/set_fmpz_poly.c b/src/padic_poly/set_fmpz_poly.c index 00b741f29d..fca5704aa4 100644 --- a/src/padic_poly/set_fmpz_poly.c +++ b/src/padic_poly/set_fmpz_poly.c @@ -12,16 +12,16 @@ #include "fmpz_vec.h" #include "padic_poly.h" -void padic_poly_set_fmpz_poly(padic_poly_t f, const fmpz_poly_t g, +void padic_poly_set_fmpz_poly(padic_poly_t rop, const fmpz_poly_t op, const padic_ctx_t ctx) { - const slong len = g->length; + const slong len = op->length; - padic_poly_fit_length(f, len); - _padic_poly_set_length(f, len); - _fmpz_vec_set(f->coeffs, g->coeffs, len); - f->val = 0; + padic_poly_fit_length(rop, len); + _padic_poly_set_length(rop, len); + _fmpz_vec_set(rop->coeffs, op->coeffs, len); + rop->val = 0; - padic_poly_canonicalise(f, ctx->p); - padic_poly_reduce(f, ctx); + padic_poly_canonicalise(rop, ctx->p); + padic_poly_reduce(rop, ctx); } diff --git a/src/padic_poly/sub.c b/src/padic_poly/sub.c index 675b3c29e7..a19ff4c223 100644 --- a/src/padic_poly/sub.c +++ b/src/padic_poly/sub.c @@ -14,19 +14,19 @@ #include "padic.h" #include "padic_poly.h" -void _padic_poly_sub(fmpz *rop, slong *val, slong N, +void _padic_poly_sub(fmpz *rop, slong *rval, slong N, const fmpz *op1, slong val1, slong len1, slong FLINT_UNUSED(N1), const fmpz *op2, slong val2, slong len2, slong FLINT_UNUSED(N2), const padic_ctx_t ctx) { const slong len = FLINT_MAX(len1, len2); - *val = FLINT_MIN(val1, val2); + *rval = FLINT_MIN(val1, val2); if (val1 == val2) { _fmpz_poly_sub(rop, op1, len1, op2, len2); - _padic_poly_canonicalise(rop, val, len, ctx->p); + _padic_poly_canonicalise(rop, rval, len, ctx->p); } else { @@ -69,17 +69,17 @@ void _padic_poly_sub(fmpz *rop, slong *val, slong N, } /* Reduce */ - if (N - *val > 0) + if (N - *rval > 0) { fmpz_t pow; int alloc; - alloc = _padic_ctx_pow_ui(pow, N - *val, ctx); + alloc = _padic_ctx_pow_ui(pow, N - *rval, ctx); _fmpz_vec_scalar_mod_fmpz(rop, rop, len, pow); if (_fmpz_vec_is_zero(rop, len)) - *val = 0; + *rval = 0; if (alloc) fmpz_clear(pow); @@ -87,7 +87,7 @@ void _padic_poly_sub(fmpz *rop, slong *val, slong N, else { _fmpz_vec_zero(rop, len); - *val = 0; + *rval = 0; } } diff --git a/src/thread_pool.h b/src/thread_pool.h index b536ff86ef..964fd6a451 100644 --- a/src/thread_pool.h +++ b/src/thread_pool.h @@ -60,7 +60,7 @@ FLINT_DLL extern int global_thread_pool_initialized; void * thread_pool_idle_loop(void * varg); -void thread_pool_init(thread_pool_t T, slong l); +void thread_pool_init(thread_pool_t T, slong size); int thread_pool_set_affinity(thread_pool_t T, int * cpus, slong length);