GEN
gcdii(GEN a, GEN b)
{
long v, w;
pari_sp av;
GEN t;
switch (absi_cmp(a,b))
{
case 0: return absi(a);
case -1: swap(a,b);
}
if (!signe(b)) return absi(a);
/* here |a|>|b|>0. Try single precision first */
if (lgefint(a)==3)
return igcduu((ulong)a[2], (ulong)b[2]);
if (lgefint(b)==3)
{
ulong u = resiu(a,(ulong)b[2]);
if (!u) return absi(b);
return igcduu((ulong)b[2], u);
}
/* larger than gcd: "avma=av" gerepile (erasing t) is valid */
av = avma; (void)new_chunk(lgefint(b)+1); /* HACK */
t = remii(a,b);
if (!signe(t)) { avma=av; return absi(b); }
a = b; b = t;
v = vali(a); a = shifti(a,-v); setabssign(a);
w = vali(b); b = shifti(b,-w); setabssign(b);
if (w < v) v = w;
switch(absi_cmp(a,b))
{
case 0: avma=av; a=shifti(a,v); return a;
case -1: swap(a,b);
}
if (is_pm1(b)) { avma=av; return int2n(v); }
{
/* general case */
/*This serve two purposes: 1) mpn_gcd destroy its input and need an extra
* limb 2) this allows us to use icopy instead of gerepile later. NOTE: we
* must put u before d else the final icopy could fail.
*/
GEN res= cgeti(lgefint(a)+1);
GEN ca = icopy_ef(a,lgefint(a)+1);
GEN cb = icopy_ef(b,lgefint(b)+1);
long l = mpn_gcd(LIMBS(res), LIMBS(ca), NLIMBS(ca), LIMBS(cb), NLIMBS(cb));
res[1] = evalsigne(1)|evallgefint(l+2);
avma=av;
return shifti(res,v);
}
}
static GEN
nf_chk_factors(nfcmbf_t *T, GEN P, GEN M_L, GEN famod, GEN pk)
{
GEN nf = T->nf, bound = T->bound;
GEN nfT = gel(nf,1);
long i, r;
GEN pol = P, list, piv, y;
GEN C2ltpol, C = T->L->topowden, Tpk = T->L->Tpk;
GEN lc = absi(leading_term(pol)), lt = is_pm1(lc)? NULL: lc;
GEN Clt = mul_content(C, lt);
GEN C2lt = mul_content(C,Clt);
piv = special_pivot(M_L);
if (!piv) return NULL;
if (DEBUGLEVEL>3) fprintferr("special_pivot output:\n%Z\n",piv);
r = lg(piv)-1;
list = cgetg(r+1, t_COL);
C2ltpol = C2lt? gmul(C2lt,pol): pol;
for (i = 1;;)
{
pari_sp av = avma;
if (DEBUGLEVEL)
fprintferr("nf_LLL_cmbf: checking factor %ld (avma - bot = %lu)\n",
i, avma - bot);
y = chk_factors_get(lt, famod, gel(piv,i), Tpk, pk);
if (DEBUGLEVEL>2) fprintferr("... mod p^k (avma - bot = %lu)\n", avma-bot);
if (! (y = nf_pol_lift(y, bound, T)) ) return NULL;
if (DEBUGLEVEL>2) fprintferr("... lifted (avma - bot = %lu)\n", avma-bot);
y = gerepilecopy(av, y);
/* y is the candidate factor */
pol = RgXQX_divrem(C2ltpol, y, nfT, ONLY_DIVIDES);
if (!pol) return NULL;
y = Q_primpart(y);
gel(list,i) = QXQX_normalize(y, nfT);
if (++i >= r) break;
if (C2lt) pol = Q_primpart(pol);
if (lt) lt = absi(leading_term(pol));
Clt = mul_content(C, lt);
C2lt = mul_content(C,Clt);
C2ltpol = C2lt? gmul(C2lt,pol): pol;
}
y = Q_primpart(pol);
gel(list,i) = QXQX_normalize(y, nfT); return list;
}
int effect(ImageData *img,ImageData *outimg,int som)
{
int x,y;
int i;
int val;
int xx,yy;
int rrx,ggx,bbx;
int rry,ggy,bby;
int rr,gg,bb;
Pixel col;
int sadr;
int x1,y1,x2,y2;
int area,sum;
x1=0;
y1=0;
x2=img->width-1;
y2=img->height-1;
area=som*2+1;
sum=0;
for(yy=0;yy<area;yy++) {
sadr=(yy+(5-som))*11+(5-som);
for(xx=0;xx<area;xx++) {
sum+=absi(fil_x[sadr]);
sadr++;
}
}
for(y=y1;y<=y2;y++) {
for(x=x1;x<=x2;x++) {
rrx=ggx=bbx=0;
rry=ggy=bby=0;
for(yy=0;yy<area;yy++) {
sadr=(yy+(5-som))*11+(5-som);
for(xx=0;xx<area;xx++) {
val = getPixel(img,x+xx-1,y+yy-1,&col); 得
rrx+= (int)col.r*fil_x[sadr];
ggx+= (int)col.g*fil_x[sadr];
bbx+= (int)col.b*fil_x[sadr];
rry+= (int)col.r*fil_y[sadr];
ggy+= (int)col.g*fil_y[sadr];
bby+= (int)col.b*fil_y[sadr];
sadr++;
}
}
rr=(int)(sqrt(rrx*rrx+rry*rry)/(double)sum);
gg=(int)(sqrt(ggx*ggx+ggy*ggy)/(double)sum);
bb=(int)(sqrt(bbx*bbx+bby*bby)/(double)sum);
col.r = rr;
col.g = gg;
col.b = bb;
setPixel(outimg,x,y,&col);
}
}
return TRUE;
}
static void
subfields_poldata(GEN T, poldata *PD)
{
GEN nf,L,dis;
T = shallowcopy(get_nfpol(T, &nf));
PD->pol = T; setvarn(T, 0);
if (nf)
{
PD->den = Q_denom(gel(nf,7));
PD->roo = gel(nf,6);
PD->dis = mulii(absi(gel(nf,3)), sqri(gel(nf,4)));
}
else
{
PD->den = initgaloisborne(T,NULL,ZX_get_prec(T), &L,NULL,&dis);
PD->roo = L;
PD->dis = absi(dis);
}
}
bool UCamRad::removeRadialErrorPixels(UPixel ps[],
UPixel pd[],
unsigned int height,
unsigned int width,
float pixSize)
{ //
int result = true;
UXYoffset oxy; // offset x and y
UXYoffset * oxyh; // line with ofset values
int decimalFactor = roundi(resultDecimalFactor * pixSize);
int w, h, i;
int rhx, rhy;
double dhx, dhy;
int ix, iy; // pixel offset in Intensity resolution
int r1, r2, c1, c2;
int i1, i2; // intensity (decimal part) from pix 1 and 2
UPixel * pss; // source pixel pointer intensity (Y)
UPixel * pdd; // destination pixel pointer Intensity
UPixel p1, p2, p3, p4, pt, pb, pr; // pixel values
UPixel gray(128,128,128);
bool outside, outsideByOne;
//
// head point in actual resolution
dhx = par.getHx();
dhy = par.getHy();
rhx = int(dhx);
rhy = int(dhx);
// correct all lines
for (h = 0; h < int(height); h++)
{ // get destination
pdd = &pd[h * width];
// get line in offset table
i = absi(int(pixSize * (double(h)- dhy)));
// get pointer to first line of offsets
oxyh = radialOffset[i];
for (w = 0; w < int(width); w++)
{ // get index to offset value on this line
i = absi(int(pixSize * (double(w) - dhx)));
// get offset for this pixel
oxy = oxyh[i];
// corrext for right quadrant - matrix is for lower-right
if (w < rhx)
oxy.dx = -oxy.dx;
if (h < rhy)
oxy.dy = -oxy.dy;
// if not exact right find 4 pixels to interpolate
if ((oxy.dx != 0) or (oxy.dy != 0))
{ // get top left pixel offset
ix = oxy.dx / decimalFactor;
if (oxy.dx < 0) ix--;
iy = oxy.dy / decimalFactor;
if (oxy.dy < 0) iy--;
// limit to edge of image (reuse border pixels)
r1 = h + iy;
r2 = r1 + 1;
c1 = w + ix;
c2 = c1 + 1;
outside = (r1 < 0) or (r2 >= int(height)) or
(c1 < 0) or (c2 >= int(width));
if (outside)
// may be outside by just one pixel
outsideByOne = (((r2 == 0) or (r2 == int(height))) and
(c2 > 0) and (c2 < int(width))) or
(((c2 == 0) or (c2 == int(width))) and
(r2 > 0) and (r2 < int(height)));
else
outsideByOne = false;
//
if (outside and not outsideByOne)
// both outside - use gray
*pdd = gray;
else
{ // not (completely) outside
// get pixels
i = r1 * width + c1;
pss = &ps[i];
p1 = pss[0];
p2 = pss[1];
p3 = pss[width];
p4 = pss[width + 1];
if (outsideByOne)
{ // just outside by one, so adjust index to inside
if (r2 == 0)
{ // top row missing
p1 = p3;
p2 = p4;
}
if (r2 == int(height))
{ // bottom row missing
p3 = p1;
p4 = p2;
}
if (c2 == 0)
{ // left column missing
p1 = p2;
p3 = p4;
}
if (c2 == int(width))
{ // right column missing
p2 = p1;
p4 = p3;
}
}
outside = false;
}
if (not outside)
{ // get index to top-left of pixels in question
// get 4 pixels in question
// get left and right share
i2 = oxy.dx - ix * decimalFactor; // part of pixel in position (ix, iy)
i1 = decimalFactor - i2; // part of (ix+1, iy+1)
// average for top set of pixels
pt.y = (unsigned char)((int(p1.y) * i1 + int(p2.y) * i2)/decimalFactor);
pt.u = (unsigned char)((int(p1.u) * i1 + int(p2.u) * i2)/decimalFactor);
pt.v = (unsigned char)((int(p1.v) * i1 + int(p2.v) * i2)/decimalFactor);
// average for bottom set of pixels
pb.y = (unsigned char)((int(p3.y) * i1 + int(p4.y) * i2)/decimalFactor);
pb.u = (unsigned char)((int(p3.u) * i1 + int(p4.u) * i2)/decimalFactor);
pb.v = (unsigned char)((int(p3.v) * i1 + int(p4.v) * i2)/decimalFactor);
// get shares of top and bottom
i2 = oxy.dy - iy * decimalFactor; // part of pixel in position (ix, iy)
i1 = decimalFactor - i2; // part of (ix, iy+1)
// find result pixel intensity
pr.y = (unsigned char)((int(pt.y) * i1 + int(pb.y) * i2)/decimalFactor);
pr.u = (unsigned char)((int(pt.u) * i1 + int(pb.u) * i2)/decimalFactor);
pr.v = (unsigned char)((int(pt.v) * i1 + int(pb.v) * i2)/decimalFactor);
// implement
*pdd = pr;
}
}
else
{ // no change, so set destination to source
pss = &ps[h * width];
*pdd = pss[w];
}
pdd++;
}
}
return result;
}
GEN
bezout(GEN a, GEN b, GEN *pu, GEN *pv)
{
GEN t,u,u1,v,v1,d,d1,q,r;
GEN *pt;
pari_sp av, av1;
long s, sa, sb;
ulong g;
ulong xu,xu1,xv,xv1; /* Lehmer stage recurrence matrix */
int lhmres; /* Lehmer stage return value */
s = abscmpii(a,b);
if (s < 0)
{
t=b; b=a; a=t;
pt=pu; pu=pv; pv=pt;
}
/* now |a| >= |b| */
sa = signe(a); sb = signe(b);
if (!sb)
{
if (pv) *pv = gen_0;
switch(sa)
{
case 0: if (pu) *pu = gen_0; return gen_0;
case 1: if (pu) *pu = gen_1; return icopy(a);
case -1: if (pu) *pu = gen_m1; return(negi(a));
}
}
if (s == 0) /* |a| == |b| != 0 */
{
if (pu) *pu = gen_0;
if (sb > 0)
{ if (pv) *pv = gen_1; return icopy(b); }
else
{ if (pv) *pv = gen_m1; return(negi(b)); }
}
/* now |a| > |b| > 0 */
if (lgefint(a) == 3) /* single-word affair */
{
g = xxgcduu(uel(a,2), uel(b,2), 0, &xu, &xu1, &xv, &xv1, &s);
sa = s > 0 ? sa : -sa;
sb = s > 0 ? -sb : sb;
if (pu)
{
if (xu == 0) *pu = gen_0; /* can happen when b divides a */
else if (xu == 1) *pu = sa < 0 ? gen_m1 : gen_1;
else if (xu == 2) *pu = sa < 0 ? gen_m2 : gen_2;
else
{
*pu = cgeti(3);
(*pu)[1] = evalsigne(sa)|evallgefint(3);
(*pu)[2] = xu;
}
}
if (pv)
{
if (xv == 1) *pv = sb < 0 ? gen_m1 : gen_1;
else if (xv == 2) *pv = sb < 0 ? gen_m2 : gen_2;
else
{
*pv = cgeti(3);
(*pv)[1] = evalsigne(sb)|evallgefint(3);
(*pv)[2] = xv;
}
}
if (g == 1) return gen_1;
else if (g == 2) return gen_2;
else return utoipos(g);
}
/* general case */
av = avma;
(void)new_chunk(lgefint(b) + (lgefint(a)<<1)); /* room for u,v,gcd */
/* if a is significantly larger than b, calling lgcdii() is not the best
* way to start -- reduce a mod b first
*/
if (lgefint(a) > lgefint(b))
{
d = absi(b), q = dvmdii(absi(a), d, &d1);
if (!signe(d1)) /* a == qb */
{
avma = av;
if (pu) *pu = gen_0;
if (pv) *pv = sb < 0 ? gen_m1 : gen_1;
return (icopy(d));
}
else
{
u = gen_0;
u1 = v = gen_1;
v1 = negi(q);
}
/* if this results in lgefint(d) == 3, will fall past main loop */
}
else
{
d = absi(a); d1 = absi(b);
u = v1 = gen_1; u1 = v = gen_0;
}
av1 = avma;
/* main loop is almost identical to that of invmod() */
while (lgefint(d) > 3 && signe(d1))
{
lhmres = lgcdii((ulong *)d, (ulong *)d1, &xu, &xu1, &xv, &xv1, ULONG_MAX);
if (lhmres != 0) /* check progress */
{ /* apply matrix */
if ((lhmres == 1) || (lhmres == -1))
{
if (xv1 == 1)
{
r = subii(d,d1); d=d1; d1=r;
a = subii(u,u1); u=u1; u1=a;
a = subii(v,v1); v=v1; v1=a;
}
else
{
r = subii(d, mului(xv1,d1)); d=d1; d1=r;
a = subii(u, mului(xv1,u1)); u=u1; u1=a;
a = subii(v, mului(xv1,v1)); v=v1; v1=a;
}
}
else
{
r = subii(muliu(d,xu), muliu(d1,xv));
d1 = subii(muliu(d,xu1), muliu(d1,xv1)); d = r;
a = subii(muliu(u,xu), muliu(u1,xv));
u1 = subii(muliu(u,xu1), muliu(u1,xv1)); u = a;
a = subii(muliu(v,xu), muliu(v1,xv));
v1 = subii(muliu(v,xu1), muliu(v1,xv1)); v = a;
if (lhmres&1) { togglesign(d); togglesign(u); togglesign(v); }
else { togglesign(d1); togglesign(u1); togglesign(v1); }
}
}
if (lhmres <= 0 && signe(d1))
{
q = dvmdii(d,d1,&r);
a = subii(u,mulii(q,u1));
u=u1; u1=a;
a = subii(v,mulii(q,v1));
v=v1; v1=a;
d=d1; d1=r;
}
if (gc_needed(av,1))
{
if(DEBUGMEM>1) pari_warn(warnmem,"bezout");
gerepileall(av1,6, &d,&d1,&u,&u1,&v,&v1);
}
} /* end while */
/* Postprocessing - final sprint */
if (signe(d1))
{
/* Assertions: lgefint(d)==lgefint(d1)==3, and
* gcd(d,d1) is nonzero and fits into one word
*/
g = xxgcduu(uel(d,2), uel(d1,2), 0, &xu, &xu1, &xv, &xv1, &s);
u = subii(muliu(u,xu), muliu(u1, xv));
v = subii(muliu(v,xu), muliu(v1, xv));
if (s < 0) { sa = -sa; sb = -sb; }
avma = av;
if (pu) *pu = sa < 0 ? negi(u) : icopy(u);
if (pv) *pv = sb < 0 ? negi(v) : icopy(v);
if (g == 1) return gen_1;
else if (g == 2) return gen_2;
else return utoipos(g);
}
/* get here when the final sprint was skipped (d1 was zero already).
* Now the matrix is final, and d contains the gcd.
*/
avma = av;
if (pu) *pu = sa < 0 ? negi(u) : icopy(u);
if (pv) *pv = sb < 0 ? negi(v) : icopy(v);
return icopy(d);
}
int effect(ImageData *img,ImageData *outimg,int th,int nn)
{
int val;
int x,y;
int xx,yy;
int hh;
int tot,count;
int dr,dg,db;
int endn;
int c1,c2;
int rr,gg,bb;
Pixel col,ncol;
Pixel ans;
int bufR[400],bufG[400],bufB[400];
int ovx;
int n2;
int adr;
int x1,y1,x2,y2;
x1=0;
y1=0;
x2=img->width-1;
y2=img->height-1;
n2=nn*2+1;
for(y=y1;y<=y2;y++) {
x=x1;
for(yy=(-nn);yy<=nn;yy++) {
adr=(yy+nn)*BUF_MX;
for(xx=(-nn);xx<nn;xx++) {
val = getPixel(img,x+xx,y+yy,&ncol);
bufR[adr]=ncol.r;
bufG[adr]=ncol.g;
bufB[adr]=ncol.b;
adr++;
}
}
ovx=n2-1;
for(x=x1;x<=x2;x++) {
xx=nn;
for(yy=(-nn);yy<=nn;yy++) {
adr=(yy+nn)*BUF_MX+ovx;
val = getPixel(img,x+xx,y+yy,&ncol);
bufR[adr]=ncol.r;
bufG[adr]=ncol.g;
bufB[adr]=ncol.b;
adr++;
}
ovx=(ovx+1)%n2;
rr=gg=bb=0;
count=0;
val = getPixel(img,x,y,&col);
for(yy=0;yy<n2;yy++) {
adr=yy*BUF_MX;
for(xx=0;xx<n2;xx++) {
dr=absi((int)(col.r) - bufR[adr]);
dg=absi((int)(col.g) - bufG[adr]);
db=absi((int)(col.b) - bufB[adr]);
if(dr<th && dg<th && db<th) {
rr+= bufR[adr];
gg+= bufG[adr];
bb+= bufB[adr];
count++;
}
adr++;
}
}
if(count) {
hh=rr/count;
ans.r = hh;
hh=gg/count;
ans.g = hh;
hh=bb/count;
ans.b = hh;
}
else {
ans=col;
}
setPixel(outimg,x,y,&ans);
}
}
return TRUE;
}
/* Naive recombination of modular factors: combine up to maxK modular
* factors, degree <= klim and divisible by hint
*
* target = polynomial we want to factor
* famod = array of modular factors. Product should be congruent to
* target/lc(target) modulo p^a
* For true factors: S1,S2 <= p^b, with b <= a and p^(b-a) < 2^31 */
static GEN
nfcmbf(nfcmbf_t *T, GEN p, long a, long maxK, long klim)
{
GEN pol = T->pol, nf = T->nf, famod = T->fact, dn = T->dn;
GEN bound = T->bound;
GEN nfpol = gel(nf,1);
long K = 1, cnt = 1, i,j,k, curdeg, lfamod = lg(famod)-1, dnf = degpol(nfpol);
GEN res = cgetg(3, t_VEC);
pari_sp av0 = avma;
GEN pk = gpowgs(p,a), pks2 = shifti(pk,-1);
GEN ind = cgetg(lfamod+1, t_VECSMALL);
GEN degpol = cgetg(lfamod+1, t_VECSMALL);
GEN degsofar = cgetg(lfamod+1, t_VECSMALL);
GEN listmod = cgetg(lfamod+1, t_COL);
GEN fa = cgetg(lfamod+1, t_COL);
GEN lc = absi(leading_term(pol)), lt = is_pm1(lc)? NULL: lc;
GEN C2ltpol, C = T->L->topowden, Tpk = T->L->Tpk;
GEN Clt = mul_content(C, lt);
GEN C2lt = mul_content(C,Clt);
const double Bhigh = get_Bhigh(lfamod, dnf);
trace_data _T1, _T2, *T1, *T2;
pari_timer ti;
TIMERstart(&ti);
if (maxK < 0) maxK = lfamod-1;
C2ltpol = C2lt? gmul(C2lt,pol): pol;
{
GEN q = ceil_safe(sqrtr(T->BS_2));
GEN t1,t2, ltdn, lt2dn;
GEN trace1 = cgetg(lfamod+1, t_MAT);
GEN trace2 = cgetg(lfamod+1, t_MAT);
ltdn = mul_content(lt, dn);
lt2dn= mul_content(ltdn, lt);
for (i=1; i <= lfamod; i++)
{
pari_sp av = avma;
GEN P = gel(famod,i);
long d = degpol(P);
degpol[i] = d; P += 2;
t1 = gel(P,d-1);/* = - S_1 */
t2 = gsqr(t1);
if (d > 1) t2 = gsub(t2, gmul2n(gel(P,d-2), 1));
/* t2 = S_2 Newton sum */
t2 = typ(t2)!=t_INT? FpX_rem(t2, Tpk, pk): modii(t2, pk);
if (lt)
{
if (typ(t2)!=t_INT) {
t1 = FpX_red(gmul(ltdn, t1), pk);
t2 = FpX_red(gmul(lt2dn,t2), pk);
} else {
t1 = remii(mulii(ltdn, t1), pk);
t2 = remii(mulii(lt2dn,t2), pk);
}
}
gel(trace1,i) = gclone( nf_bestlift(t1, NULL, T->L) );
gel(trace2,i) = gclone( nf_bestlift(t2, NULL, T->L) ); avma = av;
}
T1 = init_trace(&_T1, trace1, T->L, q);
T2 = init_trace(&_T2, trace2, T->L, q);
for (i=1; i <= lfamod; i++) {
gunclone(gel(trace1,i));
gunclone(gel(trace2,i));
}
}
degsofar[0] = 0; /* sentinel */
/* ind runs through strictly increasing sequences of length K,
* 1 <= ind[i] <= lfamod */
nextK:
if (K > maxK || 2*K > lfamod) goto END;
if (DEBUGLEVEL > 3)
fprintferr("\n### K = %d, %Z combinations\n", K,binomial(utoipos(lfamod), K));
setlg(ind, K+1); ind[1] = 1;
i = 1; curdeg = degpol[ind[1]];
for(;;)
{ /* try all combinations of K factors */
for (j = i; j < K; j++)
{
degsofar[j] = curdeg;
ind[j+1] = ind[j]+1; curdeg += degpol[ind[j+1]];
}
if (curdeg <= klim && curdeg % T->hint == 0) /* trial divide */
{
GEN t, y, q, list;
pari_sp av;
av = avma;
/* d - 1 test */
if (T1)
{
t = get_trace(ind, T1);
if (rtodbl(QuickNormL2(t,DEFAULTPREC)) > Bhigh)
{
if (DEBUGLEVEL>6) fprintferr(".");
avma = av; goto NEXT;
}
}
/* d - 2 test */
if (T2)
{
t = get_trace(ind, T2);
if (rtodbl(QuickNormL2(t,DEFAULTPREC)) > Bhigh)
{
if (DEBUGLEVEL>3) fprintferr("|");
avma = av; goto NEXT;
}
}
avma = av;
y = lt; /* full computation */
for (i=1; i<=K; i++)
{
GEN q = gel(famod, ind[i]);
if (y) q = gmul(y, q);
y = FqX_centermod(q, Tpk, pk, pks2);
}
y = nf_pol_lift(y, bound, T);
if (!y)
{
if (DEBUGLEVEL>3) fprintferr("@");
avma = av; goto NEXT;
}
/* try out the new combination: y is the candidate factor */
q = RgXQX_divrem(C2ltpol, y, nfpol, ONLY_DIVIDES);
if (!q)
{
if (DEBUGLEVEL>3) fprintferr("*");
avma = av; goto NEXT;
}
/* found a factor */
list = cgetg(K+1, t_VEC);
gel(listmod,cnt) = list;
for (i=1; i<=K; i++) list[i] = famod[ind[i]];
y = Q_primpart(y);
gel(fa,cnt++) = QXQX_normalize(y, nfpol);
/* fix up pol */
pol = q;
for (i=j=k=1; i <= lfamod; i++)
{ /* remove used factors */
if (j <= K && i == ind[j]) j++;
else
{
famod[k] = famod[i];
update_trace(T1, k, i);
update_trace(T2, k, i);
degpol[k] = degpol[i]; k++;
}
}
lfamod -= K;
if (lfamod < 2*K) goto END;
i = 1; curdeg = degpol[ind[1]];
if (C2lt) pol = Q_primpart(pol);
if (lt) lt = absi(leading_term(pol));
Clt = mul_content(C, lt);
C2lt = mul_content(C,Clt);
C2ltpol = C2lt? gmul(C2lt,pol): pol;
if (DEBUGLEVEL > 2)
{
fprintferr("\n"); msgTIMER(&ti, "to find factor %Z",y);
fprintferr("remaining modular factor(s): %ld\n", lfamod);
}
continue;
}
NEXT:
for (i = K+1;;)
{
if (--i == 0) { K++; goto nextK; }
if (++ind[i] <= lfamod - K + i)
{
curdeg = degsofar[i-1] + degpol[ind[i]];
if (curdeg <= klim) break;
}
}
}
END:
if (degpol(pol) > 0)
{ /* leftover factor */
if (signe(leading_term(pol)) < 0) pol = gneg_i(pol);
if (C2lt && lfamod < 2*K) pol = QXQX_normalize(Q_primpart(pol), nfpol);
setlg(famod, lfamod+1);
gel(listmod,cnt) = shallowcopy(famod);
gel(fa,cnt++) = pol;
}
if (DEBUGLEVEL>6) fprintferr("\n");
if (cnt == 2) {
avma = av0;
gel(res,1) = mkvec(T->pol);
gel(res,2) = mkvec(T->fact);
}
else
{
setlg(listmod, cnt); setlg(fa, cnt);
gel(res,1) = fa;
gel(res,2) = listmod;
res = gerepilecopy(av0, res);
}
return res;
}
static long
nf_pick_prime(long ct, GEN nf, GEN polbase, long fl,
GEN *lt, GEN *Fa, GEN *pr, GEN *Tp)
{
GEN nfpol = gel(nf,1), dk, bad;
long maxf, n = degpol(nfpol), dpol = degpol(polbase), nbf = 0;
byteptr pt = diffptr;
ulong pp = 0;
*lt = leading_term(polbase); /* t_INT */
if (gcmp1(*lt)) *lt = NULL;
dk = absi(gel(nf,3));
bad = mulii(dk,gel(nf,4)); if (*lt) bad = mulii(bad, *lt);
/* FIXME: slow factorization of large polynomials over large Fq */
maxf = 1;
if (ct > 1) {
if (dpol > 100) /* tough */
{
if (n >= 20) maxf = 4;
}
else
{
if (n >= 15) maxf = 4;
}
}
for (ct = 5;;)
{
GEN aT, apr, ap, modpr, red;
long anbf;
pari_timer ti_pr;
GEN list, r = NULL, fa = NULL;
pari_sp av2 = avma;
if (DEBUGLEVEL>3) TIMERstart(&ti_pr);
for (;;)
{
NEXT_PRIME_VIADIFF_CHECK(pp, pt);
if (! umodiu(bad,pp)) continue;
ap = utoipos(pp);
list = (GEN)FpX_factor(nfpol, ap)[1];
if (maxf == 1)
{ /* deg.1 factors are best */
r = gel(list,1);
if (degpol(r) == 1) break;
}
else
{ /* otherwise, pick factor of largish degree */
long i, dr;
for (i = lg(list)-1; i > 0; i--)
{
r = gel(list,i); dr = degpol(r);
if (dr <= maxf) break;
}
if (i > 0) break;
}
avma = av2;
}
apr = primedec_apply_kummer(nf,r,1,ap);
modpr = zk_to_ff_init(nf,&apr,&aT,&ap);
red = modprX(polbase, nf, modpr);
if (!aT)
{ /* degree 1 */
red = ZX_to_Flx(red, pp);
if (!Flx_is_squarefree(red, pp)) { avma = av2; continue; }
anbf = fl? Flx_nbroots(red, pp): Flx_nbfact(red, pp);
}
else
{
GEN q;
if (!FqX_is_squarefree(red,aT,ap)) { avma = av2; continue; }
q = gpowgs(ap, degpol(aT));
anbf = fl? FqX_split_deg1(&fa, red, q, aT, ap)
: FqX_split_by_degree(&fa, red, q, aT, ap);
}
if (fl == 2 && anbf < dpol) return anbf;
if (anbf <= 1)
{
if (!fl) return anbf; /* irreducible */
if (!anbf) return 0; /* no root */
}
if (!nbf || anbf < nbf
|| (anbf == nbf && cmpii(gel(apr,4), gel(*pr,4)) > 0))
{
nbf = anbf;
*pr = apr;
*Tp = aT;
*Fa = fa;
}
else avma = av2;
if (DEBUGLEVEL>3)
fprintferr("%3ld %s at prime\n %Z\nTime: %ld\n",
anbf, fl?"roots": "factors", apr, TIMER(&ti_pr));
if (--ct <= 0) return nbf;
}
}
static GEN
nf_LLL_cmbf(nfcmbf_t *T, GEN p, long k, long rec)
{
nflift_t *L = T->L;
GEN pk = L->pk, PRK = L->prk, PRKinv = L->iprk, GSmin = L->GSmin;
GEN Tpk = L->Tpk;
GEN famod = T->fact, nf = T->nf, ZC = T->ZC, Br = T->Br;
GEN Pbase = T->polbase, P = T->pol, dn = T->dn;
GEN nfT = gel(nf,1);
GEN Btra;
long dnf = degpol(nfT), dP = degpol(P);
double BitPerFactor = 0.5; /* nb bits / modular factor */
long i, C, tmax, n0;
GEN lP, Bnorm, Tra, T2, TT, CM_L, m, list, ZERO;
double Bhigh;
pari_sp av, av2, lim;
long ti_LLL = 0, ti_CF = 0;
pari_timer ti2, TI;
lP = absi(leading_term(P));
if (is_pm1(lP)) lP = NULL;
n0 = lg(famod) - 1;
/* Lattice: (S PRK), small vector (vS vP). To find k bound for the image,
* write S = S1 q + S0, P = P1 q + P0
* |S1 vS + P1 vP|^2 <= Bhigh for all (vS,vP) assoc. to true factors */
Btra = mulrr(ZC, mulsr(dP*dP, normlp(Br, 2, dnf)));
Bhigh = get_Bhigh(n0, dnf);
C = (long)ceil(sqrt(Bhigh/n0)) + 1; /* C^2 n0 ~ Bhigh */
Bnorm = dbltor( n0 * C * C + Bhigh );
ZERO = zeromat(n0, dnf);
av = avma; lim = stack_lim(av, 1);
TT = cgetg(n0+1, t_VEC);
Tra = cgetg(n0+1, t_MAT);
for (i=1; i<=n0; i++) TT[i] = 0;
CM_L = gscalsmat(C, n0);
/* tmax = current number of traces used (and computed so far) */
for(tmax = 0;; tmax++)
{
long a, b, bmin, bgood, delta, tnew = tmax + 1, r = lg(CM_L)-1;
GEN oldCM_L, M_L, q, S1, P1, VV;
int first = 1;
/* bound for f . S_k(genuine factor) = ZC * bound for T_2(S_tnew) */
Btra = mulrr(ZC, mulsr(dP*dP, normlp(Br, 2*tnew, dnf)));
bmin = logint(ceil_safe(sqrtr(Btra)), gen_2, NULL);
if (DEBUGLEVEL>2)
fprintferr("\nLLL_cmbf: %ld potential factors (tmax = %ld, bmin = %ld)\n",
r, tmax, bmin);
/* compute Newton sums (possibly relifting first) */
if (gcmp(GSmin, Btra) < 0)
{
nflift_t L1;
GEN polred;
bestlift_init(k<<1, nf, T->pr, Btra, &L1);
polred = ZqX_normalize(Pbase, lP, &L1);
k = L1.k;
pk = L1.pk;
PRK = L1.prk;
PRKinv = L1.iprk;
GSmin = L1.GSmin;
Tpk = L1.Tpk;
famod = hensel_lift_fact(polred, famod, Tpk, p, pk, k);
for (i=1; i<=n0; i++) TT[i] = 0;
}
for (i=1; i<=n0; i++)
{
GEN h, lPpow = lP? gpowgs(lP, tnew): NULL;
GEN z = polsym_gen(gel(famod,i), gel(TT,i), tnew, Tpk, pk);
gel(TT,i) = z;
h = gel(z,tnew+1);
/* make Newton sums integral */
lPpow = mul_content(lPpow, dn);
if (lPpow) h = FpX_red(gmul(h,lPpow), pk);
gel(Tra,i) = nf_bestlift(h, NULL, L); /* S_tnew(famod) */
}
/* compute truncation parameter */
if (DEBUGLEVEL>2) { TIMERstart(&ti2); TIMERstart(&TI); }
oldCM_L = CM_L;
av2 = avma;
b = delta = 0; /* -Wall */
AGAIN:
M_L = Q_div_to_int(CM_L, utoipos(C));
VV = get_V(Tra, M_L, PRK, PRKinv, pk, &a);
if (first)
{ /* initialize lattice, using few p-adic digits for traces */
bgood = (long)(a - max(32, BitPerFactor * r));
b = max(bmin, bgood);
delta = a - b;
}
else
{ /* add more p-adic digits and continue reduction */
if (a < b) b = a;
b = max(b-delta, bmin);
if (b - delta/2 < bmin) b = bmin; /* near there. Go all the way */
}
/* restart with truncated entries */
q = int2n(b);
P1 = gdivround(PRK, q);
S1 = gdivround(Tra, q);
T2 = gsub(gmul(S1, M_L), gmul(P1, VV));
m = vconcat( CM_L, T2 );
if (first)
{
first = 0;
m = shallowconcat( m, vconcat(ZERO, P1) );
/* [ C M_L 0 ]
* m = [ ] square matrix
* [ T2' PRK ] T2' = Tra * M_L truncated
*/
}
CM_L = LLL_check_progress(Bnorm, n0, m, b == bmin, /*dbg:*/ &ti_LLL);
if (DEBUGLEVEL>2)
fprintferr("LLL_cmbf: (a,b) =%4ld,%4ld; r =%3ld -->%3ld, time = %ld\n",
a,b, lg(m)-1, CM_L? lg(CM_L)-1: 1, TIMER(&TI));
if (!CM_L) { list = mkcol(QXQX_normalize(P,nfT)); break; }
if (b > bmin)
{
CM_L = gerepilecopy(av2, CM_L);
goto AGAIN;
}
if (DEBUGLEVEL>2) msgTIMER(&ti2, "for this trace");
i = lg(CM_L) - 1;
if (i == r && gequal(CM_L, oldCM_L))
{
CM_L = oldCM_L;
avma = av2; continue;
}
if (i <= r && i*rec < n0)
{
pari_timer ti;
if (DEBUGLEVEL>2) TIMERstart(&ti);
list = nf_chk_factors(T, P, Q_div_to_int(CM_L,utoipos(C)), famod, pk);
if (DEBUGLEVEL>2) ti_CF += TIMER(&ti);
if (list) break;
CM_L = gerepilecopy(av2, CM_L);
}
if (low_stack(lim, stack_lim(av,1)))
{
if(DEBUGMEM>1) pari_warn(warnmem,"nf_LLL_cmbf");
gerepileall(av, Tpk? 9: 8,
&CM_L,&TT,&Tra,&famod,&pk,&GSmin,&PRK,&PRKinv,&Tpk);
}
}
if (DEBUGLEVEL>2)
fprintferr("* Time LLL: %ld\n* Time Check Factor: %ld\n",ti_LLL,ti_CF);
return list;
}
int
invmod(GEN a, GEN b, GEN *res)
#endif
{
GEN v,v1,d,d1,q,r;
pari_sp av, av1, lim;
long s;
ulong g;
ulong xu,xu1,xv,xv1; /* Lehmer stage recurrence matrix */
int lhmres; /* Lehmer stage return value */
if (typ(a) != t_INT || typ(b) != t_INT) pari_err(arither1);
if (!signe(b)) { *res=absi(a); return 0; }
av = avma;
if (lgefint(b) == 3) /* single-word affair */
{
ulong d1 = umodiu(a, (ulong)(b[2]));
if (d1 == 0)
{
if (b[2] == 1L)
{ *res = gen_0; return 1; }
else
{ *res = absi(b); return 0; }
}
g = xgcduu((ulong)(b[2]), d1, 1, &xv, &xv1, &s);
#ifdef DEBUG_LEHMER
fprintferr(" <- %lu,%lu\n", (ulong)(b[2]), (ulong)(d1[2]));
fprintferr(" -> %lu,%ld,%lu; %lx\n", g,s,xv1,avma);
#endif
avma = av;
if (g != 1UL) { *res = utoipos(g); return 0; }
xv = xv1 % (ulong)(b[2]); if (s < 0) xv = ((ulong)(b[2])) - xv;
*res = utoipos(xv); return 1;
}
(void)new_chunk(lgefint(b));
d = absi(b); d1 = modii(a,d);
v=gen_0; v1=gen_1; /* general case */
#ifdef DEBUG_LEHMER
fprintferr("INVERT: -------------------------\n");
output(d1);
#endif
av1 = avma; lim = stack_lim(av,1);
while (lgefint(d) > 3 && signe(d1))
{
#ifdef DEBUG_LEHMER
fprintferr("Calling Lehmer:\n");
#endif
lhmres = lgcdii((ulong*)d, (ulong*)d1, &xu, &xu1, &xv, &xv1, MAXULONG);
if (lhmres != 0) /* check progress */
{ /* apply matrix */
#ifdef DEBUG_LEHMER
fprintferr("Lehmer returned %d [%lu,%lu;%lu,%lu].\n",
lhmres, xu, xu1, xv, xv1);
#endif
if ((lhmres == 1) || (lhmres == -1))
{
if (xv1 == 1)
{
r = subii(d,d1); d=d1; d1=r;
a = subii(v,v1); v=v1; v1=a;
}
else
{
r = subii(d, mului(xv1,d1)); d=d1; d1=r;
a = subii(v, mului(xv1,v1)); v=v1; v1=a;
}
}
else
{
r = subii(muliu(d,xu), muliu(d1,xv));
a = subii(muliu(v,xu), muliu(v1,xv));
d1 = subii(muliu(d,xu1), muliu(d1,xv1)); d = r;
v1 = subii(muliu(v,xu1), muliu(v1,xv1)); v = a;
if (lhmres&1)
{
setsigne(d,-signe(d));
setsigne(v,-signe(v));
}
else
{
if (signe(d1)) { setsigne(d1,-signe(d1)); }
setsigne(v1,-signe(v1));
}
}
}
#ifdef DEBUG_LEHMER
else
fprintferr("Lehmer returned 0.\n");
output(d); output(d1); output(v); output(v1);
sleep(1);
#endif
if (lhmres <= 0 && signe(d1))
{
q = dvmdii(d,d1,&r);
#ifdef DEBUG_LEHMER
fprintferr("Full division:\n");
printf(" q = "); output(q); sleep (1);
#endif
a = subii(v,mulii(q,v1));
v=v1; v1=a;
d=d1; d1=r;
}
if (low_stack(lim, stack_lim(av,1)))
{
GEN *gptr[4]; gptr[0]=&d; gptr[1]=&d1; gptr[2]=&v; gptr[3]=&v1;
if(DEBUGMEM>1) pari_warn(warnmem,"invmod");
gerepilemany(av1,gptr,4);
}
} /* end while */
/* Postprocessing - final sprint */
if (signe(d1))
{
/* Assertions: lgefint(d)==lgefint(d1)==3, and
* gcd(d,d1) is nonzero and fits into one word
*/
g = xxgcduu((ulong)d[2], (ulong)d1[2], 1, &xu, &xu1, &xv, &xv1, &s);
#ifdef DEBUG_LEHMER
output(d);output(d1);output(v);output(v1);
fprintferr(" <- %lu,%lu\n", (ulong)d[2], (ulong)d1[2]);
fprintferr(" -> %lu,%ld,%lu; %lx\n", g,s,xv1,avma);
#endif
if (g != 1UL) { avma = av; *res = utoipos(g); return 0; }
/* (From the xgcduu() blurb:)
* For finishing the multiword modinv, we now have to multiply the
* returned matrix (with properly adjusted signs) onto the values
* v' and v1' previously obtained from the multiword division steps.
* Actually, it is sufficient to take the scalar product of [v',v1']
* with [u1,-v1], and change the sign if s==1.
*/
v = subii(muliu(v,xu1),muliu(v1,xv1));
if (s > 0) setsigne(v,-signe(v));
avma = av; *res = modii(v,b);
#ifdef DEBUG_LEHMER
output(*res); fprintfderr("============================Done.\n");
sleep(1);
#endif
return 1;
}
/* get here when the final sprint was skipped (d1 was zero already) */
avma = av;
if (!equalii(d,gen_1)) { *res = icopy(d); return 0; }
*res = modii(v,b);
#ifdef DEBUG_LEHMER
output(*res); fprintferr("============================Done.\n");
sleep(1);
#endif
return 1;
}