/***************************************************
* API to convert a Vector to its Maple equivalent *
***************************************************/
ALGEB lbConvertVector (MKernelVector kv, ALGEB *argv){
try {
const VectorKey *k = &MapleToVectorKey(kv, argv[1]);
SerialVector s;
SerializeVector(s, *k);
if (strcmp(s.type, "integer")==0){
size_t n = s.list.size();
RTableSettings setting;
M_INT bounds[2];bounds[0]=1;bounds[1]=n;
RTableGetDefaults(kv, &setting);
setting.num_dimensions=1;
setting.subtype=RTABLE_COLUMN;
setting.data_type=RTABLE_DAG;
ALGEB vector = RTableCreate(kv, &setting, NULL, bounds);
M_INT index[1];
RTableData tmp;
for (size_t i=1; i<n+1; ++i){
index[0]=i;
tmp.dag = LinBoxToGMPMaple(kv, s.list[i-1]);
RTableAssign(kv, vector, index, tmp);
}
return vector;
}
if (strcmp(s.type, "rational")==0){
size_t n = (s.list.size());
if (n & 0x1) MapleRaiseError(kv, "LinBox internal error (serializing vector problem)");
n = n>>1;
RTableSettings setting;
M_INT bounds[2];bounds[0]=1;bounds[1]=n;
RTableGetDefaults(kv, &setting);
setting.num_dimensions=1;
setting.subtype=RTABLE_COLUMN;
setting.data_type=RTABLE_DAG;
ALGEB vector = RTableCreate(kv, &setting, NULL, bounds);
ALGEB f = EvalMapleStatement(kv,"Fraction:");
M_INT index[1];
RTableData tmp;
for (size_t i=1; i<n+1; ++i){
index[0]=i;
tmp.dag = EvalMapleProc(kv, f, 2, LinBoxToGMPMaple(kv, s.list[(i<<1)-2]) , LinBoxToGMPMaple(kv, s.list[(i<<1)-1]));
RTableAssign(kv, vector, index, tmp);
}
return vector;
}
else
MapleRaiseError(kv, "LinBox internal error (serializing vector problem)");
}
int main( int argc, char *argv[] )
{
char err[2048]; /* command input and error string buffers */
MKernelVector kv; /* Maple kernel handle */
MCallBackVectorDesc cb = { textCallBack,
0, /* errorCallBack not used */
0, /* statusCallBack not used */
0, /* readLineCallBack not used */
0, /* redirectCallBack not used */
0, /* streamCallBack not used */
0, /* queryInterrupt not used */
0 /* callBackCallBack not used */
};
ALGEB r, l; /* Maple data-structures */
/* initialize Maple */
if( (kv=StartMaple(argc,argv,&cb,NULL,NULL,err)) == NULL ) {
printf("Fatal error, %s\n",err);
return( 1 );
}
/* example 1: find out where maple is installed */
r = MapleKernelOptions(kv,"mapledir",NULL);
if( IsMapleString(kv,r) )
printf("Maple directory = \"%s\"\n\n",MapleToString(kv,r));
/* example 2: compute an integral */
/* output goes through the textCallBack */
printf("Evaluate an integral: \n\t");
r = EvalMapleStatement(kv,"int(1/(x^4+1),x);");
/* example 3: assign x a value and reevaluate the integral */
MapleAssign(kv,
ToMapleName(kv,"x",TRUE),
ToMapleInteger(kv,0));
r = MapleEval(kv,r);
MapleALGEB_Printf(kv,"\nEvaluated at x=0, the integral is: %a\n",r);
/* example 4: create a list with 3 elements */
l = MapleListAlloc(kv,3);
MapleListAssign(kv,l,1,r);
MapleListAssign(kv,l,2,ToMapleBoolean(kv,1));
MapleListAssign(kv,l,3,ToMapleFloat(kv,3.14));
MapleALGEB_Printf(kv,"\nHere's the list: %a\n",l);
return( 0 );
}
int
poly_eq_holds (MKernelVector kv, mpz_t a, mpz_t n, mpz_t r)
{
char *a_str;
char *n_str;
char *r_str;
char *a_buf;
char *n_buf;
char *r_buf;
size_t a_size;
size_t n_size;
size_t r_size;
char maple_stmt[4092];
int maple_sez;
/* La..La..La..La.. */
a_size = mpz_sizeinbase (a, 10) + 2;
r_size = mpz_sizeinbase (r, 10) + 2;
n_size = mpz_sizeinbase (n, 10) + 2;
a_buf = (char *) malloc (a_size * sizeof (char));
r_buf = (char *) malloc (r_size * sizeof (char));
n_buf = (char *) malloc (n_size * sizeof (char));
a_str = mpz_get_str (a_buf, 10, a);
n_str = mpz_get_str (r_buf, 10, n);
r_str = mpz_get_str (n_buf, 10, r);
/* Build up MAPLE statement */
sprintf (maple_stmt,
"if(powmod(x+%s,%s,x^%s-1,x) mod %s = "
"powmod(x,%s,x^%s-1,x)+%s mod %s) then 1 "
"else 0 end if;",
a_str, n_str, r_str, n_str, n_str, r_str, a_str, n_str);
printf ("maple_stmt = %s\n", maple_stmt);
/* Feed the statement to MAPLE kernel */
EvalMapleStatement (kv, maple_stmt);
/* To avoid memory leakage */
free (a_buf);
free (r_buf);
free (n_buf);
if (atoi (MAPLE_rslt) == 1)
{
return TRUE;
}
else
{
return FALSE;
}
}
/***********************************************************
* API to convert a domain element to its Maple equivalent *
***********************************************************/
ALGEB lbConvertElement (MKernelVector kv, ALGEB *argv){
try {
const EltKey *k = &MapleToElementKey(kv, argv[1]);
SerialElement s;
SerializeElement(s, *k);
if (strcmp(s.type, "integer")==0)
return LinBoxToGMPMaple(kv, s.list.front());
else
if (strcmp(s.type,"rational")==0){
ALGEB n,d,f;
n = LinBoxToGMPMaple(kv, s.list.front());
d = LinBoxToGMPMaple(kv, s.list.back());
f = EvalMapleStatement(kv,"Fraction:");
return EvalMapleProc(kv, f, 2, n, d);
}
else
MapleRaiseError(kv, "LinBox internal error (serializing element problem)");
}
catch (lb_runtime_error &t)
{lbRaiseError(kv, t);}
return ToMapleNULL(kv);
}
