示例#1
0
// generate a random mpz_mat_t with the given number of rows and columns and number of bits per entry
void mpz_randmat(mpz_mat_t mat, ulong r, ulong c, ulong maxbits)
{
   ulong bits;
   mpz_t temp;
   mpz_init(temp);
   
   long i;
   for (i = 0; i < r; i++)
   {
		long j;
		for (j = 0; j < c; j++)
		{
#if VARY_BITS
         bits = z_randint(maxbits+1);
#else
         bits = maxbits;
#endif
         if (bits == 0) mpz_set_ui(temp, 0);
         else 
         {
#if SPARSE
            if (z_randint(10) == 1) mpz_rrandomb(temp, randstate, bits);
            else mpz_set_ui(temp, 0);
#else
            mpz_rrandomb(temp, randstate, bits);
#endif
#if SIGNS
            if (z_randint(2)) mpz_neg(temp, temp);
#endif
         }
         mpz_set(mat->entries[i*c+j], temp);
		}
   }
   mpz_clear(temp);
} 
示例#2
0
void mpz_mat_randintrel(mpz_mat_t mat, ulong r, ulong c, ulong maxbits)
{
   ulong bits;
   mpz_t temp;
   mpz_init(temp);

   long i;
   for (i = 0; i < r; i++)
   {
#if VARY_BITS
      bits = z_randint(maxbits+1);
#else
      bits = maxbits;
#endif
      if (bits == 0) mpz_set_ui(temp, 0);
      else 
      {
         mpz_rrandomb(temp, randstate, bits);
#if SIGNS
         if (z_randint(2)) mpz_neg(temp, temp);
#endif
      }
      mpz_set(mat->entries[i*c + c - 1], temp);
      long j;
      for (j = 0; j < i; j++)
         mpz_set_ui(mat->entries[i*c + j], 0);
      mpz_set_ui(mat->entries[i*c + i], 1);
      for (j = i + 1; j < c - 1; j++)
         mpz_set_ui(mat->entries[i*c + j], 0);
   }

   mpz_clear(temp);

}
示例#3
0
int test_heuristic_scalar_product()
{
   int result = 1;
   ulong count1, count2, i;

   double ** mat;
   F_mpz_mat_t B;
   int expo[50];

   for (count1 = 0; count1 < 1000; count1++)
   {
	   ulong rows = z_randint(50) + 1;
      ulong cols = z_randint(50) + 2;

	   F_mpz_mat_init(B, rows, cols);
      F_mpz_randmat(B, rows, cols, 900);

      mat = d_mat_init(rows, cols);

	   for (i = 0; i < rows; i++)
	      expo[i] = _F_mpz_vec_to_d_vec_2exp(mat[i], B->rows[i], cols);

      for (count2 = 0; (count2 < 100); count2++)
      {
	      ulong r1 = z_randint(rows);
		   ulong r2 = z_randint(rows);

		   double d1 = heuristic_scalar_product(mat[r1], mat[r2], cols, 
								B, r1, r2, expo[r1] + expo[r2]);
		   double d2 = heuristic_scalar_product(mat[r1], mat[r1], cols, 
								B, r1, r1, expo[r1] + expo[r1]);
		   double d3 = heuristic_scalar_product(mat[r2], mat[r2], cols, 
								B, r2, r2, expo[r2] + expo[r2]);

         _d_vec_add(mat[r2], mat[r1], mat[r2], cols);
		   _F_mpz_vec_add(B->rows[r2], B->rows[r1], B->rows[r2], cols);

		   double d4 = heuristic_scalar_product(mat[r2], mat[r2], cols, 
								B, r2, r2, expo[r2] + expo[r2]);

		   result = (fabs(d4 - d3 - d2 - 2*d1) < 1.0E-12);

		   if (!result)
		   {
		      printf("count2 = %ld Failed expo[r1] = %d expo[r2] = %d,  d1 = %lf, d2 = %lf, d3 = %lf, d4 = %f\n", count2, expo[r1], expo[r2], d1, d2, d3, d4);
		   }

         expo[r2] = _F_mpz_vec_to_d_vec_2exp(mat[r2], B->rows[r2], cols);

      }

      F_mpz_mat_clear(B);
      d_mat_clear(mat);
   }

   return result;
}
示例#4
0
文件: t-get_str.c 项目: goens/flint2
int
main(void)
{
    int i, result;
    flint_rand_t state;

    printf("get_str... ");
    fflush(stdout);

    flint_randinit(state);

    for (i = 0; i < 10000; i++)
    {
        fmpz_t p;
        long N;
        padic_ctx_t ctx;

        padic_t x;
        fmpq_t y;

        char *s, *t;

        fmpz_init(p);
        fmpz_set_ui(p, n_randprime(state, 5, 1));
        N = z_randint(state, 50) + 1;
        padic_ctx_init(ctx, p, N, PADIC_TERSE);

        padic_init(x, ctx);
        fmpq_init(y);

        padic_randtest(x, state, ctx);
        _padic_get_fmpq(y, x, ctx);

        s = _padic_get_str(NULL, x, ctx);
        t = fmpq_get_str(NULL, 10, y);

        result = strcmp(s, t) == 0;
        if (!result)
        {
            printf("FAIL:\n\n");
            printf("x = "), _padic_print(x, ctx), printf("\n");
            printf("y = "), fmpq_clear(y), printf("\n");
            abort();
        }

        free(s);
        free(t);
        _padic_clear(x);
        fmpq_clear(y);
        padic_ctx_clear(ctx);
    }

    flint_randclear(state);
    _fmpz_cleanup();
    printf("PASS\n");
    return EXIT_SUCCESS;
}
示例#5
0
void F_mpz_test_random(F_mpz_t f, ulong bits)
{
	if (bits == 0)
	{
		F_mpz_zero(f);
      return;
	}
	
	mpz_t temp;
	mpz_init(temp);
	
	mpz_rrandomb(temp, randstate, bits);
#if SIGNS
	if (z_randint(2)) mpz_neg(temp, temp);
#endif
   
	F_mpz_set_mpz(f, temp);

   mpz_clear(temp);
}
示例#6
0
void mpz_mat_randajtai(mpz_mat_t mat, ulong r, ulong c, double alpha)
{
   ulong i, j, d, bits;
   mpz_t tmp;

   r = mat->r;
   c = mat->c;
   d = r;

   if (c != r)
   {
      printf("Exception: mpz_mat_ajtai called on an ill-formed matrix\n");
      abort();
   }

   mpz_init(tmp);

   for (i = 0; i < d; i++)
   {
      bits = (ulong) pow((double) (2*d - i), alpha);

      mpz_rrandomb(mat->entries[i*c + i], randstate, bits);
      mpz_add_ui(mat->entries[i*c + i], mat->entries[i*c + i], 2);
      mpz_fdiv_q_2exp(mat->entries[i*c + i], mat->entries[i*c + i], 1);

	   for (j = i + 1; j < d; j++)
      {
         mpz_rrandomb(mat->entries[j*c + i], randstate, bits);
         if (z_randint(2))
            mpz_neg(mat->entries[j*c + i], mat->entries[j*c + i]);
         mpz_set_ui(mat->entries[i*c + j], 0L);
      }
   }

   mpz_clear(tmp);
}
示例#7
0
文件: mp_poly.c 项目: hperl/flint
void compute_A(QS_t * qs_inf, poly_t * poly_inf)
{
   unsigned long min = poly_inf->min;
   unsigned long span = poly_inf->span;
   unsigned long s = poly_inf->s;
   unsigned long * A_ind = poly_inf->A_ind;
   unsigned long * A = poly_inf->A;
   unsigned long * target_A = poly_inf->target_A;
   unsigned long * current_A = (unsigned long *) flint_stack_alloc(qs_inf->prec+1);  
   unsigned long * diff = (unsigned long *) flint_stack_alloc(qs_inf->prec+1);  
   unsigned long * best_diff = (unsigned long *) flint_stack_alloc(qs_inf->prec+1);  
   prime_t * factor_base = qs_inf->factor_base;
   unsigned long factor, p;
   unsigned long best1, best2, best3;
   unsigned long odds = s - 3;
   mp_limb_t msl;
   int taken;
   long i, j, k;
   
   A[0] = 1;
   A[1] = 1;
   for (i = 0; i < odds; i++) // Randomly choose the first s-3 prime factors of A with odd indices
   {
      do
      {
         taken = 0;
         A_ind[i] = ((z_randint(span) + min) | 1);
         if (A_ind[i] == min + span) A_ind[i] -= 2;
         for (j = 0; j < i; j++)
         {
            if (A_ind[i] == A_ind[j]) taken = 1;
         }  
      } while (taken);
      msl = mpn_mul_1(A+1, A+1, A[0], factor_base[A_ind[i]].p);
      if (msl) // Compute the product of these s-3 primes
      {
         A[A[0]+1] = msl;
         A[0]++;
      }
   }
 
   for (k = 0; k < 30; k++) // Now try 8 different sets of even index primes as the remaining factors
   {
      F_mpn_copy(current_A, A, A[0] + 1);
      for (i = 0; i < 3; i++) // Randomly choose the last 3 prime factors of A with even indices
      {
         do
         {
            taken = 0;
            A_ind[s-3+i] = ((z_randint(span) + min) & -2L);
            if (A_ind[s-3+i] < min) A_ind[s-3+i] += 2;
            for (j = 0; j < i; j++)
            {
               if (A_ind[s-3+i] == A_ind[s-3+j]) taken = 1;
            }  
         } while (taken);

         msl = mpn_mul_1(current_A+1, current_A+1, current_A[0], factor_base[A_ind[s-3+i]].p);
         if (msl) // Compute the product of these s-3 primes and the odd indexed primes
         {
            current_A[current_A[0]+1] = msl;
            current_A[0]++;
         }
      }
      
      if (k == 0)  // Just store the first difference as the best one
      {
         if (target_A[0] >= current_A[0]) // Compute the difference with the target A
         {
            msl = mpn_sub(best_diff+1, target_A+1, target_A[0], current_A+1, current_A[0]);
            best_diff[0] = target_A[0];
         }
         else 
         {
            msl = mpn_sub(best_diff+1, current_A+1, current_A[0], target_A+1, target_A[0]);
            best_diff[0] = current_A[0];
         }
         if (msl) F_mpn_negate(best_diff+1, best_diff+1, best_diff[0]);
         while ((!best_diff[best_diff[0]]) && (best_diff[0])) best_diff[0]--; // Normalise best_diff
         
         best1 = A_ind[s-3];
         best2 = A_ind[s-2];
         best3 = A_ind[s-1];
   
         continue;
      }

      if (target_A[0] >= current_A[0]) // Compute the difference with the target A
      {
         msl = mpn_sub(diff+1, target_A+1, target_A[0], current_A+1, current_A[0]);
         diff[0] = target_A[0];
      }
      else 
      {
         msl = mpn_sub(diff+1, current_A+1, current_A[0], target_A+1, target_A[0]);
         diff[0] = current_A[0];
      }
      if (msl) F_mpn_negate(diff+1, diff+1, diff[0]);
      while ((!diff[diff[0]]) && (diff[0])) diff[0]--; // Normalise diff

      if ((diff[0] < best_diff[0]) || ((diff[0] == best_diff[0]) && (mpn_cmp(diff+1, best_diff+1, diff[0]) < 0)))  // The new diff is better
      {
         F_mpn_copy(best_diff, diff, diff[0]+1);
         best1 = A_ind[s-3];
         best2 = A_ind[s-2];
         best3 = A_ind[s-1];         
      }
   }    

   A_ind[s-3] = best1; // Multiply A by the product of these 3 primes and store their indices
   A_ind[s-2] = best2;
   A_ind[s-1] = best3;   
   for (i = 0; i < 3; i++) 
   {
      msl = mpn_mul_1(A+1, A+1, A[0], factor_base[A_ind[s+i-3]].p);
      if (msl) 
      {
         A[A[0]+1] = msl;
         A[0]++;
      }
   }
              
#if POLY_A
   mpz_t A_disp, targ_A;
   mpz_init(A_disp);
   mpz_init(targ_A);
   fmpz_to_mpz(A_disp, A);
   fmpz_to_mpz(targ_A, target_A);
   gmp_printf("A = %Zd, target A = %Zd\n", A_disp, targ_A);
   mpz_clear(A_disp);
   mpz_clear(targ_A);
#endif    
 
   /*for (i = 0; i < s; i++)
   {
      p = factor_base[A_ind[i]].p;
      poly_inf->inv_p2[i] = z_precompute_inverse(p*p);
   } */

   fmpz_to_mpz(poly_inf->A_mpz, A);
   
   flint_stack_release(); // release current_A
   flint_stack_release(); // release diff
   flint_stack_release(); // release best_diff     
}
示例#8
0
文件: t-sqrt.c 项目: goens/flint2
int main(void)
{
    int i, result;
    flint_rand_t state;

    printf("sqrt... ");
    fflush(stdout);

    flint_randinit(state);

    /* PRIME p = 2 ***************************************************************/

    /* Check aliasing: a = sqrt(a) */
    for (i = 0; i < 10000; i++)
    {
        fmpz_t p;
        long N;
        padic_ctx_t ctx;

        int ans1, ans2;
        padic_t a, d;

        fmpz_init(p);
        fmpz_set_ui(p, 2);
        N = z_randint(state, 100);
        padic_ctx_init(ctx, p, N, PADIC_SERIES);

        padic_init(a, ctx);
        padic_init(d, ctx);

        padic_randtest(a, state, ctx);

        ans1 = padic_sqrt(d, a, ctx);
        ans2 = padic_sqrt(a, a, ctx);

        result = ((ans1 == ans2) && (!ans1 || padic_equal(a, d, ctx)));
        if (!result)
        {
            printf("FAIL (aliasing):\n\n");
            printf("p = "), fmpz_print(p), printf("\n");
            printf("a = "), _padic_print(a, ctx), printf("\n");
            printf("d = "), _padic_print(d, ctx), printf("\n");
            abort();
        }

        padic_clear(a, ctx);
        padic_clear(d, ctx);

        fmpz_clear(p);
        padic_ctx_clear(ctx);
    }

    /* Test random elements */
    for (i = 0; i < 10000; i++)
    {
        fmpz_t p;
        long N;
        padic_ctx_t ctx;

        int ans;
        padic_t a, b, d;

        fmpz_init(p);
        fmpz_set_ui(p, 2);
        N = z_randint(state, 100);
        padic_ctx_init(ctx, p, N, PADIC_SERIES);

        padic_init(a, ctx);
        padic_init(b, ctx);
        padic_init(d, ctx);

        padic_randtest(a, state, ctx);

        ans = padic_sqrt(b, a, ctx);

        padic_mul(d, b, b, ctx);

        if (ans && padic_val(a) < 0)
        {
            padic_ctx_t ctx2;
            padic_t a2, d2;

            padic_ctx_init(ctx2, p, N + padic_val(a), PADIC_SERIES);

            padic_init(a2, ctx2);
            padic_init(d2, ctx2);
            padic_set(a2, a, ctx2);
            padic_set(d2, d, ctx2);
            padic_reduce(a2, ctx2);
            padic_reduce(d2, ctx2);

            result = (padic_equal(a2, d2, ctx2));
            if (!result)
            {
                printf("FAIL (random elements):\n\n");
                printf("a = "), padic_print(a, ctx), printf("\n");
                printf("b = "), padic_print(b, ctx), printf("\n");
                printf("d = "), padic_print(d, ctx), printf("\n");
                printf("a2 = "), padic_print(a2, ctx2), printf("\n");
                printf("d2 = "), padic_print(d2, ctx2), printf("\n");
                printf("p = "), fmpz_print(p), printf("\n");
                printf("ans = %d\n", ans);
                abort();
            }

            padic_clear(a2, ctx2);
            padic_clear(d2, ctx2);
            padic_ctx_clear(ctx2);
        }
        else
        {
            result = (!ans || padic_equal(a, d, ctx));
            if (!result)
            {
                printf("FAIL (random elements):\n\n");
                printf("a = "), padic_print(a, ctx), printf("\n");
                printf("b = "), padic_print(b, ctx), printf("\n");
                printf("d = "), padic_print(d, ctx), printf("\n");
                printf("p = "), fmpz_print(p), printf("\n");
                printf("ans = %d\n", ans);
                abort();
            }
        }

        padic_clear(a, ctx);
        padic_clear(b, ctx);
        padic_clear(d, ctx);

        fmpz_clear(p);
        padic_ctx_clear(ctx);
    }

    /* Test random squares */
    for (i = 0; i < 10000; i++)
    {
        fmpz_t p;
        long N;
        padic_ctx_t ctx;

        int ans;
        padic_t a, b, c, d;

        fmpz_init(p);
        fmpz_set_ui(p, 2);
        N = z_randint(state, 100);
        padic_ctx_init(ctx, p, N, PADIC_SERIES);

        padic_init(a, ctx);
        padic_init(b, ctx);
        padic_init(c, ctx);
        padic_init(d, ctx);

        padic_randtest(b, state, ctx);
        padic_mul(a, b, b, ctx);

        ans = padic_sqrt(c, a, ctx);

        padic_mul(d, c, c, ctx);

        if (ans && padic_val(a) < 0)
        {
            padic_ctx_t ctx2;
            padic_t a2, d2;

            padic_ctx_init(ctx2, p, N + padic_val(a), PADIC_SERIES);

            padic_init(a2, ctx2);
            padic_init(d2, ctx2);
            padic_set(a2, a, ctx2);
            padic_set(d2, d, ctx2);
            padic_reduce(a2, ctx2);
            padic_reduce(d2, ctx2);

            result = (padic_equal(a2, d2, ctx2));
            if (!result)
            {
                printf("FAIL (random elements):\n\n");
                printf("a = "), padic_print(a, ctx), printf("\n");
                printf("b = "), padic_print(b, ctx), printf("\n");
                printf("c = "), padic_print(c, ctx), printf("\n");
                printf("d = "), padic_print(d, ctx), printf("\n");
                printf("a2 = "), padic_print(a2, ctx2), printf("\n");
                printf("d2 = "), padic_print(d2, ctx2), printf("\n");
                printf("p = "), fmpz_print(p), printf("\n");
                printf("ans = %d\n", ans);
                abort();
            }

            padic_clear(a2, ctx2);
            padic_clear(d2, ctx2);
            padic_ctx_clear(ctx2);
        }
        else
        {
            result = (ans && padic_equal(a, d, ctx));
            if (!result)
            {
                printf("FAIL (random squares):\n\n");
                printf("a = "), padic_print(a, ctx), printf("\n");
                printf("b = "), padic_print(b, ctx), printf("\n");
                printf("c = "), padic_print(c, ctx), printf("\n");
                printf("d = "), padic_print(d, ctx), printf("\n");
                printf("p = "), fmpz_print(p), printf("\n");
                printf("ans = %d\n", ans);
                abort();
            }
        }

        padic_clear(a, ctx);
        padic_clear(b, ctx);
        padic_clear(c, ctx);
        padic_clear(d, ctx);

        fmpz_clear(p);
        padic_ctx_clear(ctx);
    }

    /* PRIME p > 2 ***************************************************************/

    /* Check aliasing: a = sqrt(a) */
    for (i = 0; i < 10000; i++)
    {
        fmpz_t p;
        long N;
        padic_ctx_t ctx;

        int ans1, ans2;
        padic_t a, d;

        fmpz_init(p);
        fmpz_set_ui(p, n_randprime(state, 5, 1));
        N = z_randint(state, 100);
        padic_ctx_init(ctx, p, N, PADIC_SERIES);

        padic_init(a, ctx);
        padic_init(d, ctx);

        padic_randtest(a, state, ctx);

        ans1 = padic_sqrt(d, a, ctx);
        ans2 = padic_sqrt(a, a, ctx);

        result = ((ans1 == ans2) && (!ans1 || padic_equal(a, d, ctx)));
        if (!result)
        {
            printf("FAIL (aliasing):\n\n");
            printf("a = "), _padic_print(a, ctx), printf("\n");
            printf("d = "), _padic_print(d, ctx), printf("\n");
            abort();
        }

        padic_clear(a, ctx);
        padic_clear(d, ctx);

        fmpz_clear(p);
        padic_ctx_clear(ctx);
    }

    /* Test random elements */
    for (i = 0; i < 10000; i++)
    {
        fmpz_t p;
        long N;
        padic_ctx_t ctx;

        int ans;
        padic_t a, b, d;

        fmpz_init(p);
        fmpz_set_ui(p, n_randprime(state, 5, 1));
        N = z_randint(state, 100);
        padic_ctx_init(ctx, p, N, PADIC_SERIES);

        padic_init(a, ctx);
        padic_init(b, ctx);
        padic_init(d, ctx);

        padic_randtest(a, state, ctx);

        ans = padic_sqrt(b, a, ctx);

        padic_mul(d, b, b, ctx);

        if (ans && padic_val(a) < 0)
        {
            padic_ctx_t ctx2;
            padic_t a2, d2;

            padic_ctx_init(ctx2, p, N + padic_val(a), PADIC_SERIES);

            padic_init(a2, ctx2);
            padic_init(d2, ctx2);
            padic_set(a2, a, ctx2);
            padic_set(d2, d, ctx2);
            padic_reduce(a2, ctx2);
            padic_reduce(d2, ctx2);

            result = (padic_equal(a2, d2, ctx2));
            if (!result)
            {
                printf("FAIL (random elements):\n\n");
                printf("a = "), padic_print(a, ctx), printf("\n");
                printf("b = "), padic_print(b, ctx), printf("\n");
                printf("d = "), padic_print(d, ctx), printf("\n");
                printf("a2 = "), padic_print(a2, ctx2), printf("\n");
                printf("d2 = "), padic_print(d2, ctx2), printf("\n");
                printf("p = "), fmpz_print(p), printf("\n");
                printf("ans = %d\n", ans);
                abort();
            }

            padic_clear(a2, ctx2);
            padic_clear(d2, ctx2);
            padic_ctx_clear(ctx2);
        }
        else
        {
            result = (!ans || padic_equal(a, d, ctx));
            if (!result)
            {
                printf("FAIL (random elements):\n\n");
                printf("a = "), padic_print(a, ctx), printf("\n");
                printf("b = "), padic_print(b, ctx), printf("\n");
                printf("d = "), padic_print(d, ctx), printf("\n");
                printf("p = "), fmpz_print(p), printf("\n");
                printf("ans = %d\n", ans);
                abort();
            }
        }

        padic_clear(a, ctx);
        padic_clear(b, ctx);
        padic_clear(d, ctx);

        fmpz_clear(p);
        padic_ctx_clear(ctx);
    }

    /* Test random squares */
    for (i = 0; i < 10000; i++)
    {
        fmpz_t p;
        long N;
        padic_ctx_t ctx;

        int ans;
        padic_t a, b, c, d;

        fmpz_init(p);
        fmpz_set_ui(p, n_randprime(state, 5, 1));
        N = z_randint(state, 100);
        padic_ctx_init(ctx, p, N, PADIC_SERIES);

        padic_init(a, ctx);
        padic_init(b, ctx);
        padic_init(c, ctx);
        padic_init(d, ctx);

        padic_randtest(b, state, ctx);
        padic_mul(a, b, b, ctx);

        ans = padic_sqrt(c, a, ctx);

        padic_mul(d, c, c, ctx);

        if (ans && padic_val(a) < 0)
        {
            padic_ctx_t ctx2;
            padic_t a2, d2;

            padic_ctx_init(ctx2, p, N + padic_val(a), PADIC_SERIES);

            padic_init(a2, ctx2);
            padic_init(d2, ctx2);
            padic_set(a2, a, ctx2);
            padic_set(d2, d, ctx2);
            padic_reduce(a2, ctx2);
            padic_reduce(d2, ctx2);

            result = (padic_equal(a2, d2, ctx2));
            if (!result)
            {
                printf("FAIL (random elements):\n\n");
                printf("a = "), padic_print(a, ctx), printf("\n");
                printf("b = "), padic_print(b, ctx), printf("\n");
                printf("c = "), padic_print(c, ctx), printf("\n");
                printf("d = "), padic_print(d, ctx), printf("\n");
                printf("a2 = "), padic_print(a2, ctx2), printf("\n");
                printf("d2 = "), padic_print(d2, ctx2), printf("\n");
                printf("p = "), fmpz_print(p), printf("\n");
                printf("ans = %d\n", ans);
                abort();
            }

            padic_clear(a2, ctx2);
            padic_clear(d2, ctx2);
            padic_ctx_clear(ctx2);
        }
        else
        {
            result = (ans && padic_equal(a, d, ctx));
            if (!result)
            {
                printf("FAIL (random squares):\n\n");
                printf("a = "), padic_print(a, ctx), printf("\n");
                printf("b = "), padic_print(b, ctx), printf("\n");
                printf("c = "), padic_print(c, ctx), printf("\n");
                printf("d = "), padic_print(d, ctx), printf("\n");
                printf("p = "), fmpz_print(p), printf("\n");
                printf("ans = %d\n", ans);
                abort();
            }
        }

        padic_clear(a, ctx);
        padic_clear(b, ctx);
        padic_clear(c, ctx);
        padic_clear(d, ctx);

        fmpz_clear(p);
        padic_ctx_clear(ctx);
    }

    flint_randclear(state);
    _fmpz_cleanup();
    printf("PASS\n");
    return EXIT_SUCCESS;
}
示例#9
0
文件: t-mul.c 项目: clear731/lattice
int
main(void)
{
    int i, result;
    FLINT_TEST_INIT(state);

    flint_printf("mul... ");
    fflush(stdout);

    

    /* Check aliasing: a = a * b */
    for (i = 0; i < 2000; i++)
    {
        fmpz_t p;
        slong d, N;
        qadic_ctx_t ctx;

        qadic_t a, b, c;

        fmpz_init_set_ui(p, n_randprime(state, 2 + n_randint(state, 3), 1));
        d = n_randint(state, 10) + 1;
        N = z_randint(state, 50) + 1;
        qadic_ctx_init_conway(ctx, p, d, FLINT_MAX(0,N-10), FLINT_MAX(0,N+10), "a", PADIC_SERIES);

        qadic_init2(a, N);
        qadic_init2(b, N);
        qadic_init2(c, N);

        qadic_randtest(a, state, ctx);
        qadic_randtest(b, state, ctx);

        qadic_mul(c, a, b, ctx);
        qadic_mul(a, a, b, ctx);

        result = (qadic_equal(a, c));
        if (!result)
        {
            flint_printf("FAIL:\n\n");
            flint_printf("a = "), qadic_print_pretty(a, ctx), flint_printf("\n");
            flint_printf("b = "), qadic_print_pretty(b, ctx), flint_printf("\n");
            flint_printf("c = "), qadic_print_pretty(c, ctx), flint_printf("\n");
            abort();
        }

        qadic_clear(a);
        qadic_clear(b);
        qadic_clear(c);

        fmpz_clear(p);
        qadic_ctx_clear(ctx);
    }

    /* Check aliasing: b = a * b */
    for (i = 0; i < 2000; i++)
    {
        fmpz_t p;
        slong d, N;
        qadic_ctx_t ctx;

        qadic_t a, b, c;

        fmpz_init_set_ui(p, n_randprime(state, 2 + n_randint(state, 3), 1));
        d = n_randint(state, 10) + 1;
        N = z_randint(state, 50) + 1;
        qadic_ctx_init_conway(ctx, p, d, FLINT_MAX(0, N-10), FLINT_MAX(0, N+10), "a", PADIC_SERIES);

        qadic_init2(a, N);
        qadic_init2(b, N);
        qadic_init2(c, N);

        qadic_randtest(a, state, ctx);
        qadic_randtest(b, state, ctx);

        qadic_mul(c, a, b, ctx);
        qadic_mul(b, a, b, ctx);

        result = (qadic_equal(b, c));
        if (!result)
        {
            flint_printf("FAIL:\n\n");
            flint_printf("a = "), qadic_print_pretty(a, ctx), flint_printf("\n");
            flint_printf("b = "), qadic_print_pretty(b, ctx), flint_printf("\n");
            flint_printf("c = "), qadic_print_pretty(c, ctx), flint_printf("\n");
            abort();
        }

        qadic_clear(a);
        qadic_clear(b);
        qadic_clear(c);

        fmpz_clear(p);
        qadic_ctx_clear(ctx);
    }

    /* Check aliasing: a = a + a */
    for (i = 0; i < 2000; i++)
    {
        fmpz_t p;
        slong d, N;
        qadic_ctx_t ctx;

        qadic_t a, c;

        fmpz_init_set_ui(p, n_randprime(state, 2 + n_randint(state, 3), 1));
        d = n_randint(state, 10) + 1;
        N = z_randint(state, 50) + 1;
        qadic_ctx_init_conway(ctx, p, d, FLINT_MAX(0,N-10), FLINT_MAX(0,N+10), "a", PADIC_SERIES);

        qadic_init2(a, N);
        qadic_init2(c, N);

        qadic_randtest(a, state, ctx);

        qadic_add(c, a, a, ctx);
        qadic_add(a, a, a, ctx);

        result = (qadic_equal(a, c));
        if (!result)
        {
            flint_printf("FAIL:\n\n");
            flint_printf("a = "), qadic_print_pretty(a, ctx), flint_printf("\n");
            flint_printf("c = "), qadic_print_pretty(c, ctx), flint_printf("\n");
            abort();
        }

        qadic_clear(a);
        qadic_clear(c);

        fmpz_clear(p);
        qadic_ctx_clear(ctx);
    }

    /* Check that a * b == b * a */
    for (i = 0; i < 2000; i++)
    {
        fmpz_t p;
        slong d, N;
        qadic_ctx_t ctx;

        qadic_t a, b, c1, c2;

        fmpz_init_set_ui(p, n_randprime(state, 2 + n_randint(state, 3), 1));
        d = n_randint(state, 10) + 1;
        N = z_randint(state, 50) + 1;
        qadic_ctx_init_conway(ctx, p, d, FLINT_MAX(0,N-10), FLINT_MAX(0,N+10), "a", PADIC_SERIES);

        qadic_init2(a, N);
        qadic_init2(b, N);
        qadic_init2(c1, N);
        qadic_init2(c2, N);

        qadic_randtest(a, state, ctx);
        qadic_randtest(b, state, ctx);

        qadic_mul(c1, a, b, ctx);
        qadic_mul(c2, b, a, ctx);

        result = (qadic_equal(c1, c2));
        if (!result)
        {
            flint_printf("FAIL:\n\n");
            flint_printf("a  = "), qadic_print_pretty(a, ctx), flint_printf("\n");
            flint_printf("b  = "), qadic_print_pretty(b, ctx), flint_printf("\n");
            flint_printf("c1 = "), qadic_print_pretty(c1, ctx), flint_printf("\n");
            flint_printf("c2 = "), qadic_print_pretty(c2, ctx), flint_printf("\n");
            abort();
        }

        qadic_clear(a);
        qadic_clear(b);
        qadic_clear(c1);
        qadic_clear(c2);

        fmpz_clear(p);
        qadic_ctx_clear(ctx);
    }

    /* Check that (a * b) * c == a * (b * c) for integral values */
    for (i = 0; i < 2000; i++)
    {
        fmpz_t p;
        slong d, N;
        qadic_ctx_t ctx;

        qadic_t a, b, c, lhs, rhs;

        fmpz_init_set_ui(p, n_randprime(state, 2 + n_randint(state, 3), 1));
        d = n_randint(state, 10) + 1;
        N = n_randint(state, 50) + 1;
        qadic_ctx_init_conway(ctx, p, d, FLINT_MAX(0,N-10), FLINT_MAX(0,N+10), "a", PADIC_SERIES);

        qadic_init2(a, N);
        qadic_init2(b, N);
        qadic_init2(c, N);
        qadic_init2(lhs, N);
        qadic_init2(rhs, N);

        qadic_randtest_int(a, state, ctx);
        qadic_randtest_int(b, state, ctx);
        qadic_randtest_int(c, state, ctx);

        qadic_mul(lhs, a, b, ctx);
        qadic_mul(lhs, lhs, c, ctx);
        qadic_mul(rhs, b, c, ctx);
        qadic_mul(rhs, a, rhs, ctx);

        result = (qadic_equal(lhs, rhs));
        if (!result)
        {
            flint_printf("FAIL:\n\n");
            flint_printf("a   = "), qadic_print_pretty(a, ctx), flint_printf("\n");
            flint_printf("b   = "), qadic_print_pretty(b, ctx), flint_printf("\n");
            flint_printf("c   = "), qadic_print_pretty(c, ctx), flint_printf("\n");
            flint_printf("lhs = "), qadic_print_pretty(lhs, ctx), flint_printf("\n");
            flint_printf("rhs = "), qadic_print_pretty(rhs, ctx), flint_printf("\n");
            abort();
        }

        qadic_clear(a);
        qadic_clear(b);
        qadic_clear(c);
        qadic_clear(lhs);
        qadic_clear(rhs);

        fmpz_clear(p);
        qadic_ctx_clear(ctx);
    }

    FLINT_TEST_CLEANUP(state);
    
    flint_printf("PASS\n");
    return EXIT_SUCCESS;
}
示例#10
0
文件: t-mul.c 项目: goens/flint2
int
main(void)
{
    int i, result;
    flint_rand_t state;

    printf("mul... ");
    fflush(stdout);

    flint_randinit(state);

    /* Check aliasing: a = a * b (mod p^N) */
    for (i = 0; i < 10000; i++)
    {
        fmpz_t p;
        long N;
        padic_ctx_t ctx;

        padic_t a, b, d;

        fmpz_init(p);
        fmpz_set_ui(p, n_randprime(state, 5, 1));
        N = z_randint(state, 50);
        padic_ctx_init(ctx, p, N, PADIC_SERIES);

        padic_init(a, ctx);
        padic_init(b, ctx);
        padic_init(d, ctx);

        padic_randtest(a, state, ctx);
        padic_randtest(b, state, ctx);

        padic_mul(d, a, b, ctx);
        padic_mul(a, a, b, ctx);

        result = (padic_equal(a, d, ctx));
        if (!result)
        {
            printf("FAIL:\n\n");
            printf("a = "), _padic_print(a, ctx), printf("\n");
            printf("b = "), _padic_print(b, ctx), printf("\n");
            printf("d = "), _padic_print(d, ctx), printf("\n");
            abort();
        }

        padic_clear(a, ctx);
        padic_clear(b, ctx);
        padic_clear(d, ctx);

        fmpz_clear(p);
        padic_ctx_clear(ctx);
    }

    /* Check aliasing: b = a * b (mod p^N) */
    for (i = 0; i < 10000; i++)
    {
        fmpz_t p;
        long N;
        padic_ctx_t ctx;

        padic_t a, b, d;

        fmpz_init(p);
        fmpz_set_ui(p, n_randprime(state, 5, 1));
        N = z_randint(state, 50);
        padic_ctx_init(ctx, p, N, PADIC_SERIES);

        padic_init(a, ctx);
        padic_init(b, ctx);
        padic_init(d, ctx);

        padic_randtest(a, state, ctx);
        padic_randtest(b, state, ctx);

        padic_mul(d, a, b, ctx);
        padic_mul(b, a, b, ctx);

        result = (padic_equal(b, d, ctx));
        if (!result)
        {
            printf("FAIL:\n\n");
            printf("a = "), _padic_print(a, ctx), printf("\n");
            printf("b = "), _padic_print(b, ctx), printf("\n");
            printf("d = "), _padic_print(d, ctx), printf("\n");
            abort();
        }

        padic_clear(a, ctx);
        padic_clear(b, ctx);
        padic_clear(d, ctx);

        fmpz_clear(p);
        padic_ctx_clear(ctx);
    }

    /* Check aliasing: a = a * a (mod p^N) */
    for (i = 0; i < 10000; i++)
    {
        fmpz_t p;
        long N;
        padic_ctx_t ctx;

        padic_t a, d;

        fmpz_init(p);
        fmpz_set_ui(p, n_randprime(state, 5, 1));
        N = z_randint(state, 50);
        padic_ctx_init(ctx, p, N, PADIC_SERIES);

        padic_init(a, ctx);
        padic_init(d, ctx);

        padic_randtest(a, state, ctx);

        padic_mul(d, a, a, ctx);
        padic_mul(a, a, a, ctx);

        result = (padic_equal(a, d, ctx));
        if (!result)
        {
            printf("FAIL:\n\n");
            printf("a = "), _padic_print(a, ctx), printf("\n");
            printf("d = "), _padic_print(d, ctx), printf("\n");
            abort();
        }

        padic_clear(a, ctx);
        padic_clear(d, ctx);

        fmpz_clear(p);
        padic_ctx_clear(ctx);
    }

    /* Check that a * b == b * a (mod p^N) */
    for (i = 0; i < 10000; i++)
    {
        fmpz_t p;
        long N;
        padic_ctx_t ctx;

        padic_t a, b, c, d;

        fmpz_init(p);
        fmpz_set_ui(p, n_randprime(state, 5, 1));
        N = z_randint(state, 50);
        padic_ctx_init(ctx, p, N, PADIC_SERIES);

        padic_init(a, ctx);
        padic_init(b, ctx);
        padic_init(c, ctx);
        padic_init(d, ctx);

        padic_randtest(a, state, ctx);
        padic_randtest(b, state, ctx);

        padic_mul(c, a, b, ctx);
        padic_mul(d, b, a, ctx);

        result = (padic_equal(c, d, ctx));
        if (!result)
        {
            printf("FAIL:\n\n");
            printf("a = "), _padic_print(a, ctx), printf("\n");
            printf("b = "), _padic_print(b, ctx), printf("\n");
            printf("c = "), _padic_print(c, ctx), printf("\n");
            printf("d = "), _padic_print(d, ctx), printf("\n");
            abort();
        }

        padic_clear(a, ctx);
        padic_clear(b, ctx);
        padic_clear(c, ctx);
        padic_clear(d, ctx);

        fmpz_clear(p);
        padic_ctx_clear(ctx);
    }

    /* Check that (a * b) * c == a * (b * c), correct only mod p^{N-v} */
    for (i = 0; i < 10000; i++)
    {
        fmpz_t p;
        long N;
        padic_ctx_t ctx;

        padic_t a, b, c, d, e;
        long v;

        fmpz_init(p);
        fmpz_set_ui(p, n_randprime(state, 5, 1));
        N = z_randint(state, 50);
        padic_ctx_init(ctx, p, N, PADIC_SERIES);

        padic_init(a, ctx);
        padic_init(b, ctx);
        padic_init(c, ctx);
        padic_init(d, ctx);
        padic_init(e, ctx);

        padic_randtest(a, state, ctx);
        padic_randtest(b, state, ctx);
        padic_randtest(c, state, ctx);

        v = FLINT_MIN(padic_val(a), padic_val(b));
        v = FLINT_MIN(v, padic_val(c));
        v = FLINT_MIN(v, 0);

        if ((v >= 0) || (-v < N)) /* Otherwise, no precision left */
        {
            padic_ctx_t ctx2;

            padic_ctx_init(ctx2, p, (v >= 0) ? N : N + v, PADIC_SERIES);

            padic_mul(d, a, b, ctx);
            padic_mul(d, d, c, ctx);

            padic_mul(e, b, c, ctx);
            padic_mul(e, a, e, ctx);

            padic_reduce(d, ctx2);
            padic_reduce(e, ctx2);

            result = (padic_equal(d, e, ctx2));
            if (!result)
            {
                printf("FAIL:\n\n");
                printf("a = "), _padic_print(a, ctx), printf("\n");
                printf("b = "), _padic_print(b, ctx), printf("\n");
                printf("c = "), _padic_print(c, ctx), printf("\n");
                printf("d = "), _padic_print(d, ctx2), printf("\n");
                printf("e = "), _padic_print(e, ctx2), printf("\n");
                abort();
            }
            padic_ctx_clear(ctx2);
        }

        padic_clear(a, ctx);
        padic_clear(b, ctx);
        padic_clear(c, ctx);
        padic_clear(d, ctx);
        padic_clear(e, ctx);

        fmpz_clear(p);
        padic_ctx_clear(ctx);
    }

    /* Check that a * 1 == a */
    for (i = 0; i < 10000; i++)
    {
        fmpz_t p;
        long N;
        padic_ctx_t ctx;

        padic_t a, b;

        fmpz_init(p);
        fmpz_set_ui(p, n_randprime(state, 5, 1));
        N = z_randint(state, 50);
        padic_ctx_init(ctx, p, N, PADIC_SERIES);

        padic_init(a, ctx);
        padic_init(b, ctx);

        padic_randtest(a, state, ctx);
        _padic_one(b);

        padic_mul(b, a, b, ctx);

        result = (padic_equal(a, b, ctx));
        if (!result)
        {
            printf("FAIL:\n\n");
            printf("a = "), _padic_print(a, ctx), printf("\n");
            printf("b = "), _padic_print(b, ctx), printf("\n");
            abort();
        }

        padic_clear(a, ctx);
        padic_clear(b, ctx);

        fmpz_clear(p);
        padic_ctx_clear(ctx);
    }

    flint_randclear(state);
    _fmpz_cleanup();
    printf("PASS\n");
    return EXIT_SUCCESS;
}
示例#11
0
int main(void)
{
    int i;
    flint_rand_t state;
    
    printf("init_set_readonly....");
    fflush(stdout);
    
    flint_randinit(state);

    /* Create some small fmpz integers, clear the mpz_t */
    for (i = 0; i < 100000; i++)
    {
        fmpz_t f;
        mpz_t z;

        *f = z_randint(state, COEFF_MAX + 1);

        mpz_init(z);
        fmpz_get_mpz(z, f);

        {
            fmpz_t g;

            fmpz_init_set_readonly(g, z);
            fmpz_clear_readonly(g);
        }

        mpz_clear(z);
    }

    /* Create some small fmpz integers, do *not* clear the mpz_t */
    for (i = 0; i < 100000; i++)
    {
        fmpz_t f;
        mpz_t z;

        *f = z_randint(state, COEFF_MAX + 1);

        mpz_init(z);
        fmpz_get_mpz(z, f);

        {
            fmpz_t g;

            fmpz_init_set_readonly(g, z);
        }

        mpz_clear(z);
    }

    /* Create some more fmpz integers */
    for (i = 0; i < 100000; i++)
    {
        fmpz_t f;
        mpz_t z;

        fmpz_init(f);
        fmpz_randtest(f, state, 2 * FLINT_BITS);
        mpz_init(z);
        fmpz_get_mpz(z, f);

        {
            fmpz_t g, h;

            fmpz_init_set_readonly(g, z);
            fmpz_init(h);
            fmpz_set_mpz(h, z);

            if (!fmpz_equal(g, h))
            {
                printf("FAIL:\n\n");
                printf("g = "), fmpz_print(g), printf("\n");
                printf("h = "), fmpz_print(h), printf("\n");
                gmp_printf("z = %Zd\n", z);
            }

            fmpz_clear_readonly(g);
            fmpz_clear(h);
        }

        fmpz_clear(f);
        mpz_clear(z);
    }

    flint_randclear(state);
    _fmpz_cleanup();
    printf("PASS\n");
    return 0;
}
示例#12
0
int test_F_mpz_LLL_randsimdioph()
{
   mpz_mat_t m_mat;
   F_mpz_mat_t F_mat;
   int result = 1;
   ulong bits1, bits2;
   F_mpz_t fzero;
   F_mpz_init(fzero);
   
   ulong count1;
   for (count1 = 0; (count1 < 10*ITER) && (result == 1) ; count1++)
   {
#if TRACE
       printf("count1 == %ld\n", count1);
#endif
      ulong r = z_randint(200) + 1;
      ulong c = r;

      F_mpz_mat_init(F_mat, r, c);

      mpz_mat_init(m_mat, r, c);

      bits1 = z_randint(200) + 1;
      bits2 = z_randint(5) + 1;
      
      mpz_mat_randsimdioph(m_mat, r, c, bits1, bits2);
           
      mpz_mat_to_F_mpz_mat(F_mat, m_mat);
      
      F_mpz_set_d_2exp(fzero, 2.0, bits2);
// good stuff here

      U_LLL_with_removal(F_mat, 350, fzero);

      mp_prec_t prec;
      prec = 20;

      __mpfr_struct ** Q, ** R;

      Q = mpfr_mat_init2(r, c, prec);
      R = mpfr_mat_init2(r, r, prec);

      F_mpz_mat_RQ_factor(F_mat, R, Q, r, c, prec); 

// should be that RQ = FM_copy
/*      long j;
      if (count1 == 29){
         mpfr_printf("%.12Rf was R[i][i] for i = %ld\n", R[0] + 0, 0); 
         for (j = 1; j < r; j++)
         { 
            mpfr_printf("%.12Rf was R[i][i+1] for i = %ld\n", R[j] + j - 1, j); 
            mpfr_printf("%.12Rf was R[i+1][i+1] for i = %ld\n", R[j] + j, j); 
         }
      }
*/

      result = mpfr_mat_R_reduced(R, r, (double) DELTA, (double) ETA, prec);

      mpfr_mat_clear(Q, r, c);
      mpfr_mat_clear(R, r, r);
          
//result here       result = mpz_mat_equal(res1, res2); 
      if (!result) 
      {

         F_mpz_mat_print_pretty(F_mat);
         printf("Error: bits1 = %ld, count1 = %ld\n", bits1, count1);
      }
          
      F_mpz_mat_clear(F_mat);
      mpz_mat_clear(m_mat);
   }

   F_mpz_clear(fzero);
   return result;
}
示例#13
0
int test_F_mpz_LLL_randajtai()
{
   mpz_mat_t m_mat;
   F_mpz_mat_t F_mat;
   int result = 1;
   ulong bits;
   F_mpz_t fzero;
   F_mpz_init(fzero);
   
   ulong count1;
   for (count1 = 0; (count1 < 100*ITER) && (result == 1) ; count1++)
   {
#if TRACE
       printf("count1 == %ld\n", count1);
#endif
      ulong r = z_randint(10)+1;
      ulong c = r;

      F_mpz_mat_init(F_mat, r, c);

      mpz_mat_init(m_mat, r, c);

      bits = z_randint(200) + 1;
      
      mpz_mat_randajtai(m_mat, r, c, .5);
           
      mpz_mat_to_F_mpz_mat(F_mat, m_mat);
      
      F_mpz_set_d_2exp(fzero, (double) 2*r, 1);
// good stuff here
      //F_mpz_mat_print_pretty(F_mat);

      long newd = U_LLL_with_removal(F_mat, 350, fzero);

      mp_prec_t prec;
      prec = 50;

      __mpfr_struct ** Q, ** R;

      Q = mpfr_mat_init2(r, c, prec);
      R = mpfr_mat_init2(r, r, prec);

      F_mpz_mat_RQ_factor(F_mat, R, Q, r, c, prec); 

// should be that RQ = FM_copy
      long j;
#if TRACE
       if (count1 == 30){
         mpfr_printf("%.12Rf was R[i][i] for i = %ld\n", R[0] + 0, 0); 
         for (j = 1; j < r; j++)
         { 
            mpfr_printf("%.12Rf was R[i][i+1] for i = %ld\n", R[j] + j - 1, j); 
            mpfr_printf("%.12Rf was R[i+1][i+1] for i = %ld\n", R[j] + j, j); 
         }
      }
#endif

      result = mpfr_mat_R_reduced(R, r, (double) DELTA-.01, (double) ETA+.01, prec);

      mpfr_mat_clear(Q, r, c);
      mpfr_mat_clear(R, r, r);
          
//result here       result = mpz_mat_equal(res1, res2); 
      if (!result) 
      {
         printf("Error: bits = %ld, count1 = %ld, newd = %ld\n", bits, count1, newd);
      }
          
      F_mpz_mat_clear(F_mat);
      mpz_mat_clear(m_mat);
   }

   F_mpz_clear(fzero);
   return result;
}
示例#14
0
文件: t-norm.c 项目: clear731/lattice
int
main(void)
{
    int i, result;
    FLINT_TEST_INIT(state);

    flint_printf("norm... ");
    fflush(stdout);

    

    /* Compare with product of Galois conjugates */
    for (i = 0; i < 2000; i++)
    {
        fmpz_t p;
        slong d, N;
        qadic_ctx_t ctx;

        qadic_t a, b, c;
        padic_t x, y;
        slong j;
        int ans;

        fmpz_init_set_ui(p, n_randprime(state, 2 + n_randint(state, 3), 1));
        d = n_randint(state, 10) + 1;
        N = z_randint(state, 50) + 1;
        qadic_ctx_init_conway(ctx, p, d, FLINT_MAX(0,N-10), FLINT_MAX(0,N+10), "a", PADIC_SERIES);

        qadic_init2(a, N);
        qadic_init2(b, N);
        qadic_init2(c, N);
        padic_init2(x, N);
        padic_init2(y, N);

        qadic_randtest_val(a, state, 0, ctx);
        qadic_reduce(a, ctx);

        qadic_norm(x, a, ctx);

        qadic_one(b);
        for (j = 0; j < d; j++)
        {
            qadic_frobenius(c, a, j, ctx);
            qadic_mul(b, b, c, ctx);
        }
        ans = qadic_get_padic(y, b, ctx);

        result = (ans && padic_equal(x, y));
        if (!result)
        {
            flint_printf("FAIL:\n\n");
            flint_printf("a = "), qadic_print_pretty(a, ctx), flint_printf("\n");
            flint_printf("b = "), qadic_print_pretty(b, ctx), flint_printf("\n");
            flint_printf("x = "), padic_print(x, &ctx->pctx), flint_printf("\n");
            flint_printf("y = "), padic_print(y, &ctx->pctx), flint_printf("\n");
            for (j = 0; j < d; j++)
            {
                qadic_frobenius(c, a, j, ctx);
                flint_printf("sigma^%wd = ", j), qadic_print_pretty(c, ctx), flint_printf("\n");
            }
            flint_printf("ans = %d\n", ans);
            abort();
        }

        qadic_clear(a);
        qadic_clear(b);
        qadic_clear(c);
        padic_clear(x);
        padic_clear(y);

        fmpz_clear(p);
        qadic_ctx_clear(ctx);
    }

    FLINT_TEST_CLEANUP(state);
    
    flint_printf("PASS\n");
    return EXIT_SUCCESS;
}
示例#15
0
void tiny_compute_A(QS_t * qs_inf, poly_t * poly_inf)
{
   unsigned long min = poly_inf->min;
   unsigned long span = poly_inf->span;
   unsigned long s = poly_inf->s;
   unsigned long * A_ind = poly_inf->A_ind;
   prime_t * factor_base = qs_inf->factor_base;
   unsigned long factor, i, p;
   unsigned long diff, best_diff, best1, best2;
   
   unsigned long A;
   
   if (s <= 4) 
   {
       A_ind[0] = z_randint(span) + min;
       do
       {
          A_ind[1] = z_randint(span) + min;
       } while (A_ind[0] == A_ind[1]);
   }
   
   if (s == 2) A = factor_base[A_ind[0]].p * factor_base[A_ind[1]].p;
   
   if ((s == 3) || (s == 4))
   {
       do
       {
          A_ind[2] = z_randint(span) + min;
       } while ((A_ind[0] == A_ind[2]) || (A_ind[1] == A_ind[2]));
       A = factor_base[A_ind[0]].p * factor_base[A_ind[1]].p * factor_base[A_ind[2]].p;
   }  
   
   if (s == 4)
   {
      factor = (poly_inf->target_A - 1) / A + 1; 
      for (i = min; i < min+span; i++)
      {
         if ((factor_base[i].p > factor) && (i != A_ind[0]) && (i != A_ind[1]) && (i != A_ind[2])) break;
      } 
      if (i == min + span)
      {
         i--;
         while ((i == A_ind[0]) || (i == A_ind[1]) || (i == A_ind[2])) i--;
      }   
      A_ind[3] = i;
      A *= factor_base[A_ind[3]].p;
   }
   
   if (s == 5) 
   {
       A_ind[0] = ((z_randint(span) + min) | 1);
       if (A_ind[0] == min + span) A_ind[0] -= 2;
       
       do
       {
          A_ind[1] = ((z_randint(span) + min) | 1);
          if (A_ind[1] == min + span) A_ind[1] -= 2;
       } while (A_ind[0] == A_ind[1]);
       
       do
       {
          A_ind[2] = ((z_randint(span) + min) | 1);
          if (A_ind[2] == min + span) A_ind[2] -= 2;
       } while ((A_ind[0] == A_ind[2]) || (A_ind[1] == A_ind[2]));
       
       A = factor_base[A_ind[0]].p * factor_base[A_ind[1]].p * factor_base[A_ind[2]].p;
       factor = poly_inf->target_A / A;
       
       for (i = 0; i < 8; i++)
       {
          A_ind[3] = ((z_randint(span) + min) & -2L);
          if (A_ind[3] < min) A_ind[3]+=2;
          
          do
          {
             A_ind[4] = ((z_randint(span) + min) & -2L);
             if (A_ind[4] < min) A_ind[4]+=2;
          } while (A_ind[3] == A_ind[4]);
          
          if (i == 0)
          {
             best_diff = FLINT_ABS(factor_base[A_ind[3]].p * factor_base[A_ind[4]].p - factor);
             best1 = A_ind[3];
             best2 = A_ind[4];
             continue;
          }
          
          diff = FLINT_ABS(factor_base[A_ind[3]].p * factor_base[A_ind[4]].p - factor);
          
          if (diff < best_diff)
          {
             best_diff = diff;
             best1 = A_ind[3];
             best2 = A_ind[4];
          }
       }
       
       A_ind[3] = best1;
       A_ind[4] = best2;
       A = A * factor_base[A_ind[3]].p * factor_base[A_ind[4]].p;
   }  
   
   poly_inf->A = A;

#if POLY_A
   if ((s == 4) || (s == 5)) printf("A = %ld, target A = %ld\n", A, poly_inf->target_A);
#endif    
 
   for (i = 0; i < s; i++)
   {
      p = factor_base[A_ind[i]].p;
      poly_inf->inv_p2[i] = z_precompute_inverse(p*p);
   }      
}