void
print_all_user_fun(int member)
{
pari_sp av = avma;
long iL = 0, lL = 1024;
GEN L = cgetg(lL+1, t_VECSMALL);
entree *ep;
int i;
for (i = 0; i < functions_tblsz; i++)
for (ep = functions_hash[i]; ep; ep = ep->next)
{
const char *f;
int is_member;
if (EpVALENCE(ep) != EpVAR || typ((GEN)ep->value)!=t_CLOSURE) continue;
f = ep->name;
is_member = (f[0] == '_' && f[1] == '.');
if (member != is_member) continue;
if (iL >= lL)
{
GEN oL = L;
long j;
lL *= 2; L = cgetg(lL+1, t_VECSMALL);
for (j = 1; j <= iL; j++) gel(L,j) = gel(oL,j);
}
L[++iL] = (long)ep;
}
if (iL)
{
setlg(L, iL+1);
L = gen_sort(L, NULL, &cmp_epname);
for (i = 1; i <= iL; i++)
{
ep = (entree*)L[i];
pari_printf("%s =\n %Ps\n\n", ep->name, ep->value);
}
}
avma = av;
}
/* return the roots of pol in nf */
GEN
nfroots(GEN nf,GEN pol)
{
pari_sp av = avma;
GEN A,g, T;
long d;
if (!nf) return nfrootsQ(pol);
nf = checknf(nf); T = gel(nf,1);
if (typ(pol) != t_POL) pari_err(notpoler,"nfroots");
if (varncmp(varn(pol), varn(T)) >= 0)
pari_err(talker,"polynomial variable must have highest priority in nfroots");
d = degpol(pol);
if (d == 0) return cgetg(1,t_VEC);
if (d == 1)
{
A = gneg_i(gdiv(gel(pol,2),gel(pol,3)));
return gerepilecopy(av, mkvec( basistoalg(nf,A) ));
}
A = fix_relative_pol(nf,pol,0);
A = Q_primpart( lift_intern(A) );
if (DEBUGLEVEL>3) fprintferr("test if polynomial is square-free\n");
g = nfgcd(A, derivpol(A), T, gel(nf,4));
if (degpol(g))
{ /* not squarefree */
g = QXQX_normalize(g, T);
A = RgXQX_div(A,g,T);
}
A = QXQX_normalize(A, T);
A = Q_primpart(A);
A = nfsqff(nf,A,1);
A = RgXQV_to_mod(A, T);
return gerepileupto(av, gen_sort(A, 0, cmp_pol));
}
static void gen_rse( qli_nod* node, qli_req* request)
{
/**************************************
*
* g e n _ r s e
*
**************************************
*
* Functional description
* Generate a record selection expression.
*
**************************************/
qli_rlb* rlb = CHECK_RLB(request->req_blr);
if ((nod_t) (IPTR) node->nod_arg[e_rse_join_type] == nod_nothing)
STUFF(blr_rse);
else
STUFF(blr_rs_stream);
STUFF(node->nod_count);
// Check for aggregate case
qli_nod* list;
qli_ctx* context = (qli_ctx*) node->nod_arg[e_rse_count];
if (context->ctx_sub_rse)
{
STUFF(blr_aggregate);
STUFF(context->ctx_context);
gen_rse(context->ctx_sub_rse, request);
STUFF(blr_group_by);
if (list = node->nod_arg[e_rse_group_by])
{
request->req_flags |= REQ_group_by;
STUFF(list->nod_count);
qli_nod** ptr = list->nod_arg;
for (const qli_nod* const* const end = ptr + list->nod_count; ptr < end; ++ptr)
{
gen_expression(*ptr, request);
}
request->req_flags &= ~REQ_group_by;
}
else
STUFF(0);
gen_map(context->ctx_map, request);
if (list = node->nod_arg[e_rse_having])
{
STUFF(blr_boolean);
gen_expression(list, request);
}
if (list = node->nod_arg[e_rse_sort])
gen_sort(list, request, blr_sort);
STUFF(blr_end);
return;
}
// Make relation clauses for all relations
qli_nod** ptr = &node->nod_arg[e_rse_count];
for (const qli_nod* const* const end = ptr + node->nod_count; ptr < end; ++ptr)
{
context = (qli_ctx*) *ptr;
if (context->ctx_stream)
gen_rse(context->ctx_stream, request);
else
{
const qli_rel* relation = context->ctx_relation;
STUFF(blr_rid);
STUFF_WORD(relation->rel_id);
STUFF(context->ctx_context);
}
}
// Handle various clauses
if (list = node->nod_arg[e_rse_first])
{
STUFF(blr_first);
gen_expression(list, request);
}
if (list = node->nod_arg[e_rse_boolean])
{
STUFF(blr_boolean);
gen_expression(list, request);
}
if (list = node->nod_arg[e_rse_sort])
gen_sort(list, request, blr_sort);
if (list = node->nod_arg[e_rse_reduced])
gen_sort(list, request, blr_project);
const nod_t join_type = (nod_t) (IPTR) node->nod_arg[e_rse_join_type];
if (join_type != nod_nothing && join_type != nod_join_inner)
{
STUFF(blr_join_type);
switch (join_type)
{
case nod_join_left:
STUFF(blr_left);
break;
case nod_join_right:
STUFF(blr_right);
break;
default:
STUFF(blr_full);
}
}
STUFF(blr_end);
}
