void
UnXMLEscape( std::string & orig )
{
gsub( orig, "&", "&" );
gsub( orig, "<", "<" );
gsub( orig, ">", ">" );
gsub( orig, "'", "'" );
gsub( orig, """ , "\"" );
}
void FileList::scan( const char *pattern )
{
DIR *dpt;
struct dirent *dent;
const char *base_path = folder.c_str();
std::string s_bp( folder.c_str() );
std::string s_pat( pattern );
s_pat += "$";
/*
* clear the file vector
*/
files.clear();
/*
* we'll need to match regular expressions against the file name
* to do that we need to turn the "." into "\\." sequences and similarly
* "*" into ".*"
*/
gsub( s_pat, ".", "\\." );
gsub( s_pat, "*", ".*" );
/*
* now make a regex
*/
regex_t r;
regcomp( &r, s_pat.c_str(), 0 );
/*
* open the directory. Print an error to the console if it fails
*/
if( ( dpt = opendir( base_path ) ) == NULL )
{
std::cerr __FILE__ << " (" << __LINE__ << "): " << "Error(" << errno << ") opening " << base_path << std::endl;
return;
}
/*
* loop through the files
*/
while( ( dent = readdir( dpt ) ) != NULL )
{
if( regexec( &r, dent->d_name, 0, 0, 0 ) != 0 )
{
continue;
}
files.push_back(
FileListEntry( s_bp, std::string( dent->d_name ) )
);
}
closedir( dpt );
}
void _GenSerializerProcess::process()
{
std::string cpp;
if(FILE *fin=fopen(m_path, "rb")) {
if(!fin) { return; }
fseek(fin, 0, SEEK_END);
cpp.resize((size_t)ftell(fin));
fseek(fin, 0, SEEK_SET);
fread(&cpp[0], 1, cpp.size(), fin);
fclose(fin);
}
cpp = gsub(cpp, std::regex("^[ \\t]*GenSerializerBegin\\((.+?)\\)[.\\r\\n]+?GenSerializerEnd\\(\\)"), [&](const std::cmatch &m)->std::string {
std::string class_name = m[1].str();
std::string code;
EachMembersByTypeName(class_name.c_str(), [&](const MemberInfo *mi, size_t num){
code = m_callback(class_name.c_str(), mi, num);
});
std::string rep;
rep += "GenSerializerBegin(";
rep += class_name;
rep += ")\r\n";
rep += code;
rep += "GenSerializerEnd()";
return rep;
});
if(FILE *fout=fopen(m_path, "wb")) {
fwrite(cpp.c_str(), cpp.size(), 1, fout);
fclose(fout);
}
}
void rowMulSub(uint8_t* a, uint8_t* b, uint8_t coeff, int size){
if(coeff != 0x00){
// a = a - b*c
int i;
for(i = 0; i < size ; i++){
a[i] = gsub(a[i], gmul(coeff, b[i]));
}
}
}
/* return the characteristic polynomial of alpha over nf, where alpha
is an element of the algebra nf[X]/(T) given as a polynomial in X */
GEN
rnfcharpoly(GEN nf, GEN T, GEN alpha, long v)
{
long vnf, vT, lT;
pari_sp av = avma;
GEN p1;
nf=checknf(nf); vnf = varn(nf[1]);
if (v<0) v = 0;
T = fix_relative_pol(nf,T,1);
if (typ(alpha) == t_POLMOD) alpha = lift_to_pol(alpha);
lT = lg(T);
if (typ(alpha) != t_POL || varn(alpha) == vnf)
return gerepileupto(av, gpowgs(gsub(pol_x[v], alpha), lT - 3));
vT = varn(T);
if (varn(alpha) != vT || varncmp(v, vnf)>=0)
pari_err(talker,"incorrect variables in rnfcharpoly");
if (lg(alpha) >= lT) alpha = RgX_rem(alpha, T);
if (lT <= 4)
return gerepileupto(av, gsub(pol_x[v], alpha));
p1 = caract2(T, unifpol(nf,alpha, t_POLMOD), v);
return gerepileupto(av, unifpol(nf, p1, t_POLMOD));
}
string mconvert(const string &s)
{
/* This function is designed to escape strings destined for
* use in SQL queries and the like. Specifically, the following
* is done to the string passed in:
* 1. "\" is replaced with "\\"
* 2. "'" is replaced with "\'"
* 3. """ (double quote) is replaced with "\""
* 4. 0x00 is replaced with "\"+0x00.
*/
string returnme = "";
if (s.length() > 0)
{
returnme = gsub(s,"\\","\\\\");
returnme = gsub(returnme,"'", "\\'");
returnme = gsub(returnme,"\"","\\\"");
// special handling is required to make strings including
// 0x00; this is the kludge I found to work at 2200 tonight.
string findme = " "; findme[0] = 0;
returnme = gsub(returnme,findme,"\\0");
};
return returnme;
};
/* return P(X + c) using destructive Horner, optimize for c = 1,-1 */
GEN
translate_pol(GEN P, GEN c)
{
pari_sp av = avma, lim;
GEN Q, *R;
long i, k, n;
if (!signe(P) || gcmp0(c)) return gcopy(P);
Q = shallowcopy(P);
R = (GEN*)(Q+2); n = degpol(P);
lim = stack_lim(av, 2);
if (gcmp1(c))
{
for (i=1; i<=n; i++)
{
for (k=n-i; k<n; k++) R[k] = gadd(R[k], R[k+1]);
if (low_stack(lim, stack_lim(av,2)))
{
if(DEBUGMEM>1) pari_warn(warnmem,"TR_POL(1), i = %ld/%ld", i,n);
Q = gerepilecopy(av, Q); R = (GEN*)Q+2;
}
}
}
else if (gcmp_1(c))
{
for (i=1; i<=n; i++)
{
for (k=n-i; k<n; k++) R[k] = gsub(R[k], R[k+1]);
if (low_stack(lim, stack_lim(av,2)))
{
if(DEBUGMEM>1) pari_warn(warnmem,"TR_POL(-1), i = %ld/%ld", i,n);
Q = gerepilecopy(av, Q); R = (GEN*)Q+2;
}
}
}
else
{
for (i=1; i<=n; i++)
{
for (k=n-i; k<n; k++) R[k] = gadd(R[k], gmul(c, R[k+1]));
if (low_stack(lim, stack_lim(av,2)))
{
if(DEBUGMEM>1) pari_warn(warnmem,"TR_POL, i = %ld/%ld", i,n);
Q = gerepilecopy(av, Q); R = (GEN*)Q+2;
}
}
}
return gerepilecopy(av, Q);
}
/* Let X = Tra * M_L, Y = bestlift(X) return V s.t Y = X - PRK V
* and set *eT2 = gexpo(Y) [cf nf_bestlift, but memory efficient] */
static GEN
get_V(GEN Tra, GEN M_L, GEN PRK, GEN PRKinv, GEN pk, long *eT2)
{
long i, e = 0, l = lg(M_L);
GEN V = cgetg(l, t_MAT);
*eT2 = 0;
for (i = 1; i < l; i++)
{ /* cf nf_bestlift(Tra * c) */
pari_sp av = avma, av2;
GEN v, T2 = gmul(Tra, gel(M_L,i));
v = gdivround(gmul(PRKinv, T2), pk); /* small */
av2 = avma;
T2 = gsub(T2, gmul(PRK, v));
e = gexpo(T2); if (e > *eT2) *eT2 = e;
avma = av2;
gel(V,i) = gerepileupto(av, v); /* small */
}
return V;
}
/* return a minimal lift of elt modulo id */
static GEN
nf_bestlift(GEN elt, GEN bound, nflift_t *L)
{
GEN u;
long i,l = lg(L->prk), t = typ(elt);
if (t != t_INT)
{
if (t == t_POL) elt = mulmat_pol(L->tozk, elt);
u = gmul(L->iprk,elt);
for (i=1; i<l; i++) gel(u,i) = diviiround(gel(u,i), L->den);
}
else
{
u = gmul(elt, gel(L->iprk,1));
for (i=1; i<l; i++) gel(u,i) = diviiround(gel(u,i), L->den);
elt = gscalcol(elt, l-1);
}
u = gsub(elt, gmul(L->prk, u));
if (bound && gcmp(QuickNormL2(u,DEFAULTPREC), bound) > 0) u = NULL;
return u;
}
/* 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 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;
}
static std::string& gsub(std::string& buf, const std::string& src, int dst)
{
char tmp[64];
snprintf(tmp, sizeof(tmp), "%d", dst);
return gsub(buf, src, tmp);
}
bool XzeroDaemon::setupConfig()
{
if (instant_.empty()) {
// this is no instant-mode, so setup via configuration file.
std::ifstream ifs(configfile_);
return setup(&ifs, configfile_, optimizationLevel_);
}
// --instant=docroot[,port[,bind]]
auto tokens = x0::Tokenizer<x0::BufferRef, x0::Buffer>::tokenize(instant_, ",");
documentRoot_ = tokens.size() > 0 ? tokens[0].str() : "";
int port = tokens.size() > 1 ? tokens[1].toInt() : 0;
std::string bind = tokens.size() > 2 ? tokens[2].str() : "";
if (documentRoot_.empty())
documentRoot_ = getcwd();
else {
char result[PATH_MAX];
if (!realpath(documentRoot_.c_str(), result)) {
log(x0::Severity::error, "Could not resolv document root: '%s'. %s", documentRoot_.c_str(), strerror(errno));
return false;
} else {
documentRoot_ = result;
}
}
if (!port)
port = 8080;
if (bind.empty())
bind = "::"; //"0.0.0.0"; //TODO: "0::0";
log(x0::Severity::debug, "docroot: %s", documentRoot_.c_str());
log(x0::Severity::debug, "listen: addr=%s, port=%d", bind.c_str(), port);
std::string source(
"import compress\n"
"import dirlisting\n"
"import cgi\n"
"\n"
"handler setup {\n"
" mimetypes '/etc/mime.types'\n"
" mimetypes.default 'application/octet-stream'\n"
" listen 'bind' => #{bind}, 'port' => #{port}\n"
"}\n"
"\n"
"handler main {\n"
" docroot '#{docroot}'\n"
" autoindex ['index.cgi', 'index.html']\n"
" cgi.exec if phys.path =$ '.cgi'\n"
" dirlisting\n"
" staticfile\n"
"}\n"
);
gsub(source, "#{docroot}", documentRoot_);
gsub(source, "#{bind}", bind); // FIXME <--- bind to 1 instead of "::" lol
gsub(source, "#{port}", port);
log(x0::Severity::debug2, "source: %s", source.c_str());
server_->tcpCork(true);
std::istringstream s(source);
return setup(&s, "instant-mode.conf", optimizationLevel_);
}
GEN gsube(GEN *x, GEN y)
{
*x=gsub(*x,y);
return *x;
}
void
pariplot(GEN a, GEN b, GEN code, GEN ysmlu,GEN ybigu, long prec)
{
const char BLANK = ' ', YY = '|', XX_UPPER = '\'', XX_LOWER = '.';
long jz, j, i, sig;
pari_sp av = avma;
int jnew, jpre = 0; /* for lint */
GEN x, dx;
double diff, dyj, ysml, ybig, y[ISCR+1];
screen scr;
char buf[80], z;
sig=gcmp(b,a); if (!sig) return;
if (sig<0) { x=a; a=b; b=x; }
x = gtofp(a, prec); push_lex(x, code);
dx = divru(gtofp(gsub(b,a),prec), ISCR-1);
for (j=1; j<=JSCR; j++) scr[1][j]=scr[ISCR][j]=YY;
for (i=2; i<ISCR; i++)
{
scr[i][1] = XX_LOWER;
scr[i][JSCR]= XX_UPPER;
for (j=2; j<JSCR; j++) scr[i][j] = BLANK;
}
ysml = ybig = 0.; /* -Wall */
for (i=1; i<=ISCR; i++)
{
pari_sp av2 = avma;
y[i] = gtodouble( READ_EXPR(code,x) );
avma = av2;
if (i == 1)
ysml = ybig = y[1];
else
{
if (y[i] < ysml) ysml = y[i];
if (y[i] > ybig) ybig = y[i];
}
x = addrr(x,dx);
}
avma = av;
if (ysmlu) ysml = gtodouble(ysmlu);
if (ybigu) ybig = gtodouble(ybigu);
diff = ybig - ysml;
if (!diff) { ybig += 1; diff= 1.; }
dyj = ((JSCR-1)*3+2) / diff;
/* work around bug in gcc-4.8 (32bit): plot(x=-5,5,sin(x)))) */
jz = 3 - (long)(ysml*dyj + 0.5); /* 3 - DTOL(ysml*dyj) */
z = PICTZERO(jz); jz /= 3;
for (i=1; i<=ISCR; i++)
{
if (0<=jz && jz<=JSCR) scr[i][jz]=z;
j = 3 + DTOL((y[i]-ysml)*dyj);
jnew = j/3;
if (i > 1) fill_gap(scr, i, jnew, jpre);
if (0<=jnew && jnew<=JSCR) scr[i][jnew] = PICT(j);
jpre = jnew;
}
pari_putc('\n');
pari_printf("%s ", dsprintf9(ybig, buf));
for (i=1; i<=ISCR; i++) pari_putc(scr[i][JSCR]);
pari_putc('\n');
for (j=(JSCR-1); j>=2; j--)
{
pari_puts(" ");
for (i=1; i<=ISCR; i++) pari_putc(scr[i][j]);
pari_putc('\n');
}
pari_printf("%s ", dsprintf9(ysml, buf));
for (i=1; i<=ISCR; i++) pari_putc(scr[i][1]);
pari_putc('\n');
{
char line[10 + 32 + 32 + ISCR - 9];
sprintf(line, "%10s%-9.7g%*.7g\n"," ",todbl(a),ISCR-9,todbl(b));
pari_printf(line);
}
pop_lex(1);
}
/* d = requested degree for subfield. Return DATA, valid for given pol, S and d
* If DATA != NULL, translate pol [ --> pol(X+1) ] and update DATA
* 1: polynomial pol
* 2: p^e (for Hensel lifts) such that p^e > max(M),
* 3: Hensel lift to precision p^e of DATA[4]
* 4: roots of pol in F_(p^S->lcm),
* 5: number of polynomial changes (translations)
* 6: Bezout coefficients associated to the S->ff[i]
* 7: Hadamard bound for coefficients of h(x) such that g o h = 0 mod pol.
* 8: bound M for polynomials defining subfields x PD->den
* 9: *[i] = interpolation polynomial for S->ff[i] [= 1 on the first root
S->firstroot[i], 0 on the others] */
static void
compute_data(blockdata *B)
{
GEN ffL, roo, pe, p1, p2, fk, fhk, MM, maxroot, pol;
primedata *S = B->S;
GEN p = S->p, T = S->T, ff = S->ff, DATA = B->DATA;
long i, j, l, e, N, lff = lg(ff);
if (DEBUGLEVEL>1) fprintferr("Entering compute_data()\n\n");
pol = B->PD->pol; N = degpol(pol);
roo = B->PD->roo;
if (DATA) /* update (translate) an existing DATA */
{
GEN Xm1 = gsub(pol_x[varn(pol)], gen_1);
GEN TR = addis(gel(DATA,5), 1);
GEN mTR = negi(TR), interp, bezoutC;
gel(DATA,5) = TR;
pol = translate_pol(gel(DATA,1), gen_m1);
l = lg(roo); p1 = cgetg(l, t_VEC);
for (i=1; i<l; i++) gel(p1,i) = gadd(TR, gel(roo,i));
roo = p1;
fk = gel(DATA,4); l = lg(fk);
for (i=1; i<l; i++) gel(fk,i) = gsub(Xm1, gel(fk,i));
bezoutC = gel(DATA,6); l = lg(bezoutC);
interp = gel(DATA,9);
for (i=1; i<l; i++)
{
if (degpol(interp[i]) > 0) /* do not turn pol_1[0] into gen_1 */
{
p1 = translate_pol(gel(interp,i), gen_m1);
gel(interp,i) = FpXX_red(p1, p);
}
if (degpol(bezoutC[i]) > 0)
{
p1 = translate_pol(gel(bezoutC,i), gen_m1);
gel(bezoutC,i) = FpXX_red(p1, p);
}
}
ff = cgetg(lff, t_VEC); /* copy, don't overwrite! */
for (i=1; i<lff; i++)
gel(ff,i) = FpX_red(translate_pol((GEN)S->ff[i], mTR), p);
}
else
{
DATA = cgetg(10,t_VEC);
fk = S->fk;
gel(DATA,5) = gen_0;
gel(DATA,6) = shallowcopy(S->bezoutC);
gel(DATA,9) = shallowcopy(S->interp);
}
gel(DATA,1) = pol;
MM = gmul2n(bound_for_coeff(B->d, roo, &maxroot), 1);
gel(DATA,8) = MM;
e = logint(shifti(vecmax(MM),20), p, &pe); /* overlift 2^20 [for d-1 test] */
gel(DATA,2) = pe;
gel(DATA,4) = roots_from_deg1(fk);
/* compute fhk = hensel_lift_fact(pol,fk,T,p,pe,e) in 2 steps
* 1) lift in Zp to precision p^e */
ffL = hensel_lift_fact(pol, ff, NULL, p, pe, e);
fhk = NULL;
for (l=i=1; i<lff; i++)
{ /* 2) lift factorization of ff[i] in Qp[X] / T */
GEN F, L = gel(ffL,i);
long di = degpol(L);
F = cgetg(di+1, t_VEC);
for (j=1; j<=di; j++) F[j] = fk[l++];
L = hensel_lift_fact(L, F, T, p, pe, e);
fhk = fhk? shallowconcat(fhk, L): L;
}
gel(DATA,3) = roots_from_deg1(fhk);
p1 = mulsr(N, gsqrt(gpowgs(utoipos(N-1),N-1),DEFAULTPREC));
p2 = gpowgs(maxroot, B->size + N*(N-1)/2);
p1 = gdiv(gmul(p1,p2), gsqrt(B->PD->dis,DEFAULTPREC));
gel(DATA,7) = mulii(shifti(ceil_safe(p1), 1), B->PD->den);
if (DEBUGLEVEL>1) {
fprintferr("f = %Z\n",DATA[1]);
fprintferr("p = %Z, lift to p^%ld\n", p, e);
fprintferr("2 * Hadamard bound * ind = %Z\n",DATA[7]);
fprintferr("2 * M = %Z\n",DATA[8]);
}
if (B->DATA) {
DATA = gclone(DATA);
if (isclone(B->DATA)) gunclone(B->DATA);
}
B->DATA = DATA;
}
TEST_F(RoStrTest, gsub1) {
gsub(rstr(""), "\\u0000", "");
}
unsigned int conf_reader::read(const std::string & _filename, bool _clear)
{
if (_filename != "") { filename = _filename; };
if (filename != "")
{
try
{
ifstream cfile(filename.c_str());
if (!cfile) throw base_exception();
if (_clear) values.clear();
// read the file line by line, ignoring comments.
char inbuff[16*1024];
while (cfile)
{
cfile.getline(inbuff, 16*1024);
string in = inbuff;
// truncate at the start of a comment.
unsigned long int where = in.find("#");
while (where != string::npos)
{
if (in[where-1] == '\\')
{
// comment char was escaped.. ignore.
where = in.find("#",where+1);
}
else
{
// truncate the string at this point.
in.erase(where);
where = string::npos;
};
};
// see if we can parse what's left.
in = trim(in);
unsigned long int split_point = in.find_first_of("\t ");
if (split_point != string::npos)
{
// okay.. get the fields.
pair arg;
arg.first = gsub(trim(in.substr(0,split_point)),"\\#","#");
arg.second = gsub(trim(in.substr(split_point)),"\\#","#");
// is this an include directive?
if (arg.first == "*INCLUDE")
{
read(arg.second,false);
}
else if (arg.first != "")
{
values.insert(arg);
};
};
};
}
catch (...)
{
cerr << "\nProblems reading configuration file \""
<< filename << "\";\n\tdata may be incomplete." << endl;
}
};
return values.size();
};
