void
alias0(const char *s, const char *old)
{
entree *ep, *e;
GEN x;
ep = fetch_entry(old);
e = fetch_entry(s);
if (EpVALENCE(e) != EpALIAS && EpVALENCE(e) != EpNEW)
pari_err(e_MISC,"can't replace an existing symbol by an alias");
freeep(e);
x = newblock(2); x[0] = evaltyp(t_STR)|_evallg(2); /* for getheap */
gel(x,1) = (GEN)ep;
e->value=x; e->valence=EpALIAS;
}
long
pari_var_create(entree *ep)
{
GEN p = (GEN)initial_value(ep);
long v;
if (*p) return varn(p);
if (nvar == max_avail) pari_err(e_MISC,"no more variables available");
v = nvar++;
/* set p = pol_x(v) */
p[0] = evaltyp(t_POL) | _evallg(4);
p[1] = evalsigne(1) | evalvarn(v);
gel(p,2) = gen_0;
gel(p,3) = gen_1;
varentries_set(v, ep);
varpriority[v]= min_priority--;
return v;
}
static GEN
nf_DDF_roots(GEN pol, GEN polred, GEN nfpol, GEN lt, GEN init_fa, long nbf,
long fl, nflift_t *L)
{
long Cltx_r[] = { evaltyp(t_POL)|_evallg(4), 0,0,0 };
long i, m;
GEN C2ltpol, C = L->topowden;
GEN Clt = mul_content(C, lt);
GEN C2lt = mul_content(C,Clt);
GEN z;
if (L->Tpk)
{
int cof = (degpol(pol) > nbf); /* non trivial cofactor ? */
z = FqX_split_roots(init_fa, L->Tp, L->p, cof? polred: NULL);
z = hensel_lift_fact(polred, z, L->Tpk, L->p, L->pk, L->k);
if (cof) setlg(z, lg(z)-1); /* remove cofactor */
z = roots_from_deg1(z);
}
else
z = rootpadicfast(polred, L->p, L->k);
Cltx_r[1] = evalsigne(1) | evalvarn(varn(pol));
gel(Cltx_r,3) = Clt? Clt: gen_1;
C2ltpol = C2lt? gmul(C2lt, pol): pol;
for (m=1,i=1; i<lg(z); i++)
{
GEN q, r = gel(z,i);
r = nf_bestlift_to_pol(lt? gmul(lt,r): r, NULL, L);
gel(Cltx_r,2) = gneg(r); /* check P(r) == 0 */
q = RgXQX_divrem(C2ltpol, Cltx_r, nfpol, ONLY_DIVIDES); /* integral */
if (q) {
C2ltpol = C2lt? gmul(Clt,q): q;
if (Clt) r = gdiv(r, Clt);
gel(z,m++) = r;
}
else if (fl == 2) return cgetg(1, t_VEC);
}
z[0] = evaltyp(t_VEC) | evallg(m);
return z;
}
GEN
addrr_sign(GEN x, long sx, GEN y, long sy)
{
long lx, ex = expo(x);
long ly, ey = expo(y), e = ey - ex;
long i, j, lz, ez, m;
int extend, f2;
GEN z;
LOCAL_OVERFLOW;
if (!sy)
{
if (!sx)
{
if (e > 0) ex = ey;
return real_0_bit(ex);
}
if (e >= 0) return real_0_bit(ey);
lz = nbits2prec(-e);
lx = lg(x); if (lz > lx) lz = lx;
z = cgetr(lz); while(--lz) z[lz] = x[lz];
setsigne(z,sx); return z;
}
if (!sx)
{
if (e <= 0) return real_0_bit(ex);
lz = nbits2prec(e);
ly = lg(y); if (lz > ly) lz = ly;
z = cgetr(lz); while (--lz) z[lz] = y[lz];
setsigne(z,sy); return z;
}
if (e < 0) { swap(x,y); lswap(sx,sy); ey=ex; e=-e; }
/* now ey >= ex */
lx = lg(x);
ly = lg(y);
/* If exponents differ, need to shift one argument, here x. If
* extend = 1: extension of x,z by m < BIL bits (round to 1 word) */
/* in this case, lz = lx + d + 1, otherwise lx + d */
extend = 0;
if (e)
{
long d = dvmdsBIL(e, &m), l = ly-d;
if (l <= 2) return rcopy_sign(y, sy);
if (l > lx) { lz = lx + d + 1; extend = 1; }
else { lz = ly; lx = l; }
if (m)
{ /* shift x right m bits */
const pari_sp av = avma;
const ulong sh = BITS_IN_LONG-m;
GEN p1 = x; x = new_chunk(lx + lz + 1);
shift_right(x,p1,2,lx, 0,m);
if (extend) uel(x,lx) = uel(p1,lx-1) << sh;
avma = av; /* HACK: cgetr(lz) will not overwrite x */
}
}
else
{ /* d = 0 */
m = 0;
if (lx > ly) lx = ly;
lz = lx;
}
if (sx == sy)
{ /* addition */
i = lz-1;
j = lx-1;
if (extend) {
ulong garde = addll(x[lx], y[i]);
if (m < 4) /* don't extend for few correct bits */
z = cgetr(--lz);
else
{
z = cgetr(lz);
z[i] = garde;
}
}
else
{
z = cgetr(lz);
z[i] = addll(x[j], y[i]); j--;
}
i--;
for (; j>=2; i--,j--) z[i] = addllx(x[j],y[i]);
if (overflow)
{
z[1] = 1; /* stops since z[1] != 0 */
for (;;) { z[i] = uel(y,i)+1; if (z[i--]) break; }
if (i <= 0)
{
shift_right(z,z, 2,lz, 1,1);
z[1] = evalsigne(sx) | evalexpo(ey+1); return z;
}
}
for (; i>=2; i--) z[i] = y[i];
z[1] = evalsigne(sx) | evalexpo(ey); return z;
}
/* subtraction */
if (e) f2 = 1;
else
{
i = 2; while (i < lx && x[i] == y[i]) i++;
if (i==lx) return real_0_bit(ey+1 - prec2nbits(lx));
f2 = (uel(y,i) > uel(x,i));
}
/* result is non-zero. f2 = (y > x) */
i = lz-1; z = cgetr(lz);
if (f2)
{
j = lx-1;
if (extend) z[i] = subll(y[i], x[lx]);
else z[i] = subll(y[i], x[j--]);
for (i--; j>=2; i--) z[i] = subllx(y[i], x[j--]);
if (overflow) /* stops since y[1] != 0 */
for (;;) { z[i] = uel(y,i)-1; if (y[i--]) break; }
for (; i>=2; i--) z[i] = y[i];
sx = sy;
}
else
{
if (extend) z[i] = subll(x[lx], y[i]);
else z[i] = subll(x[i], y[i]);
for (i--; i>=2; i--) z[i] = subllx(x[i], y[i]);
}
x = z+2; i = 0; while (!x[i]) i++;
lz -= i; z += i;
j = bfffo(z[2]); /* need to shift left by j bits to normalize mantissa */
ez = ey - (j | (i * BITS_IN_LONG));
if (extend)
{ /* z was extended by d+1 words [should be e bits = d words + m bits] */
/* not worth keeping extra word if less than 5 significant bits in there */
if (m - j < 5 && lz > 3)
{ /* shorten z */
ulong last = (ulong)z[--lz]; /* cancelled word */
/* if we need to shift anyway, shorten from left
* If not, shorten from right, neutralizing last word of z */
if (j == 0)
/* stackdummy((pari_sp)(z + lz+1), (pari_sp)(z + lz)); */
z[lz] = evaltyp(t_VECSMALL) | _evallg(1);
else
{
GEN t = z;
z++; shift_left(z,t,2,lz-1, last,j);
}
if ((last<<j) & HIGHBIT)
{ /* round up */
i = lz-1;
while (++((ulong*)z)[i] == 0 && i > 1) i--;
if (i == 1) { ez++; z[2] = (long)HIGHBIT; }
}
}
else if (j) shift_left(z,z,2,lz-1, 0,j);
}
else if (j) shift_left(z,z,2,lz-1, 0,j);
z[1] = evalsigne(sx) | evalexpo(ez);
z[0] = evaltyp(t_REAL) | evallg(lz);
avma = (pari_sp)z; return z;
}
