void
_fmpz_poly_pseudo_divrem_cohen(fmpz * Q, fmpz * R, const fmpz * A,
long lenA, const fmpz * B, long lenB)
{
const fmpz * leadB = B + (lenB - 1);
long e, lenQ;
fmpz_t pow;
if (lenB == 1)
{
fmpz_init(pow);
fmpz_pow_ui(pow, leadB, lenA - 1);
_fmpz_vec_scalar_mul_fmpz(Q, A, lenA, pow);
_fmpz_vec_zero(R, lenA);
fmpz_clear(pow);
return;
}
lenQ = lenA - lenB + 1;
_fmpz_vec_zero(Q, lenQ);
if (R != A)
_fmpz_vec_set(R, A, lenA);
e = lenA - lenB;
/* Unroll the first run of the while loop */
{
fmpz_set(Q + (lenQ - 1), R + (lenA - 1));
_fmpz_vec_scalar_mul_fmpz(R, R, lenA - 1, leadB);
_fmpz_vec_scalar_submul_fmpz(R + (lenA - lenB), B, lenB - 1, R + (lenA - 1));
fmpz_zero(R + (lenA - 1));
for (lenA -= 2; (lenA >= 0) && (R[lenA] == 0L); lenA--) ;
lenA++;
}
while (lenA >= lenB)
{
_fmpz_vec_scalar_mul_fmpz(Q, Q, lenQ, leadB);
fmpz_add(Q + (lenA - lenB), Q + (lenA - lenB), R + (lenA - 1));
_fmpz_vec_scalar_mul_fmpz(R, R, lenA - 1, leadB);
_fmpz_vec_scalar_submul_fmpz(R + lenA - lenB, B, lenB - 1, R + (lenA - 1));
fmpz_zero(R + (lenA - 1));
for (lenA -= 2; (lenA >= 0) && (R[lenA] == 0L); lenA--) ;
lenA++;
e--;
}
fmpz_init(pow);
fmpz_pow_ui(pow, leadB, e);
_fmpz_vec_scalar_mul_fmpz(Q, Q, lenQ, pow);
_fmpz_vec_scalar_mul_fmpz(R, R, lenA, pow);
fmpz_clear(pow);
}
void _fmpz_mod_poly_div_basecase(fmpz *Q, fmpz *R,
const fmpz *A, long lenA, const fmpz *B, long lenB,
const fmpz_t invB, const fmpz_t p)
{
const long alloc = (R == NULL) ? lenA : 0;
long lenR = lenB - 1, iQ;
if (alloc)
R = _fmpz_vec_init(alloc);
if (R != A)
_fmpz_vec_set(R + lenR, A + lenR, lenA - lenR);
for (iQ = lenA - lenB; iQ >= 0; iQ--)
{
if (fmpz_is_zero(R + lenA - 1))
{
fmpz_zero(Q + iQ);
}
else
{
fmpz_mul(Q + iQ, R + lenA - 1, invB);
fmpz_mod(Q + iQ, Q + iQ, p);
_fmpz_vec_scalar_submul_fmpz(R + lenA - lenR - 1, B, lenR, Q + iQ);
_fmpz_vec_scalar_mod_fmpz(R + lenA - lenR - 1, R + lenA - lenR - 1, lenR, p);
}
if (lenR - 1 >= iQ)
{
B++;
lenR--;
}
lenA--;
}
if (alloc)
_fmpz_vec_clear(R, alloc);
}
void
_fmpz_poly_pseudo_divrem_basecase(fmpz * Q, fmpz * R, ulong * d,
const fmpz * A, long lenA, const fmpz * B,
long lenB)
{
const fmpz * leadB = B + (lenB - 1);
long iQ = lenA - lenB, iR = lenA - 1;
fmpz_t rem;
fmpz_init(rem);
*d = 0;
_fmpz_vec_zero(Q, lenA - lenB + 1);
if (R != A)
_fmpz_vec_set(R, A, lenA);
while (iR >= lenB - 1)
{
fmpz_fdiv_qr(Q + iQ, rem, R + iR, leadB);
if (!fmpz_is_zero(rem))
{
_fmpz_vec_scalar_mul_fmpz(Q, Q, lenA - lenB + 1, leadB);
fmpz_set(Q + iQ, R + iR);
_fmpz_vec_scalar_mul_fmpz(R, R, lenA, leadB);
(*d)++;
}
if (lenB > 1)
_fmpz_vec_scalar_submul_fmpz(R + (iR - lenB + 1), B, lenB - 1, Q + iQ);
fmpz_zero(R + iR);
iR--;
iQ--;
}
fmpz_clear(rem);
}
int
main(void)
{
int i, result;
flint_rand_t state;
printf("scalar_submul_fmpz....");
fflush(stdout);
flint_randinit(state);
/* Compare with fmpz_vec_scalar_submul_si */
for (i = 0; i < 10000; i++)
{
fmpz *a, *b, *c;
long len, n;
fmpz_t n1;
len = n_randint(state, 100);
n = (long) n_randbits(state, FLINT_BITS - 1);
if (n_randint(state, 2))
n = -n;
fmpz_init(n1);
fmpz_set_si(n1, n);
a = _fmpz_vec_init(len);
b = _fmpz_vec_init(len);
c = _fmpz_vec_init(len);
_fmpz_vec_randtest(a, state, len, 200);
_fmpz_vec_randtest(b, state, len, 200);
_fmpz_vec_set(c, b, len);
_fmpz_vec_scalar_submul_fmpz(b, a, len, n1);
_fmpz_vec_scalar_submul_si(c, a, len, n);
result = (_fmpz_vec_equal(c, b, len));
if (!result)
{
printf("FAIL:\n");
_fmpz_vec_print(c, len), printf("\n\n");
_fmpz_vec_print(b, len), printf("\n\n");
abort();
}
fmpz_clear(n1);
_fmpz_vec_clear(a, len);
_fmpz_vec_clear(b, len);
_fmpz_vec_clear(c, len);
}
/* Compute a different way */
for (i = 0; i < 10000; i++)
{
fmpz *a, *b, *c, *d;
long len = n_randint(state, 100);
fmpz_t n1;
fmpz_init(n1);
fmpz_randtest(n1, state, 200);
a = _fmpz_vec_init(len);
b = _fmpz_vec_init(len);
c = _fmpz_vec_init(len);
d = _fmpz_vec_init(len);
_fmpz_vec_randtest(a, state, len, 200);
_fmpz_vec_randtest(b, state, len, 200);
_fmpz_vec_set(c, b, len);
_fmpz_vec_scalar_submul_fmpz(b, a, len, n1);
_fmpz_vec_scalar_mul_fmpz(d, a, len, n1);
_fmpz_vec_sub(c, c, d, len);
result = (_fmpz_vec_equal(c, b, len));
if (!result)
{
printf("FAIL:\n");
_fmpz_vec_print(c, len), printf("\n\n");
_fmpz_vec_print(b, len), printf("\n\n");
abort();
}
fmpz_clear(n1);
_fmpz_vec_clear(a, len);
_fmpz_vec_clear(b, len);
_fmpz_vec_clear(c, len);
_fmpz_vec_clear(d, len);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
void _padic_poly_sub(fmpz *rop, slong *val, slong N,
const fmpz *op1, slong val1, slong len1, slong N1,
const fmpz *op2, slong val2, slong len2, slong N2,
const padic_ctx_t ctx)
{
const slong len = FLINT_MAX(len1, len2);
*val = FLINT_MIN(val1, val2);
if (val1 == val2)
{
_fmpz_poly_sub(rop, op1, len1, op2, len2);
_padic_poly_canonicalise(rop, val, len, ctx->p);
}
else
{
fmpz_t x;
fmpz_init(x);
if (val1 < val2) /* F := p^g (G - p^{h-g} H) */
{
fmpz_pow_ui(x, ctx->p, val2 - val1);
if (rop == op1)
{
_fmpz_vec_zero(rop + len1, len2 - len1);
_fmpz_vec_scalar_submul_fmpz(rop, op2, len2, x);
}
else
{
_fmpz_vec_scalar_mul_fmpz(rop, op2, len2, x);
_fmpz_vec_neg(rop, rop, len2);
_fmpz_poly_add(rop, op1, len1, rop, len2);
}
}
else /* F := p^h (p^(g-h) G - H) */
{
fmpz_pow_ui(x, ctx->p, val1 - val2);
if (rop == op2)
{
_fmpz_vec_neg(rop, op2, len2);
_fmpz_vec_zero(rop + len2, len1 - len2);
_fmpz_vec_scalar_addmul_fmpz(rop, op1, len1, x);
}
else
{
_fmpz_vec_scalar_mul_fmpz(rop, op1, len1, x);
_fmpz_poly_sub(rop, rop, len1, op2, len2);
}
}
fmpz_clear(x);
}
/* Reduce */
if (N - *val > 0)
{
fmpz_t pow;
int alloc;
alloc = _padic_ctx_pow_ui(pow, N - *val, ctx);
if (N >= N1 && N >= N2)
{
slong i;
for (i = 0; i < len; i++)
if (fmpz_sgn(rop + i) < 0)
fmpz_add(rop + i, rop + i, pow);
}
else
{
_fmpz_vec_scalar_mod_fmpz(rop, rop, len, pow);
}
if (alloc)
fmpz_clear(pow);
}
else
{
_fmpz_vec_zero(rop, len);
*val = 0;
}
}
