First batch of doc <-> header <-> source alignment

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.

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)

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.
 

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)
 
 

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)

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);
 }

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));
 }

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,

src/arb_calc/isolate_roots.c

@@ -144,39 +144,39 @@ 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;
 
     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;

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 */
 

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);

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)

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);
 }