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)); }
void createExpression(array_t * expression, YAP_Term t) /* returns the expression as an array_t of terms (cubes) starting from the prolog lists of terms each term is an array_t of factors obtained from a prolog list of factors each factor is a couple (index of variable, index of value) obtained from a prolog list containing two integers */ { YAP_Term termTerm,factorTerm; factor f; int i,j; array_t * term; i=0; while(YAP_IsPairTerm(t)) { term=array_alloc(factor,0); termTerm=YAP_HeadOfTerm(t); j=0; while(YAP_IsPairTerm(termTerm)) { factorTerm=YAP_HeadOfTerm(termTerm); f.var=YAP_IntOfTerm(YAP_HeadOfTerm(factorTerm)); f.value=YAP_IntOfTerm(YAP_HeadOfTerm(YAP_TailOfTerm(factorTerm))); array_insert(factor,term,j,f); termTerm=YAP_TailOfTerm(termTerm); j++; } array_insert(array_t *,expression,i,term); t=YAP_TailOfTerm(t); i++; } }
static YAP_Bool init(void) { int j, i; YAP_Term arg1, arg2, list; ex = 0; cycle = 0; arg1 = YAP_ARG1; arg2 = YAP_ARG2; nRules = YAP_IntOfTerm(arg1); vars_ex = NULL; nVars_ex = NULL; eta = (double ***)malloc(nRules * sizeof(double **)); eta_temp = (double ***)malloc(nRules * sizeof(double **)); rules = (int *)malloc(nRules * sizeof(int)); arrayprob = (double **)malloc(nRules * sizeof(double *)); probs_ex = NULL; bVar2mVar_ex = NULL; boolVars_ex = NULL; mgr_ex = NULL; nodes_probs_ex = NULL; list = arg2; for (j = 0; j < nRules; j++) { rules[j] = YAP_IntOfTerm(YAP_HeadOfTerm(list)); list = YAP_TailOfTerm(list); eta[j] = (double **)malloc((rules[j] - 1) * sizeof(double *)); eta_temp[j] = (double **)malloc((rules[j] - 1) * sizeof(double *)); arrayprob[j] = (double *)malloc((rules[j] - 1) * sizeof(double)); for (i = 0; i < rules[j] - 1; i++) { eta[j][i] = (double *)malloc(2 * sizeof(double)); eta_temp[j][i] = (double *)malloc(2 * sizeof(double)); } } return 1; }
static YAP_Bool equality(void) { YAP_Term arg1, arg2, arg3, out; int varIndex; int value; int i; variable v; DdNode *node, *tmp, *var; arg1 = YAP_ARG1; arg2 = YAP_ARG2; arg3 = YAP_ARG3; varIndex = YAP_IntOfTerm(arg1); value = YAP_IntOfTerm(arg2); v = vars_ex[ex][varIndex]; i = v.firstBoolVar; tmp = Cudd_ReadOne(mgr_ex[ex]); Cudd_Ref(tmp); node = NULL; for (i = v.firstBoolVar; i < v.firstBoolVar + value; i++) { var = Cudd_bddIthVar(mgr_ex[ex], i); node = Cudd_bddAnd(mgr_ex[ex], tmp, Cudd_Not(var)); Cudd_Ref(node); Cudd_RecursiveDeref(mgr_ex[ex], tmp); tmp = node; } if (!(value == v.nVal - 1)) { var = Cudd_bddIthVar(mgr_ex[ex], v.firstBoolVar + value); node = Cudd_bddAnd(mgr_ex[ex], tmp, var); Cudd_Ref(node); Cudd_RecursiveDeref(mgr_ex[ex], tmp); } out = YAP_MkIntTerm((YAP_Int)node); return (YAP_Unify(out, arg3)); }
/** @pred optimizer_set_g(+I,+G) Set the current value for `g[I]` (the partial derivative of _F_ with respect to `x[I]`). Can only be called from the evaluate call back predicate. */ static int set_g_value(void) { YAP_Term t1=YAP_ARG1; YAP_Term t2=YAP_ARG2; int i=0; if (optimizer_status != OPTIMIZER_STATUS_CB_EVAL) { printf("ERROR: optimizer_set_g/2 can only be called by the evaluation call back function.\n"); return FALSE; } if (YAP_IsIntTerm(t1)) { i=YAP_IntOfTerm(t1); } else { return FALSE; } if (i<0 || i>=n) { return FALSE; } if (YAP_IsFloatTerm(t2)) { g[i]=(lbfgsfloatval_t) YAP_FloatOfTerm(t2); } else if (YAP_IsIntTerm(t2)) { g[i]=(lbfgsfloatval_t) YAP_IntOfTerm(t2); } else { return FALSE; } return TRUE; }
/* * Blocking communication function. The message is sent immediatly. * mpi_send(+Data, +Destination, +Tag). */ static YAP_Bool mpi_send(term_t YAP_ARG1,...) { YAP_Term t1 = YAP_Deref(YAP_ARG1), t2 = YAP_Deref(YAP_ARG2), t3 = YAP_Deref(YAP_ARG3); char *str=NULL; int dest,tag; size_t len=0; int val; if (YAP_IsVarTerm(t1) || !YAP_IsIntTerm(t2) || !YAP_IsIntTerm(t3)) { return false; } CONT_TIMER(); // dest = YAP_IntOfTerm(t2); tag = YAP_IntOfTerm(t3); // the data is packaged as a string str=term2string(NULL,&len,t1); #if defined(DEBUG) && 0 write_msg(__FUNCTION__,__FILE__,__LINE__,"%s(%s,%u, MPI_CHAR,%d,%d)\n",__FUNCTION__,str,len,dest,tag); #endif // send the data val=(MPI_CALL(MPI_Send( str, len, MPI_CHAR, dest, tag, MPI_COMM_WORLD))==MPI_SUCCESS?true:false); PAUSE_TIMER(); return(val); }
static int p_rl_b_in1(void) { YAP_Term t1=YAP_Deref(YAP_ARG1); YAP_Term t2=YAP_Deref(YAP_ARG2); IDTYPE id; NUM val; RL_Tree *tree; // Check args if (!YAP_IsIntTerm(t1)) { YAP_cut_fail(); return(FALSE); } if ( YAP_IsVarTerm(t2) ) { // return all in through backtracking YAP_PRESERVE_DATA(back_data,yap_back_data_type); back_data->last_solution = YAP_MkIntTerm(0); return p_rl_b_in2(); } else { id = YAP_IntOfTerm(t1); tree=ID2PTR(id); val = YAP_IntOfTerm(t2); if ( in_rl(tree,val) ) { YAP_cut_succeed(); return (TRUE); } YAP_cut_fail(); return (FALSE); } }
/** @pred optimizer_set_x(+I,+X) Set the current value for `x[I]`. Only possible when the optimizer is initialized but not running. */ static int set_x_value(void) { YAP_Term t1=YAP_ARG1; YAP_Term t2=YAP_ARG2; int i=0; if (optimizer_status!=OPTIMIZER_STATUS_INITIALIZED) { printf("ERROR: set_x_value/2 can be called only when the optimizer is initialized and not running.\n"); return FALSE; } if (YAP_IsIntTerm(t1)) { i=YAP_IntOfTerm(t1); } else { return FALSE; } if (i<0 || i>=n) { printf("ERROR: invalid index for set_x_value/2.\n"); return FALSE; } if (YAP_IsFloatTerm(t2)) { x[i]=(lbfgsfloatval_t) YAP_FloatOfTerm(t2); } else if (YAP_IsIntTerm(t2)) { x[i]=(lbfgsfloatval_t) YAP_IntOfTerm(t2); } else { return FALSE; } return TRUE; }
static int p_rl_set_out(void) { YAP_Term t1=YAP_Deref(YAP_ARG1); YAP_Term t2=YAP_Deref(YAP_ARG2); IDTYPE id; NUM val; RL_Tree *tree; // Check args if (YAP_IsVarTerm(t1) || YAP_IsVarTerm(t2) ) return(FALSE); id = YAP_IntOfTerm(t1); val = YAP_IntOfTerm(t2); tree=ID2PTR(id); #ifdef STATS STORE_TREE_SIZE(tree); set_in_rl(tree,val,OUT); UPDATE_MEM_USAGE(tree); #else set_in_rl(tree,val,OUT); #endif return (TRUE); }
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)); } }
void setQuery(YAP_Term t1, int32_t **res) { int32_t *query = (int32_t *)malloc(MAXARG * sizeof(int32_t)); int32_t x, y = 0, *itr; predicate *ptr = NULL; if(YAP_IsPairTerm(t1)) { while(YAP_IsPairTerm(t1)) { ptr = (predicate *)YAP_IntOfTerm(YAP_HeadOfTerm(t1)); query[y] = ptr->name; itr = ptr->address_host_table; x = 2; while(itr[x] != 0) x++; query[y+1] = itr[x+1]; t1 = YAP_TailOfTerm(t1); y+=2; } } else { ptr = (predicate *)YAP_IntOfTerm(t1); query[y] = ptr->name; itr = ptr->address_host_table; x = 2; while(itr[x] != 0) x++; query[y+1] = itr[x+1]; y += 2; } query[y] = -1; query[y+1] = -1; *res = query; }
static int p_setrand(void) { a1 = YAP_IntOfTerm(YAP_ARG1); b1 = YAP_IntOfTerm(YAP_ARG2); c1 = YAP_IntOfTerm(YAP_ARG3); return(TRUE); }
/* * Broadcasts a message from the process with rank "root" to * all other processes of the group. * mpi_ibcast(+Root,+Data,+Tag). */ static YAP_Bool my_ibcast(YAP_Term t1,YAP_Term t2, YAP_Term t3) { int root; int k,worldsize; size_t len=0; char *str; int tag; BroadcastRequest *b; //fprintf(stderr,"ibcast1"); //The arguments should be bound if(YAP_IsVarTerm(t2) || !YAP_IsIntTerm(t1) || !YAP_IsIntTerm(t3)) { return false; } CONT_TIMER(); // fprintf(stderr,"ibcast2"); MPI_CALL(MPI_Comm_size(MPI_COMM_WORLD,&worldsize)); root = YAP_IntOfTerm(t1); tag = YAP_IntOfTerm(t3); str = term2string(NULL,&len,t2); b=new_broadcast(); if ( b==NULL ) { PAUSE_TIMER(); return false; } //fprintf(stderr,"ibcast3"); for(k=0;k<=worldsize-1;++k) { if(k!=root) { MPI_Request *handle=(MPI_Request*)malloc(sizeof(MPI_Request)); MSG_SENT(len); // Use async send if(MPI_CALL(MPI_Isend(str, len, MPI_CHAR, k, tag, MPI_COMM_WORLD,handle))!=MPI_SUCCESS) { free(handle); PAUSE_TIMER(); return false; } new_broadcast_request(b,handle,str); //new_request(handle,str); USED_BUFFER(); } } if(!b->nreq)//release b if no messages were sent (worldsize==1) free(b); #if defined(DEBUG) && defined(MALLINFO) { struct mallinfo s = mallinfo(); printf("%d: %d=%d/%d\n",getpid(),s.arena,s.uordblks,s.fordblks); //vsc } #endif PAUSE_TIMER(); //fprintf(stderr,"ibcast4"); return true; }
static int p_item2(void) { YAP_Term titem; int x = YAP_IntOfTerm(YAP_ARG2); int y = YAP_IntOfTerm(YAP_ARG3); titem = YAP_ARG4; return item2(YAP_ARG1,titem,x,y); }
static int p_item2_1(void) { YAP_Term titem; int offx = YAP_IntOfTerm(YAP_ARG2)-1; int offy = YAP_IntOfTerm(YAP_ARG3)-1; titem = YAP_ARG4; return item2(YAP_ARG1,titem,offx,offy); }
static int p_trie_join(void) { /* check args */ if (!YAP_IsIntTerm(arg_trie_dest)) return FALSE; if (!YAP_IsIntTerm(arg_trie_source)) return FALSE; /* join trie */ trie_join((TrEntry) YAP_IntOfTerm(arg_trie_dest), (TrEntry) YAP_IntOfTerm(arg_trie_source)); return TRUE; }
static int p_itrie_intersect(void) { /* check args */ if (!YAP_IsIntTerm(arg_itrie_dest)) return FALSE; if (!YAP_IsIntTerm(arg_itrie_source)) return FALSE; /* intersect itrie */ itrie_intersect((TrEntry) YAP_IntOfTerm(arg_itrie_dest), (TrEntry) YAP_IntOfTerm(arg_itrie_source)); return TRUE; }
static int item2(YAP_Term tvar, YAP_Term titem, int offx, int offy) { mxArray *mat; int rows; int cols; int off; mat = get_array(tvar); rows = mxGetM(mat); cols = mxGetN(mat); off = MAT_ACCESS(offx,offy,rows,cols); if (!mat) return FALSE; if (mxIsInt32(mat)) { INT32_T *input = (INT32_T *)mxGetPr(mat); if (YAP_IsIntTerm(titem)) { input[off] = YAP_IntOfTerm(titem); } else if (YAP_IsFloatTerm(titem)) { input[off] = YAP_FloatOfTerm(titem); } else if (YAP_IsVarTerm(titem)) { return YAP_Unify(titem, YAP_MkIntTerm(input[off])); } else return FALSE; } else if (mxIsInt64(mat)) { INT64_T *input = (INT64_T *)mxGetPr(mat); if (YAP_IsIntTerm(titem)) { input[off] = YAP_IntOfTerm(titem); } else if (YAP_IsFloatTerm(titem)) { input[off] = YAP_FloatOfTerm(titem); } else if (YAP_IsVarTerm(titem)) { return YAP_Unify(titem, YAP_MkIntTerm(input[off])); } else return FALSE; } else if (mxIsCell(mat)) { if (YAP_IsVarTerm(titem)) { return YAP_Unify(titem, YAP_MkIntTerm((YAP_Int)mxGetCell(mat,off))); } else { mxArray *mat2 = get_array(titem); mxSetCell(mat,off, mat2); } } else if (mxIsDouble(mat)) { double *input = mxGetPr(mat); if (YAP_IsFloatTerm(titem)) { input[off] = YAP_FloatOfTerm(titem); } else if (YAP_IsIntTerm(titem)) { input[off] = YAP_IntOfTerm(titem); } else { return YAP_Unify(titem, YAP_MkFloatTerm(input[off])); } } else return FALSE; return cp_back(tvar, mat); }
static int p_trie_count_join(void) { YAP_Int entries; /* check args */ if (!YAP_IsIntTerm(arg_trie1)) return FALSE; if (!YAP_IsIntTerm(arg_trie2)) return FALSE; /* count join trie */ entries = trie_count_join((TrEntry) YAP_IntOfTerm(arg_trie1), (TrEntry) YAP_IntOfTerm(arg_trie2)); return YAP_Unify(arg_entries, YAP_MkIntTerm(entries)); }
static int p_itrie_count_intersect(void) { YAP_Int entries; /* check args */ if (!YAP_IsIntTerm(arg_itrie1)) return FALSE; if (!YAP_IsIntTerm(arg_itrie2)) return FALSE; /* count intersect itrie */ entries = itrie_count_intersect((TrEntry) YAP_IntOfTerm(arg_itrie1), (TrEntry) YAP_IntOfTerm(arg_itrie2)); return YAP_Unify(arg_entries, YAP_MkIntTerm(entries)); }
static YAP_Bool or (void) { YAP_Term arg1, arg2, arg3, out; DdNode *node1, *node2, *nodeout; arg1 = YAP_ARG1; arg2 = YAP_ARG2; arg3 = YAP_ARG3; node1 = (DdNode *)YAP_IntOfTerm(arg1); node2 = (DdNode *)YAP_IntOfTerm(arg2); nodeout = Cudd_bddOr(mgr_ex[ex], node1, node2); Cudd_Ref(nodeout); out = YAP_MkIntTerm((YAP_Int)nodeout); return (YAP_Unify(out, arg3)); }
void createVars(array_t * vars, YAP_Term t,DdManager * mgr, array_t * bVar2mVar,int create_dot, char inames[1000][20]) /* adds the boolean variables to the BDD and returns an array_t containing them (array_t is defined in the util library of glu) returns also the names of the variables to be used to save the ADD in dot format */ { YAP_Term varTerm,probTerm; int varIndex,nVal,i,b; variable v; char numberVar[10],numberBit[10]; double p; b=0; while(YAP_IsPairTerm(t)) { varTerm=YAP_HeadOfTerm(t); varIndex=YAP_IntOfTerm(YAP_HeadOfTerm(varTerm)); varTerm=YAP_TailOfTerm(varTerm); nVal=YAP_IntOfTerm(YAP_HeadOfTerm(varTerm)); varTerm=YAP_TailOfTerm(varTerm); probTerm=YAP_HeadOfTerm(varTerm); v.nVal=nVal; v.nBit=(int)ceil(log(nVal)/log(2)); v.probabilities=array_alloc(double,0); v.booleanVars=array_alloc(DdNode *,0); for (i=0;i<nVal;i++) { if (create_dot) { strcpy(inames[b+i],"X"); sprintf(numberVar,"%d",varIndex); strcat(inames[b+i],numberVar); strcat(inames[b+i],"_"); sprintf(numberBit,"%d",i); strcat(inames[b+i],numberBit); } p=YAP_FloatOfTerm(YAP_HeadOfTerm(probTerm)); array_insert(double,v.probabilities,i,p); probTerm=YAP_TailOfTerm(probTerm); array_insert(DdNode *,v.booleanVars,i,Cudd_bddIthVar(mgr,b+i)); array_insert(int,bVar2mVar,b+i,varIndex); } Cudd_MakeTreeNode(mgr,b,nVal,MTR_FIXED); b=b+nVal; array_insert(variable,vars,varIndex,v); t=YAP_TailOfTerm(t); } }
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 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; }
/* return YAP's environment */ static YAP_Bool p_environ(void) { #if HAVE_ENVIRON && 0 #if HAVE__NSGETENVIRON char **ptr = _NSGetEnviron(); #elif defined(__MINGW32__) || _MSC_VER extern char **_environ; char **ptr = _environ; #else extern char **environ; char **ptr = environ; #endif YAP_Term t1 = YAP_ARG1; long int i; i = YAP_IntOfTerm(t1); if (ptr[i] == NULL) return (FALSE); else { YAP_Term t = YAP_BufferToString(ptr[i]); return (YAP_Unify(t, YAP_ARG2)); } #else YAP_Error(0, 0L, "environ not available in this configuration"); return (FALSE); #endif }
/** mpi_wait(+Handle,-Status,-Data * * Completes a non-blocking operation. IF the operation was a send, the * function waits until the message is buffered or sent by the runtime * system. At this point the send buffer is released. If the operation * was a receive, it waits until the message is copied to the receive * buffer. * . */ static YAP_Bool mpi_wait_recv(term_t YAP_ARG1,...) { YAP_Term t1 = YAP_Deref(YAP_ARG1); // data MPI_Status status; MPI_Request *handle; char *s; int ret; size_t len; YAP_Term out; // The first argument (handle) must be an integer if(!YAP_IsIntTerm(t1)) { return false; } CONT_TIMER(); handle=INT2HANDLE(YAP_IntOfTerm(t1)); s=(char*)get_request(handle); // wait for communication completion if( MPI_CALL(MPI_Wait( handle , &status )) != MPI_SUCCESS) { PAUSE_TIMER(); return false; } len=YAP_SizeOfExportedTerm(s); // make sure we only fetch ARG3 after constructing the term out = string2term(s,(size_t*)&len); MSG_RECV(len); free_request(handle); PAUSE_TIMER(); ret=YAP_Unify(YAP_ARG3,out); return(ret & YAP_Unify(YAP_ARG2,YAP_MkIntTerm(status.MPI_ERROR))); }
/* * mpi_test(+Handle,-Status) * * Provides information regarding a handle, ie. if a communication operation has been completed. * If the operation has been completed the predicate succeeds with the completion status, * otherwise it fails. * ). */ static YAP_Bool mpi_test(term_t YAP_ARG1,...) { YAP_Term t1 = YAP_Deref(YAP_ARG1), // Handle t2 = YAP_Deref(YAP_ARG2); // Status MPI_Status status; MPI_Request *handle; int flag; // The first argument (handle) must be an integer if(!YAP_IsIntTerm(t1)) { return false; } CONT_TIMER(); handle=INT2HANDLE(YAP_IntOfTerm(t1)); // MPI_CALL(MPI_Test( handle , &flag, &status )); if( flag != true ) { PAUSE_TIMER(); return false; } free_request(handle); PAUSE_TIMER(); return(YAP_Unify(t2,YAP_MkIntTerm(status.MPI_ERROR))); }
static YAP_Bool init_test(void) { YAP_Term arg1; arg1 = YAP_ARG1; nRules = YAP_IntOfTerm(arg1); ex = 0; mgr_ex = (DdManager **)malloc((ex + 1) * sizeof(DdManager *)); mgr_ex[ex] = Cudd_Init(0, 0, UNIQUE_SLOTS, CACHE_SLOTS, 5120); Cudd_AutodynEnable(mgr_ex[ex], CUDD_REORDER_GROUP_SIFT); Cudd_SetMaxCacheHard(mgr_ex[ex], 0); Cudd_SetLooseUpTo(mgr_ex[ex], 0); Cudd_SetMinHit(mgr_ex[ex], 15); bVar2mVar_ex = (int **)malloc((ex + 1) * sizeof(int *)); bVar2mVar_ex[ex] = NULL; vars_ex = (variable **)malloc((ex + 1) * sizeof(variable *)); vars_ex[ex] = NULL; nVars_ex = (int *)malloc((ex + 1) * sizeof(int)); nVars_ex[ex] = 0; probs_ex = (double **)malloc((ex + 1) * sizeof(double *)); probs_ex[ex] = NULL; boolVars_ex = (int *)malloc((ex + 1) * sizeof(int)); boolVars_ex[ex] = 0; rules = (int *)malloc(nRules * sizeof(int)); return 1; }
static int p_create_double_array3(void) { mwSize dims[3]; mxArray *mat; dims[0] = YAP_IntOfTerm(YAP_ARG1); dims[1] = YAP_IntOfTerm(YAP_ARG2); dims[2] = YAP_IntOfTerm(YAP_ARG3); if (!(mat = mxCreateNumericArray(3, dims, mxDOUBLE_CLASS, mxREAL))) return FALSE; if (YAP_IsAtomTerm(YAP_ARG3)) { return !engPutVariable(Meng, YAP_AtomName(YAP_AtomOfTerm(YAP_ARG4)), mat); } return YAP_Unify(YAP_ARG3,address2term(mat)); }
static int p_set_int(void) { int rows, cols, i, j; YAP_Int *input; mxArray *mat; mat = matlab_getvar(YAP_ARG1); i = YAP_IntOfTerm(YAP_ARG2); j = YAP_IntOfTerm(YAP_ARG3); input = (YAP_Int *)mxGetPr(mat); rows = mxGetM(mat); cols = mxGetN(mat); input[MAT_ACCESS(i-1,j-1,rows,cols)] = YAP_IntOfTerm(YAP_ARG4); return TRUE; }