static int p_itrie_get_data(void) {
YAP_Term list;
YAP_Term item;
YAP_Functor f;
YAP_Int pos, neg, time;
/* check arg */
if (!YAP_IsIntTerm(arg_ref))
return FALSE;
/* get data */
itrie_get_data((TrData) YAP_IntOfTerm(arg_ref), &pos, &neg, &time);
list = YAP_MkAtomTerm(YAP_LookupAtom("[]"));
f = YAP_MkFunctor(YAP_LookupAtom("timestamp"), 1);
item = YAP_MkIntTerm(time);
item = YAP_MkApplTerm(f, 1, &item);
list = YAP_MkPairTerm(item, list);
f = YAP_MkFunctor(YAP_LookupAtom("neg"), 1);
item = YAP_MkIntTerm(neg);
item = YAP_MkApplTerm(f, 1, &item);
list = YAP_MkPairTerm(item, list);
f = YAP_MkFunctor(YAP_LookupAtom("pos"), 1);
item = YAP_MkIntTerm(pos);
item = YAP_MkApplTerm(f, 1, &item);
list = YAP_MkPairTerm(item, list);
return YAP_Unify(arg_data, list);
}
/** md5( +Text, -Key, -Remaining keyq
* encode text using OpenSSL
*
* arg Text is a List of ASCII codes
* arg2 and 3: difference list with the character codes for the
* digest.
*
* @return whether ARG1's md5 unifies with the difference liat.
*/
static YAP_Bool md5(void) {
unsigned char buf[64];
md5_state_t pms;
const char *s;
size_t len = -1;
if (!(s = YAP_StringToBuffer(YAP_ARG1, NULL, len)) || s[0] == 0)
return false;
md5_init(&pms);
md5_append(&pms, (const unsigned char *)s, strlen(s));
md5_finish(&pms, buf);
// free((void *)s);
YAP_Term t = YAP_ARG3;
int i = 16;
while (i > 0) {
int top, bop;
i--;
top = buf[i] >> 4;
if (top > 9)
top = (top - 10) + 'a';
else
top = top + '0';
bop = buf[i] & 15;
if (bop > 9)
bop = (bop - 10) + 'a';
else
bop = bop + '0';
t = YAP_MkPairTerm(YAP_MkIntTerm(top),
YAP_MkPairTerm(YAP_MkIntTerm(bop), t));
}
return YAP_Unify(YAP_ARG2, t);
}
static YAP_Bool make_multi_to_term (geometry_t geometry,
procedure_to_term_t procedure,
const char * functor_name,
YAP_Term *term)
{
int n;
geometry_t geometry_n;
YAP_Functor functor;
unsigned int size;
YAP_Term list, head;
assert (term != NULL);
list = YAP_MkAtomTerm (YAP_LookupAtom ("[]"));
size = GEOSGetNumGeometries (geometry);
for (n = size - 1; n >= 0; n --)
{
geometry_n = (geometry_t) GEOSGetGeometryN (geometry, n);
if (procedure (geometry_n, NULL, &head) == FALSE)
return (FALSE);
list = YAP_MkPairTerm (head, list);
}
functor = YAP_MkFunctor (YAP_LookupAtom (functor_name), 1);
*term = YAP_MkApplTerm (functor, 1, &list);
return (TRUE);
}
static YAP_Term build_list(list l, int current_pos)
{
if (l.size > 0)
{
if (l.nDims > 1)
{
YAP_Term curr_term = YAP_MkAtomTerm(YAP_LookupAtom("[]"));
int cDims = l.dims[0], i, j, k, inc = cDims;
for (i = cDims - 1; i >= 0; i--)
{
list newL;
newL.nDims = l.nDims - 1;
newL.size = l.size / cDims;
k = 0;
for (j = 1; j < l.nDims; j++)
newL.dims[j - 1] = l.dims[j];
for (j = i; j < l.size; j += inc)
newL.values[k++] = l.values[j];
curr_term = YAP_MkPairTerm(build_list(newL, 0), curr_term);
}
return curr_term;
}
else
{
YAP_Term curr_term = get_term(l.values[current_pos]);
if (current_pos == l.size - 1)
return YAP_MkPairTerm(curr_term,
YAP_MkAtomTerm(YAP_LookupAtom("[]")));
else
return YAP_MkPairTerm(curr_term,
build_list(l, current_pos + 1));
}
}
return YAP_MkAtomTerm(YAP_LookupAtom("[]"));
}
static YAP_Bool make_polygon_to_term (geometry_t geometry,
const char * functor_name,
YAP_Term *term)
{
int n;
geometry_t ring;
sequence_t sequence;
YAP_Functor functor;
unsigned int size;
YAP_Term head;
assert (term != NULL);
*term = YAP_MkAtomTerm (YAP_LookupAtom ("[]"));
size = GEOSGetNumInteriorRings (geometry);
for (n = size - 1; n >= 0; n --)
{
ring = (geometry_t) GEOSGetInteriorRingN (geometry, n);
sequence = (sequence_t) GEOSGeom_getCoordSeq (ring);
if ((sequence == NULL)
|| (point_list_to_term (sequence, &head) == FALSE))
return (FALSE);
*term = YAP_MkPairTerm (head, *term);
}
/* Exterior ring always exists. */
ring = (geometry_t) GEOSGetExteriorRing (geometry);
if (ring == NULL)
return (FALSE);
sequence = (sequence_t) GEOSGeom_getCoordSeq (ring);
if ((sequence == NULL)
|| (point_list_to_term (sequence, &head) == FALSE))
return (FALSE);
*term = YAP_MkPairTerm (head, *term);
if (functor_name != NULL)
{
functor = YAP_MkFunctor (YAP_LookupAtom (NAME_POLYGON), 1);
*term = YAP_MkApplTerm (functor, 1, term);
}
return (TRUE);
}
/* this has to be done carefully because we all need to transpose the matrix */
static YAP_Term
cp_floats(int ndims, int *dims, double *input, int factor, int base, YAP_Term t)
{
int i;
if (ndims == 1)
for (i=dims[0]; i>0; i--) {
t = YAP_MkPairTerm(YAP_MkFloatTerm(input[base+factor*(i-1)]),t);
}
else
for (i=dims[0]; i>0; i--) {
t = cp_floats(ndims-1, dims+1, input, factor*dims[0], base+factor*(i-1),t);
}
return t;
}
static YAP_Term
cp_cells(int ndims, int *dims, mxArray *mat, int factor, int base, YAP_Term t)
{
int i;
if (ndims == 1)
for (i=dims[0]; i>0; i--) {
t = YAP_MkPairTerm(YAP_MkIntTerm((YAP_Int)mxGetCell(mat,base+factor*(i-1))),t);
}
else
for (i=dims[0]; i>0; i--) {
t = cp_cells(ndims-1, dims+1, mat, factor*dims[0], base+factor*(i-1),t);
}
return t;
}
static YAP_Term
cp_ints64(int ndims, int *dims, INT64_T *input, int factor, int base, YAP_Term t)
{
int i;
if (ndims == 1)
for (i=dims[0]; i>0; i--) {
t = YAP_MkPairTerm(YAP_MkIntTerm(input[base+factor*(i-1)]),t);
}
else
for (i=dims[0]; i>0; i--) {
t = cp_ints64(ndims-1, dims+1, input, factor*dims[0], base+factor*(i-1),t);
}
return t;
}
static int
p_call_matlab(void)
{
YAP_Term tlength = YAP_ARG2,
tl = YAP_ARG3,
tname = YAP_ARG1,
tolength = YAP_ARG4,
tout = YAP_ARG5;
int i = 0;
mxArray *inps[50], *outs[50];
const char *name;
int olength = YAP_IntOfTerm(tolength);
if (!YAP_IsAtomTerm(tname))
return FALSE;
name = YAP_AtomName(YAP_AtomOfTerm(tname));
if (!YAP_IsIntTerm(tlength))
return FALSE;
while (YAP_IsPairTerm(tl)) {
inps[i] = get_array(YAP_HeadOfTerm(tl));
i++;
tl = YAP_TailOfTerm(tl);
}
if (mexCallMATLAB(olength, outs, i, inps, name))
return FALSE;
/* output arguments */
if (YAP_IsPairTerm(tout)) {
for (i=0; i<olength; i++) {
YAP_Term ti = YAP_HeadOfTerm(tout);
if (YAP_IsAtomTerm(ti)) {
return !engPutVariable(Meng, YAP_AtomName(YAP_AtomOfTerm(ti)), outs[i]);
} else {
return YAP_Unify(ti,address2term(outs[i]));
}
}
} else {
YAP_Term to = YAP_MkAtomTerm(YAP_LookupAtom("[]"));
for (i=olength; i>0; i--) {
to = YAP_MkPairTerm(address2term(outs[i-1]),to);
}
}
return TRUE;
}
static YAP_Bool point_list_to_term (sequence_t sequence, YAP_Term *term)
{
int n;
unsigned int size;
YAP_Float x, y;
YAP_Term head;
assert (term != NULL);
*term = YAP_MkAtomTerm (YAP_LookupAtom ("[]"));
if (GEOSCoordSeq_getSize (sequence, &size) == 0)
return (FALSE);
for (n = size - 1; n >= 0; n --)
{
if ((GEOSCoordSeq_getX (sequence, n, &x) == 0)
|| (GEOSCoordSeq_getY (sequence, n, &y) == 0))
return (FALSE);
if (make_point (x, y, NULL, &head) == FALSE)
return (FALSE);
*term = YAP_MkPairTerm (head, *term);
}
return (TRUE);
}
YAP_Bool geometrycollection_to_term (geometry_t geometry, YAP_Term *term)
{
int n;
geometry_t geometry_n;
YAP_Functor functor;
unsigned int size;
YAP_Term head;
assert (term != NULL);
*term = YAP_MkAtomTerm (YAP_LookupAtom ("[]"));
size = GEOSGetNumGeometries (geometry);
for (n = size - 1; n >= 0; n --)
{
geometry_n = (geometry_t) GEOSGetGeometryN (geometry, n);
if (geometry_to_term (geometry_n, &head) == FALSE)
return (FALSE);
*term = YAP_MkPairTerm (head, *term);
}
functor = YAP_MkFunctor (YAP_LookupAtom (NAME_GEOMETRYCOLLECTION), 1);
*term = YAP_MkApplTerm (functor, 1, term);
return (TRUE);
}
static int
cuda_eval( void )
{
int32_t *mat;
#if defined(DATALOG) || defined(TUFFY)
int32_t *query = NULL;
setQuery(YAP_ARG1, &query);
#endif
int32_t finalDR = YAP_IntOfTerm(YAP_ARG3);
int32_t n = Cuda_Eval(facts, cf, rules, cr, query, & mat, names, finalDR);
#ifdef TUFFY
cf = 0;
#endif
#ifdef ROCKIT
if(cf > 0)
cf *= -1;
#endif
#if defined(TUFFY) || defined(ROCKIT)
cr = 0;
names[0] = '\0';
return FALSE;
#else
int32_t i;
predicate *ptr = (predicate *)YAP_IntOfTerm(YAP_ARG1);
int32_t ncols = ptr->num_columns;
YAP_Term out = YAP_TermNil();
YAP_Functor f = YAP_MkFunctor(YAP_IntToAtom(ptr->name), ncols);
YAP_Term vec[256];
YAP_Atom at;
if (n < 0)
return FALSE;
for (i=0; i<n; i++) {
int32_t ni = ((n-1)-i)*ncols, j;
printf("%s(", YAP_AtomName(YAP_IntToAtom(ptr->name)));
for (j=0; j<ncols; j++) {
vec[j] = YAP_MkIntTerm(mat[ni+j]);
at = YAP_IntToAtom(mat[ni+j]);
if(at != NULL)
printf("%s", YAP_AtomName(at));
else
printf("%d", mat[ni+j]);
if(j < (ncols - 1))
printf(",");
}
out = YAP_MkPairTerm(YAP_MkApplTerm( f, ncols, vec ), out);
printf(")\n");
}
if (n > 0)
free( mat );
return YAP_Unify(YAP_ARG2, out);
#endif
}
/* Return a list of files for a directory */
static YAP_Bool list_directory(void) {
YAP_Term tf = YAP_MkAtomTerm(YAP_LookupAtom("[]"));
long sl = YAP_InitSlot(tf);
char *buf = (char *)YAP_AtomName(YAP_AtomOfTerm(YAP_ARG1));
#if defined(__MINGW32__) || _MSC_VER
struct _finddata_t c_file;
char bs[BUF_SIZE];
long hFile;
bs[0] = '\0';
#if HAVE_STRNCPY
strncpy(bs, buf, BUF_SIZE);
#else
strcpy(bs, buf);
#endif
#if HAVE_STRNCAT
strncat(bs, "/*", BUF_SIZE);
#else
strcat(bs, "/*");
#endif
if ((hFile = _findfirst(bs, &c_file)) == -1L) {
return (YAP_Unify(YAP_ARG2, tf));
}
YAP_PutInSlot(sl, YAP_MkPairTerm(YAP_MkAtomTerm(YAP_LookupAtom(c_file.name)),
YAP_GetFromSlot(sl)));
while (_findnext(hFile, &c_file) == 0) {
YAP_Term ti = YAP_MkAtomTerm(YAP_LookupAtom(c_file.name));
YAP_PutInSlot(sl, YAP_MkPairTerm(ti, YAP_GetFromSlot(sl)));
}
_findclose(hFile);
#else
#if __ANDROID__
{
extern AAssetManager *Yap_assetManager(void);
const char *dirName = buf + strlen("/assets/");
AAssetManager *mgr = Yap_assetManager();
AAssetDir *de;
const char *dp;
if ((de = AAssetManager_openDir(mgr, dirName)) == NULL) {
return (YAP_Unify(YAP_ARG3, YAP_MkIntTerm(errno)));
}
while ((dp = AAssetDir_getNextFileName(de))) {
YAP_Term ti = YAP_MkAtomTerm(YAP_LookupAtom(dp));
YAP_PutInSlot(sl, YAP_MkPairTerm(ti, YAP_GetFromSlot(sl)));
}
AAssetDir_close(de);
}
#endif
#if HAVE_OPENDIR
{
DIR *de;
struct dirent *dp;
if ((de = opendir(buf)) == NULL) {
return (YAP_Unify(YAP_ARG3, YAP_MkIntTerm(errno)));
}
while ((dp = readdir(de))) {
YAP_Term ti = YAP_MkAtomTerm(YAP_LookupAtom(dp->d_name));
YAP_PutInSlot(sl, YAP_MkPairTerm(ti, YAP_GetFromSlot(sl)));
}
closedir(de);
}
#endif /* HAVE_OPENDIR */
#endif
tf = YAP_GetFromSlot(sl);
return YAP_Unify(YAP_ARG2, tf);
}
static YAP_Bool Q(void) {
YAP_Term arg1, arg2, arg3, arg4, out, out1, term, nodesTerm, ruleTerm, tail,
pair, compoundTerm;
DdNode *node1, **nodes_ex;
int r, lenNodes, i;
double p1, p0, **eta_rule, CLL;
arg1 = YAP_ARG1;
arg2 = YAP_ARG2;
arg3 = YAP_ARG3;
arg4 = YAP_ARG4;
nodesTerm = arg1;
lenNodes = YAP_IntOfTerm(arg2);
nodes_ex = (DdNode **)malloc(lenNodes * sizeof(DdNode *));
example_prob = (double *)malloc(lenNodes * sizeof(double));
for (i = 0; i < lenNodes; i++) {
pair = YAP_HeadOfTerm(nodesTerm);
node1 = (DdNode *)YAP_IntOfTerm(YAP_HeadOfTerm(pair));
nodes_ex[i] = node1;
pair = YAP_TailOfTerm(pair);
example_prob[i] = YAP_FloatOfTerm(YAP_HeadOfTerm(pair));
nodesTerm = YAP_TailOfTerm(nodesTerm);
}
for (r = 0; r < nRules; r++) {
for (i = 0; i < rules[r] - 1; i++) {
eta_rule = eta[r];
eta_rule[i][0] = 0;
eta_rule[i][1] = 0;
}
}
CLL = Expectation(nodes_ex, lenNodes);
out = YAP_TermNil();
for (r = 0; r < nRules; r++) {
tail = YAP_TermNil();
eta_rule = eta[r];
for (i = 0; i < rules[r] - 1; i++) {
p0 = eta_rule[i][0];
p1 = eta_rule[i][1];
term = YAP_MkPairTerm(YAP_MkFloatTerm(p0),
YAP_MkPairTerm(YAP_MkFloatTerm(p1), YAP_TermNil()));
tail = YAP_MkPairTerm(term, tail);
}
ruleTerm = YAP_MkIntTerm(r);
compoundTerm =
YAP_MkPairTerm(ruleTerm, YAP_MkPairTerm(tail, YAP_TermNil()));
out = YAP_MkPairTerm(compoundTerm, out);
}
free(nodes_ex);
free(example_prob);
out1 = YAP_MkFloatTerm(CLL);
YAP_Unify(out1, arg4);
return (YAP_Unify(out, arg3));
}
static YAP_Bool EM(void) {
YAP_Term arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, out1, out2, out3,
nodesTerm, ruleTerm, tail, pair, compoundTerm;
DdNode *node1, **nodes_ex;
int r, lenNodes, i, iter;
long iter1;
double CLL0 = -2.2 * pow(10, 10); //-inf
double CLL1 = -1.7 * pow(10, 8); //+inf
double p, p0, **eta_rule, ea, er;
double ratio, diff;
arg1 = YAP_ARG1;
arg2 = YAP_ARG2;
arg3 = YAP_ARG3;
arg4 = YAP_ARG4;
arg5 = YAP_ARG5;
arg6 = YAP_ARG6;
arg7 = YAP_ARG7;
arg8 = YAP_ARG8;
nodesTerm = arg1;
ea = YAP_FloatOfTerm(arg2);
er = YAP_FloatOfTerm(arg3);
lenNodes = YAP_IntOfTerm(arg4);
iter = YAP_IntOfTerm(arg5);
nodes_ex = (DdNode **)malloc(lenNodes * sizeof(DdNode *));
nodes_probs_ex = (double *)malloc(lenNodes * sizeof(double));
example_prob = (double *)malloc(lenNodes * sizeof(double));
for (i = 0; i < lenNodes; i++) {
pair = YAP_HeadOfTerm(nodesTerm);
node1 = (DdNode *)YAP_IntOfTerm(YAP_HeadOfTerm(pair));
nodes_ex[i] = node1;
pair = YAP_TailOfTerm(pair);
example_prob[i] = YAP_FloatOfTerm(YAP_HeadOfTerm(pair));
nodesTerm = YAP_TailOfTerm(nodesTerm);
}
diff = CLL1 - CLL0;
ratio = diff / fabs(CLL0);
if (iter == -1)
iter1 = 2147000000;
else
iter1 = iter;
while ((diff > ea) && (ratio > er) && (cycle < iter1)) {
cycle++;
for (r = 0; r < nRules; r++) {
for (i = 0; i < rules[r] - 1; i++) {
eta_rule = eta[r];
eta_rule[i][0] = 0;
eta_rule[i][1] = 0;
}
}
CLL0 = CLL1;
CLL1 = Expectation(nodes_ex, lenNodes);
Maximization();
diff = CLL1 - CLL0;
ratio = diff / fabs(CLL0);
}
out2 = YAP_TermNil();
for (r = 0; r < nRules; r++) {
tail = YAP_TermNil();
p0 = 1;
for (i = 0; i < rules[r] - 1; i++) {
p = arrayprob[r][i] * p0;
tail = YAP_MkPairTerm(YAP_MkFloatTerm(p), tail);
p0 = p0 * (1 - arrayprob[r][i]);
}
tail = YAP_MkPairTerm(YAP_MkFloatTerm(p0), tail);
ruleTerm = YAP_MkIntTerm(r);
compoundTerm =
YAP_MkPairTerm(ruleTerm, YAP_MkPairTerm(tail, YAP_TermNil()));
out2 = YAP_MkPairTerm(compoundTerm, out2);
}
out3 = YAP_TermNil();
for (i = 0; i < lenNodes; i++) {
out3 = YAP_MkPairTerm(YAP_MkFloatTerm(nodes_probs_ex[i]), out3);
}
YAP_Unify(out3, arg8);
out1 = YAP_MkFloatTerm(CLL1);
YAP_Unify(out1, arg6);
free(nodes_ex);
free(example_prob);
free(nodes_probs_ex);
return (YAP_Unify(out2, arg7));
}
static YAP_Bool regexp(void)
{
unsigned int buflen = (unsigned int)YAP_IntOfTerm(YAP_ARG2)+1;
unsigned int sbuflen = (unsigned int)YAP_IntOfTerm(YAP_ARG4)+1;
char *buf, *sbuf;
regex_t reg;
int out;
size_t nmatch;
regmatch_t *pmatch;
long int tout;
int yap_flags = YAP_IntOfTerm(YAP_ARG5);
int regcomp_flags = REG_EXTENDED;
if ((buf = (char *)YAP_AllocSpaceFromYap(buflen)) == NULL) {
/* early exit */
return(FALSE);
}
if (YAP_StringToBuffer(YAP_ARG1,buf,buflen) == FALSE) {
/* something went wrong, possibly a type checking error */
YAP_FreeSpaceFromYap(buf);
return(FALSE);
}
if (yap_flags & 1)
regcomp_flags |= REG_ICASE;
/* cool, now I have my string in the buffer, let's have some fun */
if (yap_regcomp(®,buf, regcomp_flags) != 0) {
YAP_FreeSpaceFromYap(buf);
return(FALSE);
}
if (YAP_IsVarTerm(YAP_ARG7)) {
nmatch = reg.re_nsub;
} else {
nmatch = YAP_IntOfTerm(YAP_ARG7);
}
if ((sbuf = (char *)YAP_AllocSpaceFromYap(sbuflen)) == NULL) {
/* early exit */
yap_regfree(®);
YAP_FreeSpaceFromYap(buf);
return(FALSE);
}
if (YAP_StringToBuffer(YAP_ARG3,sbuf,sbuflen) == FALSE) {
/* something went wrong, possibly a type checking error */
yap_regfree(®);
YAP_FreeSpaceFromYap(buf);
YAP_FreeSpaceFromYap(sbuf);
return(FALSE);
}
pmatch = YAP_AllocSpaceFromYap(sizeof(regmatch_t)*(nmatch));
out = yap_regexec(®,sbuf,nmatch,pmatch,0);
if (out == 0) {
/* match succeed, let's fill the match in */
long int i;
YAP_Term TNil = YAP_MkAtomTerm(YAP_LookupAtom("[]"));
YAP_Functor FDiff = YAP_MkFunctor(YAP_LookupAtom("-"),2);
tout = TNil;
for (i = nmatch-1; i >= 0; --i) {
int j;
YAP_Term t = TNil;
if (pmatch[i].rm_so != -1) {
if (yap_flags & 2) {
YAP_Term to[2];
to[0] = YAP_MkIntTerm(pmatch[i].rm_so);
to[1] = YAP_MkIntTerm(pmatch[i].rm_eo);
t = YAP_MkApplTerm(FDiff,2,to);
} else {
for (j = pmatch[i].rm_eo-1; j >= pmatch[i].rm_so; j--) {
t = YAP_MkPairTerm(YAP_MkIntTerm(sbuf[j]),t);
}
}
tout = YAP_MkPairTerm(t,tout);
}
}
out = !YAP_Unify(tout, YAP_ARG6);
}
else if (out != REG_NOMATCH) {
out = 0;
}
yap_regfree(®);
YAP_FreeSpaceFromYap(buf);
YAP_FreeSpaceFromYap(sbuf);
YAP_FreeSpaceFromYap(pmatch);
return(out == 0);
}
