fix wonky argument order in mat_randops methods

doc/source/fq_default_mat.rst

@@ -207,7 +207,7 @@ Random matrix generation
     The matrix can be transformed into a dense matrix with unchanged
     rank by subsequently calling :func:`fq_default_mat_randops`.
 
-.. function:: void fq_default_mat_randops(fq_default_mat_t mat, slong count, flint_rand_t state, const fq_default_ctx_t ctx)
+.. function:: void fq_default_mat_randops(fq_default_mat_t mat, flint_rand_t state, slong count, const fq_default_ctx_t ctx)
 
     Randomises ``mat`` by performing elementary row or column
     operations. More precisely, at most ``count`` random additions

doc/source/fq_mat.rst

@@ -204,7 +204,7 @@ Random matrix generation
     The matrix can be transformed into a dense matrix with unchanged
     rank by subsequently calling :func:`fq_mat_randops`.
 
-.. function:: void fq_mat_randops(fq_mat_t mat, slong count, flint_rand_t state, const fq_ctx_t ctx)
+.. function:: void fq_mat_randops(fq_mat_t mat, flint_rand_t state, slong count, const fq_ctx_t ctx)
 
     Randomises ``mat`` by performing elementary row or column
     operations. More precisely, at most ``count`` random additions

doc/source/fq_nmod_mat.rst

@@ -203,7 +203,7 @@ Random matrix generation
     The matrix can be transformed into a dense matrix with unchanged
     rank by subsequently calling :func:`fq_nmod_mat_randops`.
 
-.. function:: void fq_nmod_mat_randops(fq_nmod_mat_t mat, slong count, flint_rand_t state, const fq_nmod_ctx_t ctx)
+.. function:: void fq_nmod_mat_randops(fq_nmod_mat_t mat, flint_rand_t state, slong count, const fq_nmod_ctx_t ctx)
 
     Randomises ``mat`` by performing elementary row or column
     operations. More precisely, at most ``count`` random additions

doc/source/fq_zech_mat.rst

@@ -181,7 +181,7 @@ Random matrix generation
     The matrix can be transformed into a dense matrix with unchanged
     rank by subsequently calling :func:`fq_zech_mat_randops`.
 
-.. function:: void fq_zech_mat_randops(fq_zech_mat_t mat, slong count, flint_rand_t state, const fq_zech_ctx_t ctx)
+.. function:: void fq_zech_mat_randops(fq_zech_mat_t mat, flint_rand_t state, slong count, const fq_zech_ctx_t ctx)
 
     Randomises ``mat`` by performing elementary row or column
     operations. More precisely, at most ``count`` random additions

doc/source/nmod_mat.rst

@@ -213,7 +213,7 @@ Random matrix generation
     The matrix can be transformed into a dense matrix with unchanged
     rank by subsequently calling :func:`nmod_mat_randops`.
 
-.. function:: void nmod_mat_randops(nmod_mat_t mat, slong count, flint_rand_t state)
+.. function:: void nmod_mat_randops(nmod_mat_t mat, flint_rand_t state, slong count)
 
     Randomises ``mat`` by performing elementary row or column
     operations. More precisely, at most ``count`` random additions

src/fmpz_mod_mat.h

@@ -106,7 +106,7 @@ void fmpz_mod_mat_randtril(fmpz_mod_mat_t mat, flint_rand_t state, int unit, con
 void fmpz_mod_mat_randtriu(fmpz_mod_mat_t mat, flint_rand_t state, int unit, const fmpz_mod_ctx_t ctx);
 
 FMPZ_MOD_MAT_INLINE
-void fmpz_mod_mat_randops(fmpz_mod_mat_t mat, slong count, flint_rand_t state, const fmpz_mod_ctx_t ctx)
+void fmpz_mod_mat_randops(fmpz_mod_mat_t mat, flint_rand_t state, slong count, const fmpz_mod_ctx_t ctx)
 {
     fmpz_mat_randops(mat, state, count);
     _fmpz_mod_mat_reduce(mat, ctx);

src/fmpz_mod_mat/test/t-can_solve.c

@@ -43,7 +43,7 @@ TEST_FUNCTION_START(fmpz_mod_mat_can_solve, state)
 
         /* Dense */
         if (n_randint(state, 2))
-            fmpz_mod_mat_randops(A, 1+n_randint(state, 1+m*m), state, ctx);
+            fmpz_mod_mat_randops(A, state, 1+n_randint(state, 1+m*m), ctx);
 
         solved = fmpz_mod_mat_can_solve(X, A, B, ctx);
         fmpz_mod_mat_mul(AX, A, X, ctx);

src/fmpz_mod_mat/test/t-inv.c

@@ -41,7 +41,7 @@ TEST_FUNCTION_START(fmpz_mod_mat_inv, state)
         fmpz_mod_mat_randrank(A, state, m, ctx);
         /* Dense or sparse? */
         if (n_randint(state, 2))
-            fmpz_mod_mat_randops(A, 1+n_randint(state, 1+m*m), state, ctx);
+            fmpz_mod_mat_randops(A, state, 1+n_randint(state, 1+m*m), ctx);
 
         result = fmpz_mod_mat_inv(B, A, ctx);
         fmpz_mod_mat_mul(C, A, B, ctx);
@@ -75,7 +75,7 @@ TEST_FUNCTION_START(fmpz_mod_mat_inv, state)
 
         /* Dense */
         if (n_randint(state, 2))
-            fmpz_mod_mat_randops(A, 1+n_randint(state, 1+m*m), state, ctx);
+            fmpz_mod_mat_randops(A, state, 1+n_randint(state, 1+m*m), ctx);
 
         FLINT_TEST(!fmpz_mod_mat_inv(B, A, ctx));
         FLINT_TEST(!fmpz_mod_mat_inv(A, A, ctx));

src/fmpz_mod_mat/test/t-lu.c

@@ -100,7 +100,7 @@ TEST_FUNCTION_START(fmpz_mod_mat_lu, state)
             if (n_randint(state, 2))
             {
                 d = n_randint(state, 2 * m * n + 1);
-                fmpz_mod_mat_randops(A, d, state, ctx);
+                fmpz_mod_mat_randops(A, state, d, ctx);
             }
 
             fmpz_mod_mat_init_set(LU, A, ctx);

src/fmpz_mod_mat/test/t-nullspace.c

@@ -41,7 +41,7 @@ TEST_FUNCTION_START(fmpz_mod_mat_nullspace, state)
             fmpz_mod_mat_randrank(A, state, r, ctx);
             /* Densify */
             if (n_randlimb(state) % 2)
-                fmpz_mod_mat_randops(A, d, state, ctx);
+                fmpz_mod_mat_randops(A, state, d, ctx);
 
             nullity = fmpz_mod_mat_nullspace(ker, A, ctx);
             nulrank = fmpz_mod_mat_rank(ker, ctx);

src/fmpz_mod_mat/test/t-rank.c

@@ -51,7 +51,7 @@ TEST_FUNCTION_START(fmpz_mod_mat_rank, state)
             d = n_randint(state, 2 * m * n + 1);
             fmpz_mod_mat_init(A, m, n, ctx);
             fmpz_mod_mat_randrank(A, state, r, ctx);
-            fmpz_mod_mat_randops(A, d, state, ctx);
+            fmpz_mod_mat_randops(A, state, d, ctx);
             FLINT_TEST(r == fmpz_mod_mat_rank(A, ctx));
             fmpz_mod_mat_clear(A, ctx);
         }

src/fmpz_mod_mat/test/t-rref.c

@@ -110,7 +110,7 @@ TEST_FUNCTION_START(fmpz_mod_mat_rref, state)
 
             fmpz_mod_mat_init(A, m, n, ctx);
             fmpz_mod_mat_randrank(A, state, r, ctx);
-            fmpz_mod_mat_randops(A, d, state, ctx);
+            fmpz_mod_mat_randops(A, state, d, ctx);
 
             rank = fmpz_mod_mat_rref(perm, A, ctx);
 

src/fmpz_mod_mat/test/t-solve.c

@@ -40,7 +40,7 @@ TEST_FUNCTION_START(fmpz_mod_mat_solve, state)
 
         /* Dense */
         if (n_randint(state, 2))
-            fmpz_mod_mat_randops(A, 1+n_randint(state, 1+m*m), state, ctx);
+            fmpz_mod_mat_randops(A, state, 1+n_randint(state, 1+m*m), ctx);
 
         solved = fmpz_mod_mat_solve(X, A, B, ctx);
         fmpz_mod_mat_mul(AX, A, X, ctx);
@@ -72,7 +72,7 @@ TEST_FUNCTION_START(fmpz_mod_mat_solve, state)
 
         /* Dense */
         if (n_randint(state, 2))
-            fmpz_mod_mat_randops(A, 1+n_randint(state, 1+m*m), state, ctx);
+            fmpz_mod_mat_randops(A, state, 1+n_randint(state, 1+m*m), ctx);
 
         solved = fmpz_mod_mat_solve(X, A, B, ctx);
         FLINT_TEST(!solved);

src/fq_default_mat.h

@@ -863,27 +863,27 @@ FQ_DEFAULT_MAT_INLINE void fq_default_mat_randrank(fq_default_mat_t mat,
 
 FQ_DEFAULT_MAT_INLINE
 void fq_default_mat_randops(fq_default_mat_t mat,
-                   slong count, flint_rand_t state, const fq_default_ctx_t ctx)
+                   flint_rand_t state, slong count, const fq_default_ctx_t ctx)
 {
     if (ctx->type == FQ_DEFAULT_FQ_ZECH)
     {
-        fq_zech_mat_randops(mat->fq_zech, count, state, ctx->ctx.fq_zech);
+        fq_zech_mat_randops(mat->fq_zech, state, count, ctx->ctx.fq_zech);
     }
     else if (ctx->type == FQ_DEFAULT_FQ_NMOD)
     {
-        fq_nmod_mat_randops(mat->fq_nmod, count, state, ctx->ctx.fq_nmod);
+        fq_nmod_mat_randops(mat->fq_nmod, state, count, ctx->ctx.fq_nmod);
     }
     else if (ctx->type == FQ_DEFAULT_NMOD)
     {
-        nmod_mat_randops(mat->nmod, count, state);
+        nmod_mat_randops(mat->nmod, state, count);
     }
     else if (ctx->type == FQ_DEFAULT_FMPZ_MOD)
     {
-        fmpz_mod_mat_randops(mat->fmpz_mod, count, state, ctx->ctx.fmpz_mod.mod);
+        fmpz_mod_mat_randops(mat->fmpz_mod, state, count, ctx->ctx.fmpz_mod.mod);
     }
     else
     {
-        fq_mat_randops(mat->fq, count, state, ctx->ctx.fq);
+        fq_mat_randops(mat->fq, state, count, ctx->ctx.fq);
     }
 }
 

src/fq_mat_templates.h

@@ -169,8 +169,8 @@ int TEMPLATE(T, mat_randpermdiag)(TEMPLATE(T, mat_t) mat, flint_rand_t state,
                               TEMPLATE(T, struct) * diag, slong n,
                               const TEMPLATE(T, ctx_t) ctx);
 
-void TEMPLATE(T, mat_randops)(TEMPLATE(T, mat_t) mat, slong count,
-                         flint_rand_t state, const TEMPLATE(T, ctx_t) ctx);
+void TEMPLATE(T, mat_randops)(TEMPLATE(T, mat_t) mat,
+                         flint_rand_t state, slong count, const TEMPLATE(T, ctx_t) ctx);
 
 void TEMPLATE(T, mat_randtril)(TEMPLATE(T, mat_t) mat, flint_rand_t state,
                           int unit, const TEMPLATE(T, ctx_t) ctx);

src/fq_mat_templates/randops.c

@@ -15,8 +15,8 @@
 #include "templates.h"
 
 void
-TEMPLATE(T, mat_randops) (TEMPLATE(T, mat_t) mat, slong count,
-                          flint_rand_t state, const TEMPLATE(T, ctx_t) ctx)
+TEMPLATE(T, mat_randops) (TEMPLATE(T, mat_t) mat,
+                          flint_rand_t state, slong count, const TEMPLATE(T, ctx_t) ctx)
 {
     slong c, i, j, k;
     slong m = mat->r;

src/fq_mat_templates/test/t-can_solve.c

@@ -43,7 +43,7 @@ TEST_TEMPLATE_FUNCTION_START(T, mat_can_solve, state)
 
         /* Dense */
         if (n_randint(state, 2))
-            TEMPLATE(T, mat_randops)(A, 1+n_randint(state, 1+m*m), state, ctx);
+            TEMPLATE(T, mat_randops)(A, state, 1+n_randint(state, 1+m*m), ctx);
 
         solved = TEMPLATE(T, mat_can_solve)(X, A, B, ctx);
 

src/fq_mat_templates/test/t-inv.c

@@ -40,7 +40,7 @@ TEST_TEMPLATE_FUNCTION_START(T, mat_inv, state)
         TEMPLATE(T, mat_randrank)(A, state, m, ctx);
         /* Dense or sparse? */
         if (n_randint(state, 2))
-            TEMPLATE(T, mat_randops)(A, 1+n_randint(state, 1+m*m), state, ctx);
+            TEMPLATE(T, mat_randops)(A, state, 1+n_randint(state, 1+m*m), ctx);
 
         result = TEMPLATE(T, mat_inv)(B, A, ctx);
         TEMPLATE(T, mat_mul)(C, A, B, ctx);
@@ -96,7 +96,7 @@ TEST_TEMPLATE_FUNCTION_START(T, mat_inv, state)
 
         /* Dense */
         if (n_randint(state, 2))
-            TEMPLATE(T, mat_randops)(A, 1+n_randint(state, 1+m*m), state, ctx);
+            TEMPLATE(T, mat_randops)(A, state, 1+n_randint(state, 1+m*m), ctx);
 
         result = TEMPLATE(T, mat_inv)(B, A, ctx);
 

src/fq_mat_templates/test/t-lu_classical.c

@@ -131,7 +131,7 @@ TEST_TEMPLATE_FUNCTION_START(T, mat_lu_classical, state)
             if (n_randint(state, 2))
             {
                 d = n_randint(state, 2 * m * n + 1);
-                TEMPLATE(T, mat_randops) (A, d, state, ctx);
+                TEMPLATE(T, mat_randops) (A, state, d, ctx);
             }
 
             TEMPLATE(T, mat_init_set) (LU, A, ctx);

src/fq_mat_templates/test/t-lu_recursive.c

@@ -131,7 +131,7 @@ TEST_TEMPLATE_FUNCTION_START(T, mat_lu_recursive, state)
             if (n_randint(state, 2))
             {
                 d = n_randint(state, 2 * m * n + 1);
-                TEMPLATE(T, mat_randops) (A, d, state, ctx);
+                TEMPLATE(T, mat_randops) (A, state, d, ctx);
             }
 
             TEMPLATE(T, mat_init_set) (LU, A, ctx);

src/fq_mat_templates/test/t-nullspace.c

@@ -41,7 +41,7 @@ TEST_TEMPLATE_FUNCTION_START(T, mat_nullspace, state)
             TEMPLATE(T, mat_randrank) (A, state, r, ctx);
             /* Densify */
             if (n_randlimb(state) % 2)
-                TEMPLATE(T, mat_randops) (A, d, state, ctx);
+                TEMPLATE(T, mat_randops) (A, state, d, ctx);
 
             nullity = TEMPLATE(T, mat_nullspace) (ker, A, ctx);
             nulrank = TEMPLATE(T, mat_rank) (ker, ctx);

src/fq_mat_templates/test/t-rank.c

@@ -57,7 +57,7 @@ TEST_TEMPLATE_FUNCTION_START(T, mat_rank, state)
             d = n_randint(state, 2 * m * n + 1);
             TEMPLATE(T, mat_init) (A, m, n, ctx);
             TEMPLATE(T, mat_randrank) (A, state, r, ctx);
-            TEMPLATE(T, mat_randops) (A, d, state, ctx);
+            TEMPLATE(T, mat_randops) (A, state, d, ctx);
             if (r != TEMPLATE(T, mat_rank) (A, ctx))
             {
                 flint_printf("FAIL:\n");

src/fq_mat_templates/test/t-solve.c

@@ -40,7 +40,7 @@ TEST_TEMPLATE_FUNCTION_START(T, mat_solve, state)
 
         /* Dense */
         if (n_randint(state, 2))
-            TEMPLATE(T, mat_randops)(A, 1+n_randint(state, 1+m*m), state, ctx);
+            TEMPLATE(T, mat_randops)(A, state, 1+n_randint(state, 1+m*m), ctx);
 
         solved = TEMPLATE(T, mat_solve)(X, A, B, ctx);
 
@@ -89,7 +89,7 @@ TEST_TEMPLATE_FUNCTION_START(T, mat_solve, state)
 
         /* Dense */
         if (n_randint(state, 2))
-            TEMPLATE(T, mat_randops)(A, 1+n_randint(state, 1+m*m), state, ctx);
+            TEMPLATE(T, mat_randops)(A, state, 1+n_randint(state, 1+m*m), ctx);
 
         solved = TEMPLATE(T, mat_solve)(X, A, B, ctx);
 

src/nmod_mat.h

@@ -94,7 +94,7 @@ void nmod_mat_randfull(nmod_mat_t mat, flint_rand_t state);
 int nmod_mat_randpermdiag(nmod_mat_t mat, flint_rand_t state,
                  mp_srcptr diag, slong n);
 void nmod_mat_randrank(nmod_mat_t, flint_rand_t state, slong rank);
-void nmod_mat_randops(nmod_mat_t mat, slong count, flint_rand_t state);
+void nmod_mat_randops(nmod_mat_t mat, flint_rand_t state, slong count);
 void nmod_mat_randtril(nmod_mat_t mat, flint_rand_t state, int unit);
 void nmod_mat_randtriu(nmod_mat_t mat, flint_rand_t state, int unit);
 

src/nmod_mat/randops.c

@@ -13,7 +13,7 @@
 #include "nmod_mat.h"
 
 void
-nmod_mat_randops(nmod_mat_t mat, slong count, flint_rand_t state)
+nmod_mat_randops(nmod_mat_t mat, flint_rand_t state, slong count)
 {
     slong c, i, j, k;
     slong m = mat->r;

src/nmod_mat/test/t-can_solve.c

@@ -39,7 +39,7 @@ TEST_FUNCTION_START(nmod_mat_can_solve, state)
 
         /* Dense */
         if (n_randint(state, 2))
-            nmod_mat_randops(A, 1+n_randint(state, 1+m*m), state);
+            nmod_mat_randops(A, state, 1+n_randint(state, 1+m*m));
 
         solved = nmod_mat_can_solve(X, A, B);
 

src/nmod_mat/test/t-det.c

@@ -37,13 +37,13 @@ TEST_FUNCTION_START(nmod_mat_det, state)
         {
             case 0:
                 nmod_mat_randrank(A, state, m);
-                nmod_mat_randops(A, n_randint(state, 2*m + 1), state);
+                nmod_mat_randops(A, state, n_randint(state, 2*m + 1));
                 break;
             case 1:
                 t = n_randint(state, m);
                 t = FLINT_MIN(t, m);
                 nmod_mat_randrank(A, state, t);
-                nmod_mat_randops(A, n_randint(state, 2*m + 1), state);
+                nmod_mat_randops(A, state, n_randint(state, 2*m + 1));
                 break;
             default:
                 nmod_mat_randtest(A, state);

src/nmod_mat/test/t-det_howell.c

@@ -37,13 +37,13 @@ TEST_FUNCTION_START(nmod_mat_det_howell, state)
         {
             case 0:
                 nmod_mat_randrank(A, state, m);
-                nmod_mat_randops(A, n_randint(state, 2*m + 1), state);
+                nmod_mat_randops(A, state, n_randint(state, 2*m + 1));
                 break;
             case 1:
                 t = n_randint(state, m);
                 t = FLINT_MIN(t, m);
                 nmod_mat_randrank(A, state, t);
-                nmod_mat_randops(A, n_randint(state, 2*m + 1), state);
+                nmod_mat_randops(A, state, n_randint(state, 2*m + 1));
                 break;
             default:
                 nmod_mat_randtest(A, state);

src/nmod_mat/test/t-inv.c

@@ -38,7 +38,7 @@ TEST_FUNCTION_START(nmod_mat_inv, state)
         nmod_mat_randrank(A, state, m);
         /* Dense or sparse? */
         if (n_randint(state, 2))
-            nmod_mat_randops(A, 1+n_randint(state, 1+m*m), state);
+            nmod_mat_randops(A, state, 1+n_randint(state, 1+m*m));
 
         result = nmod_mat_inv(B, A);
         nmod_mat_mul(C, A, B);
@@ -82,7 +82,7 @@ TEST_FUNCTION_START(nmod_mat_inv, state)
 
         /* Dense */
         if (n_randint(state, 2))
-            nmod_mat_randops(A, 1+n_randint(state, 1+m*m), state);
+            nmod_mat_randops(A, state, 1+n_randint(state, 1+m*m));
 
         result = nmod_mat_inv(B, A);
 

src/nmod_mat/test/t-lu_classical.c

@@ -103,7 +103,7 @@ TEST_FUNCTION_START(nmod_mat_lu_classical, state)
             if (n_randint(state, 2))
             {
                 d = n_randint(state, 2*m*n + 1);
-                nmod_mat_randops(A, d, state);
+                nmod_mat_randops(A, state, d);
             }
 
             nmod_mat_init_set(LU, A);

src/nmod_mat/test/t-lu_classical_delayed.c

@@ -105,7 +105,7 @@ TEST_FUNCTION_START(nmod_mat_lu_classical_delayed, state)
             if (n_randint(state, 2))
             {
                 d = n_randint(state, 2*m*n + 1);
-                nmod_mat_randops(A, d, state);
+                nmod_mat_randops(A, state, d);
             }
 
             nmod_mat_init_set(LU, A);

src/nmod_mat/test/t-lu_recursive.c

@@ -103,7 +103,7 @@ TEST_FUNCTION_START(nmod_mat_lu_recursive, state)
             if (n_randint(state, 2))
             {
                 d = n_randint(state, 2*m*n + 1);
-                nmod_mat_randops(A, d, state);
+                nmod_mat_randops(A, state, d);
             }
 
             nmod_mat_init_set(LU, A);

src/nmod_mat/test/t-nullspace.c

@@ -38,7 +38,7 @@ TEST_FUNCTION_START(nmod_mat_nullspace, state)
             nmod_mat_randrank(A, state, r);
             /* Densify */
             if (n_randlimb(state) % 2)
-                nmod_mat_randops(A, d, state);
+                nmod_mat_randops(A, state, d);
 
             nullity = nmod_mat_nullspace(ker, A);
             nulrank = nmod_mat_rank(ker);

src/nmod_mat/test/t-rank.c

@@ -51,7 +51,7 @@ TEST_FUNCTION_START(nmod_mat_rank, state)
             d = n_randint(state, 2*m*n + 1);
             nmod_mat_init(A, m, n, mod);
             nmod_mat_randrank(A, state, r);
-            nmod_mat_randops(A, d, state);
+            nmod_mat_randops(A, state, d);
             /*
             flint_printf("DENSE %wd %wd\n", r, d);
             nmod_mat_print_pretty(A); */