void getSearchSpaceRange(int dimensions, double **minSearchSpace, double **maxSearchSpace) { int i; int result; double dmin,dmax; PlTerm min,max; PlTerm args[3]; for( i=0; i<dimensions; i++){ Pl_Query_Begin(TRUE); min=Mk_Variable(); max=Mk_Variable(); args[0]=Mk_Integer(i); args[1]=min; args[2]=max; result=Pl_Query_Call(Find_Atom("fssbounds"),3,args); dmin=Rd_Float_Check(args[1]); dmax=Rd_Float_Check(args[2]); (*minSearchSpace)[i] = (double)dmin; (*maxSearchSpace)[i] = (double)dmax; if (debug == TRUE) { printf("dimension: %d :: dmin : %f dmax : %f\n",i,dmin,dmax); fflush(NULL); } Pl_Query_End(PL_RECOVER); } }
int aslAddBindingStatement( AsSystem s, AsMediaAddress m, AsNetworkAddress n, AsTime t ) { // Check if the logic layer is disabled if (aslDisableLogicFlag == 1) return 0; // Local variables PlTerm arg[10]; PlTerm arg2[10]; PlBool res; // Start processing, if needed if ( ! aslogic_initialized ) aslInitLogic(); // Do the GPC query Pl_Query_Begin(PL_TRUE); arg[0] = Pl_Mk_String(s); arg[1] = Pl_Mk_String(n); arg[2] = Pl_Mk_String(m); arg[3] = Pl_Mk_Integer(t); arg2[0] = Pl_Mk_Callable(gpc_func_dynamic_binding_statement_num, 4, arg); res = Pl_Query_Call(gpc_func_asserta_num, 1, arg2); Pl_Query_End(PL_KEEP_FOR_PROLOG); // Get output and process if (res != 1) { asLogMessage( "Prolog launch failed, aborting." ); exit( -1 ); } asLogMessage( "Binding statement added successfully (%s,%lu)", s, t ); // Return successfully return( 0 ); }
int is_feasible_Fitness(double const *x) { int i; int res = 1; int result; double dmin, dmax; PlTerm min, max; PlTerm args[3]; int DIM = (int) (x[-1]); for (i = 0; i < DIM; i++) { Pl_Query_Begin(TRUE); min = Mk_Variable(); max = Mk_Variable(); args[0] = Mk_Integer(i); args[1] = min; args[2] = max; result = Pl_Query_Call(Find_Atom("bounds"), 3, args); dmin = Rd_Float_Check(args[1]); dmax = Rd_Float_Check(args[2]); //printf("dmin : %f dmax : %f xi : %f\n",dmin,dmax,x[i]); if ((x[i] < dmin) || (x[i] > dmax)) res = 0; Pl_Query_End(PL_RECOVER); } return res; }
void set_random_paramsFss(int dim) { PlTerm args[1]; int result; Pl_Query_Begin(TRUE); args[0] = Mk_Integer(dim); result = Pl_Query_Call(Find_Atom("fss_restart"), 1, args); Pl_Query_End(PL_RECOVER); }
int aslFindValidNetworkBinding( AsNetworkAddress n, AsMediaAddress m, AsTime t ) { // Check if the logic layer is disabled if (aslDisableLogicFlag == 1) return 0; // Local variables int i; int sol_num = 0; PlTerm arg[10]; char *sol[GPC_MAX_SOLUTION_NUM]; PlBool res; // Start processing, if needed if ( ! aslogic_initialized ) aslInitLogic(); // Do the GPC query Pl_Query_Begin(PL_TRUE); arg[0] = Pl_Mk_Variable(); arg[1] = Pl_Mk_String(m); arg[2] = Pl_Mk_Integer(t); res = Pl_Query_Call(gpc_func_valid_binding_num, 3, arg); while (res) { sol[sol_num++] = Pl_Rd_String(arg[0]); res = Pl_Query_Next_Solution(); if (sol_num >= GPC_MAX_SOLUTION_NUM) { asLogMessage("Error: aslFindValidNetworkBinding got more than [%d] solutions - searching stopped", GPC_MAX_SOLUTION_NUM); break; } } Pl_Query_End(PL_KEEP_FOR_PROLOG); // Parse out the solutions asLogMessage("Info: aslFindValidNetworkBinding got [%d] solutions in total", sol_num); for (i = 0; i < sol_num; i++) { // Copy and remove trailing space strncpy( n, sol[i], MAX_NETADDR_LENGTH ); asLogMessage( "Find valid network binding successfully (%s,%lu)->[%s]", m, t, n ); // Return we found it - currently is the first solution we have found return( 1 ); } // Return successfully return( 0 ); }
/*-------------------------------------------------------------------------* * MAIN * * * * See comments in EnginePl/main.c about the use of the wrapper function. * *-------------------------------------------------------------------------*/ static int Main_Wrapper(int argc, char *argv[]) { int func; PlTerm arg[10]; char str[100]; char *sol[100]; int i, nb_sol = 0; PlBool res; Pl_Start_Prolog(argc, argv); func = Pl_Find_Atom("anc"); for (;;) { printf("\nEnter a name (or 'end' to finish): "); fflush(stdout); if (scanf("%s", str)) /* avoid gcc warning warn_unused_result */ ; if (strcmp(str, "end") == 0) break; Pl_Query_Begin(PL_TRUE); arg[0] = Pl_Mk_Variable(); arg[1] = Pl_Mk_String(str); nb_sol = 0; res = Pl_Query_Call(func, 2, arg); while (res) { sol[nb_sol++] = Pl_Rd_String(arg[0]); res = Pl_Query_Next_Solution(); } Pl_Query_End(PL_RECOVER); for (i = 0; i < nb_sol; i++) printf(" solution: %s\n", sol[i]); printf("%d solution(s)\n", nb_sol); } Pl_Stop_Prolog(); return 0; }
/*-------------------------------------------------------------------------* * MY_CALL * * * *-------------------------------------------------------------------------*/ PlBool my_call(PlTerm goal) { PlTerm *args; int functor, arity; int result; args = Pl_Rd_Callable_Check(goal, &functor, &arity); Pl_Query_Begin(PL_FALSE); result = Pl_Query_Call(functor, arity, args); Pl_Query_End(PL_KEEP_FOR_PROLOG); if (result == PL_EXCEPTION) { PlTerm except = Pl_Get_Exception(); Pl_Exec_Continuation(Pl_Find_Atom("throw"), 1, &except); } return result; }
/* ----------------------------------------------------------------------- */ double f_biochamFss(double const *x, int dimensions) { if (debug == TRUE) { printf("f_biochamFss\n"); /* positions:: %p\n", x);*/ fflush(NULL); } int i; double dist = 0.00001; int DIM = dimensions;//(int) (x[-1]); PlTerm plist[DIM]; PlTerm cost; PlTerm args[2]; int result; Pl_Query_Begin(TRUE); /*make vars */ cost = Mk_Variable(); for (i = 0; i < DIM; ++i) { if (debug == TRUE) { printf("f_biochamFss:: position values: %f \n",x[i]); fflush(NULL); } plist[i] = Mk_Float(x[i]); } args[0] = Mk_Proper_List(DIM, plist); args[1] = cost; result = Pl_Query_Call(Find_Atom("distance_fss"), 2, args); dist = Rd_Float_Check(args[1]); if (debug == TRUE) { printf("f_biochamFss:: dist is infinity: %d \n", ((dist == INFINITY || dist == -INFINITY)?1:0) ); printf("f_biochamFss:: dist: %f \n",dist); fflush(NULL); } Pl_Query_End(PL_RECOVER); return dist; }
/* ----------------------------------------------------------------------- */ double f_biocham_multiFss(double const *x, int dimensions) { int i; double dist = 0.; int DIM = dimensions;//(int) (x[-1]); PlTerm plist[DIM]; PlTerm cost; PlTerm args[2]; int result; Pl_Query_Begin(TRUE); /*make vars */ cost = Mk_Variable(); for (i = 0; i < DIM; ++i) { printf("f_biochamFssMulti:: position values: %f \n",x[i]); fflush(NULL); plist[i] = Mk_Float(x[i]); } args[0] = Mk_Proper_List(DIM, plist); args[1] = cost; printf("f_biochamFssMulti:: chamando a func multi \n"); fflush(NULL); result = Pl_Query_Call(Find_Atom("distance_fss_multi"), 2, args); printf("f_biochamFssMulti:: retornando da fun�‹o :: result %d\n", result); fflush(NULL); dist = Rd_Float_Check(args[1]); printf("f_biochamFssMulti:: dist: %f \n", dist); fflush(NULL); Pl_Query_End(PL_RECOVER); // printf("cdone\n"); return dist; }
/*-------------------------------------------------------------------------* * ALL_OP * * * *-------------------------------------------------------------------------*/ PlBool all_op(PlTerm list) { PlTerm op[1024]; PlTerm args[3]; int n = 0; int result; Pl_Query_Begin(PL_TRUE); args[0] = Pl_Mk_Variable(); args[1] = Pl_Mk_Variable(); args[2] = Pl_Mk_Variable(); result = Pl_Query_Call(Pl_Find_Atom("current_op"), 3, args); while (result) { op[n++] = Pl_Mk_Atom(Pl_Rd_Atom(args[2])); /* arg #2 is the name of the op */ result = Pl_Query_Next_Solution(); } Pl_Query_End(PL_RECOVER); return Pl_Un_Proper_List_Check(n, op, list); }
int aslSystemTrusted( AsSystem s, AsTime t ) { // Check if the logic layer is disabled if (aslDisableLogicFlag == 1) return 0; // Local variables PlTerm arg[10]; PlBool res; // Start processing, if needed if ( ! aslogic_initialized ) aslInitLogic(); // Do the GPC query Pl_Query_Begin(PL_TRUE); arg[0] = Pl_Mk_String(s); arg[1] = Pl_Mk_Integer(t); res = Pl_Query_Call(gpc_func_trusted_num, 2, arg); Pl_Query_End(PL_KEEP_FOR_PROLOG); // Just reture the res! return( res ); }
int simulFss(double const *x, int DIM) { int i; PlTerm plist[DIM]; PlTerm args[1]; int result; if (debug == TRUE) { printf("simulFSS:: graph plot \n"); fflush(NULL); } Pl_Query_Begin(TRUE); /*make vars */ for (i = 0; i < DIM; ++i) { plist[i] = Mk_Float(x[i]); } args[0] = Mk_Proper_List(DIM, plist); result = Pl_Query_Call(Find_Atom("simul_fss"), 1, args); Pl_Query_End(PL_RECOVER); return 1; }
static int Main_Wrapper(int argc, char *argv[]) { int func; PlTerm arg[3]; PlBool res; /*****************************************************************/ int not; int and; int or; int says; int implies; int colon; int geq; PlTerm plterm_0; PlTerm plterm_1[2]; PlTerm plterm_2; PlTerm plterm_3[2]; PlTerm plterm_4; PlTerm plterm_5[2]; PlTerm plterm_6; PlTerm plterm_7[2]; PlTerm plterm_8; PlTerm plterm_9[2]; PlTerm plterm_10; PlTerm plterm_11[2]; PlTerm plterm_12; PlTerm plterm_13; PlTerm plterm_14[2]; PlTerm plterm_15; PlTerm plterm_16; PlTerm plterm_17; PlTerm plterm_18[2]; PlTerm plterm_19; PlTerm plterm_20; PlTerm plterm_21; PlTerm plterm_22[2]; PlTerm plterm_23; PlTerm plterm_24[2]; PlTerm plterm_25; PlTerm plterm_26[2]; PlTerm plterm_27; PlTerm plterm_28; PlTerm plterm_29; PlTerm plterm_30; PlTerm plterm_31; PlTerm plterm_32[2]; PlTerm plterm_33; PlTerm plterm_34[2]; PlTerm plterm_35; PlTerm plterm_36; PlTerm plterm_37; PlTerm plterm_38[2]; PlTerm plterm_39; PlTerm plterm_40[2]; PlTerm plterm_41; PlTerm plterm_42; PlTerm plterm_43[2]; PlTerm plterm_44; PlTerm plterm_45; PlTerm plterm_46; PlTerm plterm_47; PlTerm plterm_48[2]; PlTerm plterm_49; PlTerm plterm_50; PlTerm plterm_51; /*****************************************************************/ Pl_Start_Prolog(argc, argv); func = Pl_Find_Atom("prove"); /*****************************************************************/ not = Pl_Find_Atom("~"); and = Pl_Find_Atom("and"); or = Pl_Find_Atom("or"); says = Pl_Find_Atom("says"); implies = Pl_Find_Atom("->"); colon = Pl_Find_Atom(":"); geq = Pl_Find_Atom(">="); /*****************************************************************/ Pl_Query_Begin(PL_TRUE); /*****************************************************************/ plterm_12 = Pl_Mk_String("a_1"); plterm_15 = Pl_Mk_String("suu_1"); plterm_16 = Pl_Mk_String("wpu_1"); plterm_14[0] = plterm_15; plterm_14[1] = plterm_16; plterm_13 = Pl_Mk_Compound(implies, 2, plterm_14); plterm_11[0] = plterm_12; plterm_11[1] = plterm_13; plterm_10 = Pl_Mk_Compound(says, 2, plterm_11); plterm_19 = Pl_Mk_String("a_2"); plterm_20 = Pl_Mk_String("suu_1"); plterm_18[0] = plterm_19; plterm_18[1] = plterm_20; plterm_17 = Pl_Mk_Compound(says, 2, plterm_18); plterm_9[0] = plterm_10; plterm_9[1] = plterm_17; plterm_8 = Pl_Mk_Compound(and, 2, plterm_9); plterm_27 = Pl_Mk_String("a_1"); plterm_28 = Pl_Mk_String("a_2"); plterm_26[0] = plterm_27; plterm_26[1] = plterm_28; plterm_25 = Pl_Mk_Compound(and, 2, plterm_26); plterm_29 = Pl_Mk_String("df_1"); plterm_24[0] = plterm_25; plterm_24[1] = plterm_29; plterm_23 = Pl_Mk_Compound(says, 2, plterm_24); plterm_30 = Pl_Mk_String("df_1"); plterm_22[0] = plterm_23; plterm_22[1] = plterm_30; plterm_21 = Pl_Mk_Compound(implies, 2, plterm_22); plterm_7[0] = plterm_8; plterm_7[1] = plterm_21; plterm_6 = Pl_Mk_Compound(and, 2, plterm_7); plterm_35 = Pl_Mk_String("a_1"); plterm_36 = Pl_Mk_String("a_2"); plterm_34[0] = plterm_35; plterm_34[1] = plterm_36; plterm_33 = Pl_Mk_Compound(and, 2, plterm_34); plterm_41 = Pl_Mk_String("wpu_1"); plterm_44 = Pl_Mk_String("u_1"); plterm_45 = Pl_Mk_String("df_1"); plterm_43[0] = plterm_44; plterm_43[1] = plterm_45; plterm_42 = Pl_Mk_Compound(says, 2, plterm_43); plterm_40[0] = plterm_41; plterm_40[1] = plterm_42; plterm_39 = Pl_Mk_Compound(and, 2, plterm_40); plterm_46 = Pl_Mk_String("df_1"); plterm_38[0] = plterm_39; plterm_38[1] = plterm_46; plterm_37 = Pl_Mk_Compound(implies, 2, plterm_38); plterm_32[0] = plterm_33; plterm_32[1] = plterm_37; plterm_31 = Pl_Mk_Compound(says, 2, plterm_32); plterm_5[0] = plterm_6; plterm_5[1] = plterm_31; plterm_4 = Pl_Mk_Compound(and, 2, plterm_5); plterm_49 = Pl_Mk_String("u_1"); plterm_50 = Pl_Mk_String("df_1"); plterm_48[0] = plterm_49; plterm_48[1] = plterm_50; plterm_47 = Pl_Mk_Compound(says, 2, plterm_48); plterm_3[0] = plterm_4; plterm_3[1] = plterm_47; plterm_2 = Pl_Mk_Compound(and, 2, plterm_3); plterm_51 = Pl_Mk_String("df_1"); plterm_1[0] = plterm_2; plterm_1[1] = plterm_51; plterm_0 = Pl_Mk_Compound(implies, 2, plterm_1); arg[0] = plterm_0; /*****************************************************************/ res = Pl_Query_Call(func, 1, arg); printf("Query:\n\t|- u : ((a_1 says (suu_1 -> wpu_1)) and (a_2 says suu_1) and (((a_1 and a_2) says df_1) -> df_1) and (a_1 and a_2 says ((wpu_1 and (u_1 says df_1)) -> df_1)) and (u_1 says df_1)) -> df_1\n%s.\n", res ? "true" : "false"); Pl_Query_End(PL_RECOVER); Pl_Stop_Prolog(); return 0; }