static mxArray* get_array(YAP_Term ti) { if (YAP_IsIntTerm(ti)) { return mxCreateDoubleScalar(YAP_IntOfTerm(ti)); } else if (YAP_IsFloatTerm(ti)) { return mxCreateDoubleScalar(YAP_FloatOfTerm(ti)); } else if (YAP_IsAtomTerm(ti)) { return matlab_getvar(ti); } else if (YAP_IsPairTerm(ti)) { YAP_Term tv = YAP_HeadOfTerm(ti); YAP_Term tf = YAP_TailOfTerm(ti); const mxArray *mout; if (!YAP_IsAtomTerm(tv)) { char s[BUFSIZE]; if (!YAP_StringToBuffer(ti, s, BUFSIZE)) return FALSE; return mxCreateString(s); } mout = matlab_getvar(tv); if (!mout) return FALSE; if (YAP_IsIntTerm(tf)) { return mxGetFieldByNumber(mout, 0, YAP_IntOfTerm(tf)); } else if (YAP_IsAtomTerm(tf)) { const char *s=YAP_AtomName(YAP_AtomOfTerm(tf)); return mxGetField(mout, 0, s); } else { return NULL; } } else { return (mxArray *)YAP_IntOfTerm(YAP_ArgOfTerm(1,ti)); } }
static int cuda_load_fact( void ) { int i = currentFact; #if defined(DATALOG) || defined(TUFFY) YAP_Term th = YAP_ARG1; int ncols = currentPred->num_columns; int j; int *mat = currentPred->address_host_table; for (j = 0; j < ncols; j++) { YAP_Term ta = YAP_ArgOfTerm(j+1, th); if (YAP_IsAtomTerm(ta)) { mat[i*ncols+j] = YAP_AtomToInt(YAP_AtomOfTerm(ta)); } else { mat[i*ncols+j] = YAP_IntOfTerm(ta); } } #endif i++; if (i == currentPred->num_rows) { Cuda_NewFacts(currentPred); currentPred = NULL; currentFact = 0; } else { currentFact = i; } return TRUE; }
static int p_create_cell_matrix_and_copy1(void) { int rows, cols; mxArray *mat; YAP_Term tl = YAP_ARG3; rows = YAP_IntOfTerm(YAP_ARG1); cols = YAP_IntOfTerm(YAP_ARG2); if (!(mat = mxCreateCellMatrix(rows, cols))) return FALSE; while (YAP_IsPairTerm(tl)) { YAP_Term th = YAP_HeadOfTerm(tl); int off = MAT_ACCESS(YAP_IntOfTerm(YAP_ArgOfTerm(1,th))-1, YAP_IntOfTerm(YAP_ArgOfTerm(2,th))-1, rows,cols); mxArray *mat2 = get_array(YAP_ArgOfTerm(3,th)); mxSetCell(mat,off, mat2); tl = YAP_TailOfTerm(tl); } if (YAP_IsAtomTerm(YAP_ARG4)) { return !engPutVariable(Meng, YAP_AtomName(YAP_AtomOfTerm(YAP_ARG4)), mat); } return YAP_Unify(YAP_ARG4,address2term(mat)); }
static YAP_Bool point_list_to_sequence (YAP_Term term, unsigned int size, sequence_t *sequence) { YAP_Float x, y; unsigned int n; YAP_Term head; *sequence = GEOSCoordSeq_create (size, 2); if (*sequence == NULL) return (FALSE); for (n = 0; YAP_IsPairTerm (term) != FALSE; n ++) { assert (n < size); head = YAP_HeadOfTerm (term); if ((Yap_IsNumberTerm (YAP_ArgOfTerm (1, head), &x) == FALSE) || (Yap_IsNumberTerm (YAP_ArgOfTerm (2, head), &y) == FALSE) || (GEOSCoordSeq_setX (*sequence, n, x) == 0) || (GEOSCoordSeq_setY (*sequence, n, y) == 0)) { GEOSCoordSeq_destroy (*sequence); return (FALSE); } term = YAP_TailOfTerm (term); } assert (n == size); assert (YAP_IsAtomTerm (term) != FALSE); assert (strcmp (YAP_AtomName (YAP_AtomOfTerm (term)), "[]") == 0); return (TRUE); }
static int p_startmatlab(void) { char opts[BUFSIZE]; const char *ptr; YAP_Term topts = YAP_ARG1; if (Meng) return TRUE; if (YAP_IsAtomTerm(topts)) ptr = YAP_AtomName(YAP_AtomOfTerm(topts)); else { if (!YAP_StringToBuffer(topts,opts, BUFSIZE)) return YAP_Unify(YAP_ARG2, YAP_MkIntTerm(-1)); ptr = opts; } if (!strlen(ptr)) { if (!(Meng = engOpen("\0"))) { return YAP_Unify(YAP_ARG2, YAP_MkIntTerm(-2)); } } else { if (!(Meng = engOpen(ptr))) { return YAP_Unify(YAP_ARG2, YAP_MkIntTerm(-2)); } } engOutputBuffer(Meng, NULL, 0); return TRUE; }
static int cp_back(YAP_Term vart, mxArray *mat) { if (!YAP_IsAtomTerm(vart)) { return TRUE; } /* save back to matlab */ return !engPutVariable(Meng, YAP_AtomName(YAP_AtomOfTerm(vart)), mat); }
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; }
/* Check if a prolog `term' is a well formed list and optionally return it's size if the variable `size' is not NULL. */ static YAP_Bool is_list_get_size (YAP_Term term, unsigned int *size) { unsigned int n; for (n = 0; YAP_IsPairTerm (term) != FALSE; n ++) term = YAP_TailOfTerm (term); if ((YAP_IsAtomTerm (term) == FALSE) || (strcmp (YAP_AtomName (YAP_AtomOfTerm (term)), "[]") != 0)) return (FALSE); if (size != NULL) *size = n; return (TRUE); }
static YAP_Bool list_to_geometry (YAP_Term term, unsigned int minimum, procedure_to_geometry_t procedure, geometry_type_t geometry_type, geometry_t *geometry) { geometry_t *p; unsigned int size; unsigned int v, n; YAP_Term head; assert (geometry != NULL); term = YAP_ArgOfTerm (1, term); if ((is_list_get_size (term, &size) == FALSE) || (size < minimum)) return (FALSE); p = (geometry_t *) malloc (sizeof (geometry_t) * size); if (p == NULL) { warning ("%s: list_to_geometry: not enough memory", __FILE__); return (FALSE); } memset (p, 0, sizeof (geometry_t) * size); for (n = 0; YAP_IsPairTerm (term) != FALSE; n ++) { assert (n < size); head = YAP_HeadOfTerm (term); if (procedure (head, &p[n]) == FALSE) { for (v = 0; v < n; v ++) GEOSGeom_destroy (p[v]); free (p); return (FALSE); } term = YAP_TailOfTerm (term); } assert (n == size); assert (YAP_IsAtomTerm (term) != FALSE); assert (strcmp (YAP_AtomName (YAP_AtomOfTerm (term)), "[]") == 0); if (geometry_type == GEOS_POLYGON) *geometry = GEOSGeom_createPolygon (p[0], p + 1, size - 1); else *geometry = GEOSGeom_createCollection (geometry_type, p, size); memset (p, 0, sizeof (geometry_t) * size); free (p); if (*geometry == NULL) return (FALSE); return (TRUE); }
static int p_create_double_vector(void) { mwSize dims[1]; mxArray *mat; dims[0] = YAP_IntOfTerm(YAP_ARG1); if (!(mat = mxCreateNumericArray(1, dims, mxDOUBLE_CLASS, mxREAL))) return FALSE; if (YAP_IsAtomTerm(YAP_ARG2)) { return !engPutVariable(Meng, YAP_AtomName(YAP_AtomOfTerm(YAP_ARG2)), mat); } return YAP_Unify(YAP_ARG2,address2term(mat)); }
static int p_create_cell_vector(void) { mwSize dims[1]; mxArray *mat; dims[0] = YAP_IntOfTerm(YAP_ARG1); if (!(mat = mxCreateCellArray(1, dims))) return FALSE; if (YAP_IsAtomTerm(YAP_ARG2)) { return !engPutVariable(Meng, YAP_AtomName(YAP_AtomOfTerm(YAP_ARG2)), mat); } return YAP_Unify(YAP_ARG2,address2term(mat)); }
static int p_create_double_array(void) { int rows, cols; mxArray *mat; rows = YAP_IntOfTerm(YAP_ARG1); cols = YAP_IntOfTerm(YAP_ARG2); if (!(mat = mxCreateDoubleMatrix(rows, cols, mxREAL))) return FALSE; if (YAP_IsAtomTerm(YAP_ARG3)) { return !engPutVariable(Meng, YAP_AtomName(YAP_AtomOfTerm(YAP_ARG3)), mat); } return YAP_Unify(YAP_ARG3,address2term(mat)); }
static int p_evalstring2(void) { char com[BUFSIZE]; YAP_Term tcom = YAP_ARG1; const char *comd; if (YAP_IsAtomTerm(tcom)) comd = YAP_AtomName(YAP_AtomOfTerm(tcom)); else { if (!YAP_StringToBuffer(tcom, com, BUFSIZE)) return YAP_Unify(YAP_ARG2, YAP_MkIntTerm(-1)); comd = com; } return !engEvalString(Meng, comd); }
static int load_facts( void ) { int32_t nrows = YAP_IntOfTerm(YAP_ARG1); int32_t ncols = YAP_IntOfTerm(YAP_ARG2), i = 0; YAP_Term t3 = YAP_ARG3; int32_t *mat = (int32_t *)malloc(sizeof(int32_t)*nrows*ncols); int32_t pname = YAP_AtomToInt(YAP_NameOfFunctor(YAP_FunctorOfTerm(YAP_HeadOfTerm(t3)))); predicate *pred; while(YAP_IsPairTerm(t3)) { int32_t j = 0; YAP_Term th = YAP_HeadOfTerm(t3); for (j = 0; j < ncols; j++) { YAP_Term ta = YAP_ArgOfTerm(j+1, th); if (YAP_IsAtomTerm(ta)) { mat[i*ncols+j] = YAP_AtomToInt(YAP_AtomOfTerm(ta)); } else { mat[i*ncols+j] = YAP_IntOfTerm(ta); } } t3 = YAP_TailOfTerm( t3 ); i++; } if (YAP_IsVarTerm( YAP_ARG4)) { // new pred = (predicate *)malloc(sizeof(predicate)); } else { pred = (predicate *)YAP_IntOfTerm(YAP_ARG4); if (pred->address_host_table) free( pred->address_host_table ); } pred->name = pname; pred->num_rows = nrows; pred->num_columns = ncols; pred->is_fact = TRUE; pred->address_host_table = mat; Cuda_NewFacts(pred); if (YAP_IsVarTerm( YAP_ARG4)) { return YAP_Unify(YAP_ARG4, YAP_MkIntTerm((YAP_Int)pred)); } else { return TRUE; } }
static int optimizer_get_parameter( void ) { YAP_Term t1 = YAP_ARG1; YAP_Term t2 = YAP_ARG2; if (! YAP_IsAtomTerm(t1)) { return FALSE; } const char* name=YAP_AtomName(YAP_AtomOfTerm(t1)); if ((strcmp(name, "m") == 0)) { return YAP_Unify(t2,YAP_MkIntTerm(param.m)); } else if ((strcmp(name, "epsilon") == 0)) { return YAP_Unify(t2,YAP_MkFloatTerm(param.epsilon)); } else if ((strcmp(name, "past") == 0)) { return YAP_Unify(t2,YAP_MkIntTerm(param.past)); } else if ((strcmp(name, "delta") == 0)) { return YAP_Unify(t2,YAP_MkFloatTerm(param.delta)); } else if ((strcmp(name, "max_iterations") == 0)) { return YAP_Unify(t2,YAP_MkIntTerm(param.max_iterations)); } else if ((strcmp(name, "linesearch") == 0)) { return YAP_Unify(t2,YAP_MkIntTerm(param.linesearch)); } else if ((strcmp(name, "max_linesearch") == 0)) { return YAP_Unify(t2,YAP_MkIntTerm(param.max_linesearch)); } else if ((strcmp(name, "min_step") == 0)) { return YAP_Unify(t2,YAP_MkFloatTerm(param.min_step)); } else if ((strcmp(name, "max_step") == 0)) { return YAP_Unify(t2,YAP_MkFloatTerm(param.max_step)); } else if ((strcmp(name, "ftol") == 0)) { return YAP_Unify(t2,YAP_MkFloatTerm(param.ftol)); } else if ((strcmp(name, "gtol") == 0)) { return YAP_Unify(t2,YAP_MkFloatTerm(param.gtol)); } else if ((strcmp(name, "xtol") == 0)) { return YAP_Unify(t2,YAP_MkFloatTerm(param.xtol)); } else if ((strcmp(name, "orthantwise_c") == 0)) { return YAP_Unify(t2,YAP_MkFloatTerm(param.orthantwise_c)); } else if ((strcmp(name, "orthantwise_start") == 0)) { return YAP_Unify(t2,YAP_MkIntTerm(param.orthantwise_start)); } else if ((strcmp(name, "orthantwise_end") == 0)) { return YAP_Unify(t2,YAP_MkIntTerm(param.orthantwise_end)); } printf("ERROR: The parameter %s is unknown.\n",name); return FALSE; }
static HANDLE get_handle(YAP_Term ti, DWORD fd) { if (YAP_IsAtomTerm(ti)) { HANDLE out; SECURITY_ATTRIBUTES satt; satt.nLength = sizeof(satt); satt.lpSecurityDescriptor = NULL; satt.bInheritHandle = TRUE; out = CreateFile("NUL", GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, &satt, OPEN_EXISTING, 0, NULL); return (out); } else { if (YAP_IsIntTerm(ti)) { return (GetStdHandle(fd)); } else return ((HANDLE)_get_osfhandle(YAP_StreamToFileNo(ti))); } }
static int p_itrie_save_as_trie(void) { const char *file_str; FILE *file; /* check args */ if (!YAP_IsIntTerm(arg_itrie)) return FALSE; if (!YAP_IsAtomTerm(arg_file)) return FALSE; /* open file */ file_str = YAP_AtomName(YAP_AtomOfTerm(arg_file)); if (!(file = fopen(file_str, "w"))) return FALSE; /* save itrie as trie and close file */ itrie_save_as_trie((TrEntry) YAP_IntOfTerm(arg_itrie), file); if (fclose(file)) return FALSE; return TRUE; }
static int p_evalstring3(void) { int out; YAP_Term tcom = YAP_ARG1; const char *comd; char com[BUFSIZE]; char buf[OBUFSIZE]; buf[0] = '\0'; if (YAP_IsAtomTerm(tcom)) comd = YAP_AtomName(YAP_AtomOfTerm(tcom)); else { if (!YAP_StringToBuffer(tcom, com, BUFSIZE)) return YAP_Unify(YAP_ARG2, YAP_MkIntTerm(-1)); comd = com; } engOutputBuffer(Meng, buf, OBUFSIZE); out = !engEvalString(Meng, comd); engOutputBuffer(Meng, NULL, 0); return YAP_Unify(YAP_ARG2, YAP_BufferToString(buf)); }
static int p_set_float_array(void) { int rows, cols, i = 0, j = 0; double *input; mxArray *mat; YAP_Term tl = YAP_ARG3; rows = YAP_IntOfTerm(YAP_ARG1); cols = YAP_IntOfTerm(YAP_ARG2); if (!(mat = mxCreateDoubleMatrix(rows, cols, mxREAL))) return FALSE; input = mxGetPr(mat); /* copy ints to matrix. */ for (i = 0; i < rows; i++) { for (j = 0; j < cols; j++) { YAP_Term th; if (!YAP_IsPairTerm(tl)) { return FALSE; } th = YAP_HeadOfTerm(tl); if (YAP_IsIntTerm(th)) { input[MAT_ACCESS(i,j,rows,cols)] = YAP_IntOfTerm(th); } else if (YAP_IsFloatTerm(th)) { input[MAT_ACCESS(i,j,rows,cols)] = YAP_FloatOfTerm(th); } else { /* ERROR */ return FALSE; } tl = YAP_TailOfTerm(tl); } } if (YAP_IsAtomTerm(YAP_ARG4)) { return !engPutVariable(Meng, YAP_AtomName(YAP_AtomOfTerm(YAP_ARG4)), mat); } return YAP_Unify(YAP_ARG4,address2term(mat)); }
static int p_itrie_load(void) { TrEntry itrie; const char *file_str; FILE *file; /* check args */ if (!YAP_IsVarTerm(arg_itrie)) return FALSE; if (!YAP_IsAtomTerm(arg_file)) return FALSE; /* open file */ file_str = YAP_AtomName(YAP_AtomOfTerm(arg_file)); if (!(file = fopen(file_str, "r"))) return FALSE; /* load itrie and close file */ if (!(itrie = itrie_load(file))) return FALSE; if (fclose(file)) return FALSE; return YAP_Unify(arg_itrie, YAP_MkIntTerm((YAP_Int) itrie)); }
static int p_set_int_array(void) { int rows, cols, i = 0, j = 0; YAP_Int *input; mxArray *mat; YAP_Term tl = YAP_ARG4; mat = matlab_getvar(YAP_ARG1); rows = YAP_IntOfTerm(YAP_ARG2); cols = YAP_IntOfTerm(YAP_ARG3); input = (YAP_Int *)mxGetPr(mat); /* copy ints to matrix. */ for (i = 0; i < rows*cols; i++) { YAP_Term th; if (!YAP_IsPairTerm(tl)) { return FALSE; } th = YAP_HeadOfTerm(tl); if (!YAP_IsIntTerm(th)) { /* ERROR */ return FALSE; } input[MAT_ACCESS(i++,j,rows,cols)] = YAP_IntOfTerm(th); if (i == rows) { i = 0; j++; } tl = YAP_TailOfTerm(tl); } if (YAP_IsAtomTerm(YAP_ARG4)) { return !engPutVariable(Meng, YAP_AtomName(YAP_AtomOfTerm(YAP_ARG4)), mat); } return YAP_Unify(YAP_ARG4,address2term(mat)); }
control_t *RtreeUdiInit (Term spec, void * pred, int arity){ control_t *control; YAP_Term arg; int i, c; /* YAP_Term mod; */ /* spec = Yap_StripModule(spec, &mod); */ if (! YAP_IsApplTerm(spec)) return (NULL); control = (control_t *) malloc (sizeof(*control)); assert(control); memset((void *) control,0, sizeof(*control)); c = 0; for (i = 1; i <= arity; i ++) { arg = YAP_ArgOfTerm(i,spec); if (YAP_IsAtomTerm(arg) && strcmp("+",YAP_AtomName(YAP_AtomOfTerm(arg))) == 0) { (*control)[c].pred = pred; (*control)[c++].arg = i; } } /* for (i = 0; i < NARGS; i++) printf("%d,%p\t",(*control)[i].arg,(*control)[i].tree); printf("\n"); */ return control; }
static int p_set_float_vector(void) { mwSize len[1]; int i = 0; double *input; mxArray *mat; YAP_Term tl = YAP_ARG2; len[0] = YAP_IntOfTerm(YAP_ARG1); if (!(mat = mxCreateNumericArray(1,len, mxDOUBLE_CLASS, mxREAL))) return FALSE; input = mxGetPr(mat); /* copy ints to matrix. */ for (i = 0; i < len[0]; i++) { YAP_Term th; if (!YAP_IsPairTerm(tl)) { return FALSE; } th = YAP_HeadOfTerm(tl); if (YAP_IsIntTerm(th)) { input[i] = YAP_IntOfTerm(th); } else if (YAP_IsFloatTerm(th)) { input[i] = YAP_FloatOfTerm(th); } else { /* ERROR */ return FALSE; } tl = YAP_TailOfTerm(tl); } if (YAP_IsAtomTerm(YAP_ARG3)) { return !engPutVariable(Meng, YAP_AtomName(YAP_AtomOfTerm(YAP_ARG3)), mat); } return YAP_Unify(YAP_ARG3,address2term(mat)); }
static void close_handle(YAP_Term ti, HANDLE h) { if (YAP_IsAtomTerm(ti)) { CloseHandle(h); } }
static int load_rule( void ) { // maximum of 2K symbols per rule, should be enough for ILP int32_t vec[2048], *ptr = vec, *nvec, neg[2048]; // qK different variables; YAP_Term vars[1024]; int32_t nvars = 0, x; int32_t ngoals = YAP_IntOfTerm(YAP_ARG1); /* gives the number of goals */ int32_t ncols = YAP_IntOfTerm(YAP_ARG2); YAP_Term t3 = YAP_ARG3; YAP_Atom name = YAP_NameOfFunctor(YAP_FunctorOfTerm(YAP_HeadOfTerm(t3))); int32_t pname = YAP_AtomToInt(name); const char *strname = YAP_AtomName(name); predicate *pred; int32_t cont = 0; memset(neg, 0x0, 2048 * sizeof(int32_t)); while(YAP_IsPairTerm(t3)) { int32_t j = 0, m; YAP_Term th = YAP_HeadOfTerm(t3); YAP_Functor f = YAP_FunctorOfTerm( th ); int32_t n = YAP_ArityOfFunctor( f ); YAP_Atom at = YAP_NameOfFunctor( f ); if (at == AtomEq) *ptr++ = SBG_EQ; else if (at == AtomGt) *ptr++ = SBG_GT; else if (at == AtomLt) *ptr++ = SBG_LT; else if (at == AtomGe) *ptr++ = SBG_GE; else if (at == AtomLe) *ptr++ = SBG_LE; else if (at == AtomDf) *ptr++ = SBG_DF; else if (at == AtomNt) { neg[cont] = 1; cont++; } else { *ptr++ = YAP_AtomToInt( at ); cont++; } for (j = 0; j < n; j++) { YAP_Term ta = YAP_ArgOfTerm(j+1, th); if (YAP_IsVarTerm(ta)) { int32_t k; for (k = 0; k< nvars; k++) { if (vars[k] == ta) { *ptr++ = k+1; break; } } if (k == nvars) { vars[k] = ta; *ptr++ = k+1; nvars++; } } else if (YAP_IsAtomTerm(ta)) { *ptr++ = -YAP_AtomToInt(YAP_AtomOfTerm(ta)); } else if (YAP_IsApplTerm(ta)) { f = YAP_FunctorOfTerm( ta ); at = YAP_NameOfFunctor( f ); m = YAP_ArityOfFunctor( f ); *ptr++ = YAP_AtomToInt( at ); for (x = 0; x < m; x++) { YAP_Term ta2 = YAP_ArgOfTerm(x+1, ta); if (YAP_IsVarTerm(ta2)) { int32_t k; for (k = 0; k < nvars; k++) { if (vars[k] == ta2) { *ptr++ = k+1; break; } } if (k == nvars) { vars[k] = ta2; *ptr++ = k+1; nvars++; } } else if (YAP_IsAtomTerm(ta2)) { *ptr++ = -YAP_AtomToInt(YAP_AtomOfTerm(ta)); } else { *ptr++ = -YAP_IntOfTerm(ta); } } } else { *ptr++ = -YAP_IntOfTerm(ta); } } *ptr++ = 0; t3 = YAP_TailOfTerm( t3 ); } if (YAP_IsVarTerm( YAP_ARG4)) { // new pred = (predicate *)malloc(sizeof(predicate)); } else { pred = (predicate *)YAP_IntOfTerm(YAP_ARG4); if (pred->address_host_table) free( pred->address_host_table ); } pred->name = pname; pred->num_rows = ngoals; pred->num_columns = ncols; pred->is_fact = FALSE; x = (strlen(strname) + 1) * sizeof(char); pred->predname = (char *)malloc(x); memcpy(pred->predname, strname, x); nvec = (int32_t *)malloc(sizeof(int32_t)*(ptr-vec)); memcpy(nvec, vec, sizeof(int32_t)*(ptr-vec)); pred->address_host_table = nvec; pred->negatives = (int32_t *)malloc(sizeof(int32_t) * cont); memcpy(pred->negatives, neg, sizeof(int32_t) * cont); Cuda_NewRule( pred ); return YAP_Unify(YAP_ARG4, YAP_MkIntTerm((YAP_Int)pred)); }
/** @pred optimizer_set_parameter(+Name,+Value) Set the parameter Name to Value. Only possible while the optimizer is not running. */ static int optimizer_set_parameter( void ) { YAP_Term t1 = YAP_ARG1; YAP_Term t2 = YAP_ARG2; if (optimizer_status != OPTIMIZER_STATUS_NONE && optimizer_status != OPTIMIZER_STATUS_INITIALIZED){ printf("ERROR: Optimizer is running right now. Please wait till it is finished.\n"); return FALSE; } if (! YAP_IsAtomTerm(t1)) { return FALSE; } const char* name=YAP_AtomName(YAP_AtomOfTerm(t1)); if ((strcmp(name, "m") == 0)) { if (! YAP_IsIntTerm(t2)) { return FALSE; } param.m = YAP_IntOfTerm(t2); } else if ((strcmp(name, "epsilon") == 0)) { lbfgsfloatval_t v; if (YAP_IsFloatTerm(t2)) { v=YAP_FloatOfTerm(t2); } else if (YAP_IsIntTerm(t2)) { v=(lbfgsfloatval_t) YAP_IntOfTerm(t2); } else { return FALSE; } param.epsilon=v; } else if ((strcmp(name, "past") == 0)) { if (! YAP_IsIntTerm(t2)) { return FALSE; } param.past = YAP_IntOfTerm(t2); } else if ((strcmp(name, "delta") == 0)) { lbfgsfloatval_t v; if (YAP_IsFloatTerm(t2)) { v=YAP_FloatOfTerm(t2); } else if (YAP_IsIntTerm(t2)) { v=(lbfgsfloatval_t) YAP_IntOfTerm(t2); } else { return FALSE; } param.delta=v; } else if ((strcmp(name, "max_iterations") == 0)) { if (! YAP_IsIntTerm(t2)) { return FALSE; } param.max_iterations = YAP_IntOfTerm(t2); } else if ((strcmp(name, "linesearch") == 0)) { if (! YAP_IsIntTerm(t2)) { return FALSE; } param.linesearch = YAP_IntOfTerm(t2); } else if ((strcmp(name, "max_linesearch") == 0)) { if (! YAP_IsIntTerm(t2)) { return FALSE; } param.max_linesearch = YAP_IntOfTerm(t2); } else if ((strcmp(name, "min_step") == 0)) { lbfgsfloatval_t v; if (YAP_IsFloatTerm(t2)) { v=YAP_FloatOfTerm(t2); } else if (YAP_IsIntTerm(t2)) { v=(lbfgsfloatval_t) YAP_IntOfTerm(t2); } else { return FALSE; } param.min_step=v; } else if ((strcmp(name, "max_step") == 0)) { lbfgsfloatval_t v; if (YAP_IsFloatTerm(t2)) { v=YAP_FloatOfTerm(t2); } else if (YAP_IsIntTerm(t2)) { v=(lbfgsfloatval_t) YAP_IntOfTerm(t2); } else { return FALSE; } param.max_step=v; } else if ((strcmp(name, "ftol") == 0)) { lbfgsfloatval_t v; if (YAP_IsFloatTerm(t2)) { v=YAP_FloatOfTerm(t2); } else if (YAP_IsIntTerm(t2)) { v=(lbfgsfloatval_t) YAP_IntOfTerm(t2); } else { return FALSE; } param.ftol=v; } else if ((strcmp(name, "gtol") == 0)) { lbfgsfloatval_t v; if (YAP_IsFloatTerm(t2)) { v=YAP_FloatOfTerm(t2); } else if (YAP_IsIntTerm(t2)) { v=(lbfgsfloatval_t) YAP_IntOfTerm(t2); } else { return FALSE; } param.gtol=v; } else if ((strcmp(name, "xtol") == 0)) { lbfgsfloatval_t v; if (YAP_IsFloatTerm(t2)) { v=YAP_FloatOfTerm(t2); } else if (YAP_IsIntTerm(t2)) { v=(lbfgsfloatval_t) YAP_IntOfTerm(t2); } else { return FALSE; } param.xtol=v; } else if ((strcmp(name, "orthantwise_c") == 0)) { lbfgsfloatval_t v; if (YAP_IsFloatTerm(t2)) { v=YAP_FloatOfTerm(t2); } else if (YAP_IsIntTerm(t2)) { v=(lbfgsfloatval_t) YAP_IntOfTerm(t2); } else { return FALSE; } param.orthantwise_c=v; } else if ((strcmp(name, "orthantwise_start") == 0)) { if (! YAP_IsIntTerm(t2)) { return FALSE; } param.orthantwise_start = YAP_IntOfTerm(t2); } else if ((strcmp(name, "orthantwise_end") == 0)) { if (! YAP_IsIntTerm(t2)) { return FALSE; } param.orthantwise_end = YAP_IntOfTerm(t2); } else { printf("ERROR: The parameter %s is unknown.\n",name); return FALSE; } return TRUE; }