// -*- c++ -*- //============================================================================= // Copyright (C) 2011 by Denys Duchier // // This program is free software: you can redistribute it and/or modify it // under the terms of the GNU Lesser General Public License as published by the // Free Software Foundation, either version 3 of the License, or (at your // option) any later version. // // This program is distributed in the hope that it will be useful, but WITHOUT // ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or // FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for // more details. // // You should have received a copy of the GNU Lesser General Public License // along with this program. If not, see . //============================================================================= #include "gecode4-common.icc" #include using namespace std; using namespace generic_gecode; using namespace Gecode; extern "C" { void gecode_init(void); #include "config.h" } namespace generic_gecode { #ifndef HAVE_DYNARRAY template struct DynArray { T* _array; DynArray(int n): _array(new T[n]) {} ~DynArray() { delete[] _array; } T& operator[](int i) { return _array[i]; } }; #define DYNARRAY(T,A,N) DynArray A(N) #else #define DYNARRAY(T,A,N) T A[N] #endif #ifndef HAVE_DYNARRAY struct SpecArray { int (*_array)[2]; SpecArray(int n): _array((int (*)[2]) new int[n*2]) {} ~SpecArray() { delete[] _array; } int& operator()(int i,int j) { return _array[i][j]; } }; #define SPECARRAY(A,N) SpecArray A(N) #define SPECARRAYELEM(A,I,J) A(I,J) #define SPECARRAYDEREF(A) A._array #else #define SPECARRAY(A,N) int A[N][2] #define SPECARRAYELEM(A,I,J) A[I][J] #define SPECARRAYDEREF(A) A #endif } extern "C" { #include "YapInterface.h" static YAP_opaque_tag_t gecode_space_tag; static YAP_opaque_handler_t gecode_space_handler; static YAP_Bool gecode_space_fail_handler(void* p) { delete *(GenericSpace**)p; return TRUE; } static YAP_Bool gecode_space_write_handler (FILE *stream, YAP_opaque_tag_t type, void *p, int flags) { fprintf(stream,"", p); return TRUE; } static YAP_Term gecode_term_from_space(GenericSpace* s) { YAP_Term term = YAP_NewOpaqueObject(gecode_space_tag, sizeof(GenericSpace*)); GenericSpace** ptr = (GenericSpace**) YAP_OpaqueObjectFromTerm(term); *ptr = s; return term; } static YAP_Bool gecode_new_space(void) { YAP_Term term = gecode_term_from_space(new GenericSpace); return YAP_Unify(YAP_ARG1, term); } #ifndef DISJUNCTOR static inline GenericSpace* gecode_Space_from_term(YAP_Term t) { return * (GenericSpace**) YAP_OpaqueObjectFromTerm(t); } #else struct YapDisjunctor { GenericSpace* home; Disjunctor disj; YapDisjunctor(GenericSpace* home_) : home(home_), disj(*home_) {} }; static YAP_opaque_tag_t gecode_disjunctor_tag; static YAP_opaque_handler_t gecode_disjunctor_handler; static YAP_opaque_tag_t gecode_disjunctor_clause_tag; static YAP_opaque_handler_t gecode_disjunctor_clause_handler; static inline Disjunctor& gecode_Disjunctor_from_term(YAP_Term t) { return ((YapDisjunctor*) YAP_OpaqueObjectFromTerm(t))->disj; } static inline YapDisjunctor& gecode_YapDisjunctor_from_term(YAP_Term t) { return * (YapDisjunctor*) YAP_OpaqueObjectFromTerm(t); } static inline Clause& gecode_Clause_from_term(YAP_Term t) { return * (Clause*) YAP_OpaqueObjectFromTerm(t); } static inline GenericSpace* gecode_Space_from_term(YAP_Term t) { if (YAP_IsOpaqueObjectTerm(t, gecode_disjunctor_clause_tag)) { Clause& c = gecode_Clause_from_term(t); return & (GenericSpace&) c; } return * (GenericSpace**) YAP_OpaqueObjectFromTerm(t); } #endif static inline FloatAssign& gecode_FloatAssign_from_term(YAP_Term t) { return * (FloatAssign*) YAP_OpaqueObjectFromTerm(t); } static inline IntAssign& gecode_IntAssign_from_term(YAP_Term t) { return * (IntAssign*) YAP_OpaqueObjectFromTerm(t); } static inline SetAssign& gecode_SetAssign_from_term(YAP_Term t) { return * (SetAssign*) YAP_OpaqueObjectFromTerm(t); } static inline TupleSet& gecode_TupleSet_from_term(YAP_Term t) { return *(TupleSet *) YAP_OpaqueObjectFromTerm(t); } static inline DFA& gecode_DFA_from_term(YAP_Term t) { return *(DFA *) YAP_OpaqueObjectFromTerm(t); } static inline FloatNum gecode_FloatNum_from_term(YAP_Term t) { return (FloatNum) YAP_FloatOfTerm(t); } static YAP_Term gecode_SET_VAR_NONE; static YAP_Term gecode_SET_VAR_DEGREE_MIN; static YAP_Term gecode_SET_VAR_DEGREE_MAX; static YAP_Term gecode_SET_VAR_MIN_MIN; static YAP_Term gecode_SET_VAR_MIN_MAX; static YAP_Term gecode_SET_VAR_MAX_MIN; static YAP_Term gecode_SET_VAR_MAX_MAX; static YAP_Term gecode_SET_VAR_SIZE_MIN; static YAP_Term gecode_SET_VAR_SIZE_MAX; static YAP_Term gecode_SET_VAR_DEGREE_SIZE_MIN; static YAP_Term gecode_SET_VAR_DEGREE_SIZE_MAX; static inline SetVarBranch gecode_SetVarBranch_from_term(YAP_Term t) { if (YAP_IsAtomTerm(t)) { if ( t == gecode_SET_VAR_SIZE_MIN) return SET_VAR_SIZE_MIN(); if ( t == gecode_SET_VAR_SIZE_MAX) return SET_VAR_SIZE_MAX(); if ( t == gecode_SET_VAR_NONE) return SET_VAR_NONE(); if ( t == gecode_SET_VAR_DEGREE_MIN) return SET_VAR_DEGREE_MIN(); if ( t == gecode_SET_VAR_DEGREE_MAX) return SET_VAR_DEGREE_MAX(); if ( t == gecode_SET_VAR_MIN_MIN) return SET_VAR_MIN_MIN(); if ( t == gecode_SET_VAR_MIN_MAX) return SET_VAR_MIN_MAX(); if ( t == gecode_SET_VAR_MAX_MIN) return SET_VAR_MAX_MIN(); if ( t == gecode_SET_VAR_MAX_MAX) return SET_VAR_MAX_MAX(); if ( t == gecode_SET_VAR_DEGREE_SIZE_MIN) return SET_VAR_DEGREE_SIZE_MIN(); if ( t == gecode_SET_VAR_DEGREE_SIZE_MAX) return SET_VAR_DEGREE_SIZE_MAX(); } cerr << "unsupported SET VAR" << endl; exit(1); } static YAP_Term gecode_SET_VAL_MIN_INC; static YAP_Term gecode_SET_VAL_MIN_EXC; static YAP_Term gecode_SET_VAL_MED_INC; static YAP_Term gecode_SET_VAL_MED_EXC; static YAP_Term gecode_SET_VAL_MAX_INC; static YAP_Term gecode_SET_VAL_MAX_EXC; static inline SetValBranch gecode_SetValBranch_from_term(YAP_Term t) { if (YAP_IsAtomTerm(t)) { if ( t == gecode_SET_VAL_MIN_INC) return SET_VAL_MIN_INC(); if ( t == gecode_SET_VAL_MIN_EXC) return SET_VAL_MIN_EXC(); if ( t == gecode_SET_VAL_MED_INC) return SET_VAL_MED_INC(); if ( t == gecode_SET_VAL_MED_EXC) return SET_VAL_MED_EXC(); if ( t == gecode_SET_VAL_MAX_INC) return SET_VAL_MAX_INC(); if ( t == gecode_SET_VAL_MAX_EXC) return SET_VAL_MAX_EXC(); } cerr << "unsupported INT VAL" << endl; exit(1); } static inline SetBranchFilter& gecode_SetBranchFilter_from_term(YAP_Term t) { return * (SetBranchFilter*) YAP_OpaqueObjectFromTerm(t); } static YAP_Term gecode_INT_VAR_NONE; static YAP_Term gecode_INT_VAR_DEGREE_MIN; static YAP_Term gecode_INT_VAR_DEGREE_MAX; static YAP_Term gecode_INT_VAR_MIN_MIN; static YAP_Term gecode_INT_VAR_MIN_MAX; static YAP_Term gecode_INT_VAR_MAX_MIN; static YAP_Term gecode_INT_VAR_MAX_MAX; static YAP_Term gecode_INT_VAR_SIZE_MIN; static YAP_Term gecode_INT_VAR_SIZE_MAX; static YAP_Term gecode_INT_VAR_DEGREE_SIZE_MIN; static YAP_Term gecode_INT_VAR_DEGREE_SIZE_MAX; static YAP_Term gecode_INT_VAR_REGRET_MIN_MIN; static YAP_Term gecode_INT_VAR_REGRET_MIN_MAX; static YAP_Term gecode_INT_VAR_REGRET_MAX_MIN; static YAP_Term gecode_INT_VAR_REGRET_MAX_MAX; static inline IntVarBranch gecode_IntVarBranch_from_term(YAP_Term t) { if (YAP_IsAtomTerm(t)) { if ( t == gecode_INT_VAR_SIZE_MIN) return INT_VAR_SIZE_MIN(); if ( t == gecode_INT_VAR_SIZE_MAX) return INT_VAR_SIZE_MAX(); if ( t == gecode_INT_VAR_NONE) return INT_VAR_NONE(); if ( t == gecode_INT_VAR_DEGREE_MIN) return INT_VAR_DEGREE_MIN(); if ( t == gecode_INT_VAR_DEGREE_MAX) return INT_VAR_DEGREE_MAX(); if ( t == gecode_INT_VAR_MIN_MIN) return INT_VAR_MIN_MIN(); if ( t == gecode_INT_VAR_MIN_MAX) return INT_VAR_MIN_MAX(); if ( t == gecode_INT_VAR_MAX_MIN) return INT_VAR_MAX_MIN(); if ( t == gecode_INT_VAR_MAX_MAX) return INT_VAR_MAX_MAX(); if ( t == gecode_INT_VAR_DEGREE_SIZE_MIN) return INT_VAR_DEGREE_SIZE_MIN(); if ( t == gecode_INT_VAR_DEGREE_SIZE_MAX) return INT_VAR_DEGREE_SIZE_MAX(); if ( t == gecode_INT_VAR_REGRET_MIN_MIN) return INT_VAR_REGRET_MIN_MIN(); if ( t == gecode_INT_VAR_REGRET_MIN_MAX) return INT_VAR_REGRET_MIN_MAX(); if ( t == gecode_INT_VAR_REGRET_MAX_MIN) return INT_VAR_REGRET_MAX_MIN(); if ( t == gecode_INT_VAR_REGRET_MAX_MAX) return INT_VAR_REGRET_MAX_MAX(); } cerr << "unsupported INT VAR" << endl; exit(1); } static YAP_Term gecode_FLOAT_VAR_NONE; static YAP_Term gecode_FLOAT_VAR_DEGREE_MIN; static YAP_Term gecode_FLOAT_VAR_DEGREE_MAX; static YAP_Term gecode_FLOAT_VAR_MIN_MIN; static YAP_Term gecode_FLOAT_VAR_MIN_MAX; static YAP_Term gecode_FLOAT_VAR_MAX_MIN; static YAP_Term gecode_FLOAT_VAR_MAX_MAX; static YAP_Term gecode_FLOAT_VAR_SIZE_MIN; static YAP_Term gecode_FLOAT_VAR_SIZE_MAX; static YAP_Term gecode_FLOAT_VAR_DEGREE_SIZE_MIN; static YAP_Term gecode_FLOAT_VAR_DEGREE_SIZE_MAX; static inline FloatVarBranch gecode_FloatVarBranch_from_term(YAP_Term t) { if (YAP_IsAtomTerm(t)) { if ( t == gecode_FLOAT_VAR_SIZE_MIN) return FLOAT_VAR_SIZE_MIN(); if ( t == gecode_FLOAT_VAR_SIZE_MAX) return FLOAT_VAR_SIZE_MAX(); if ( t == gecode_FLOAT_VAR_NONE) return FLOAT_VAR_NONE(); if ( t == gecode_FLOAT_VAR_DEGREE_MIN) return FLOAT_VAR_DEGREE_MIN(); if ( t == gecode_FLOAT_VAR_DEGREE_MAX) return FLOAT_VAR_DEGREE_MAX(); if ( t == gecode_FLOAT_VAR_MIN_MIN) return FLOAT_VAR_MIN_MIN(); if ( t == gecode_FLOAT_VAR_MIN_MAX) return FLOAT_VAR_MIN_MAX(); if ( t == gecode_FLOAT_VAR_MAX_MIN) return FLOAT_VAR_MAX_MIN(); if ( t == gecode_FLOAT_VAR_MAX_MAX) return FLOAT_VAR_MAX_MAX(); if ( t == gecode_FLOAT_VAR_DEGREE_SIZE_MIN) return FLOAT_VAR_DEGREE_SIZE_MIN(); if ( t == gecode_FLOAT_VAR_DEGREE_SIZE_MAX) return FLOAT_VAR_DEGREE_SIZE_MAX(); } cerr << "unsupported FLOAT VAR" << endl; exit(1); } static YAP_Term gecode_INT_VAL_MIN; static YAP_Term gecode_INT_VAL_MED; static YAP_Term gecode_INT_VAL_MAX; static YAP_Term gecode_INT_VAL_SPLIT_MIN; static YAP_Term gecode_INT_VAL_SPLIT_MAX; static YAP_Term gecode_INT_VAL_RANGE_MIN; static YAP_Term gecode_INT_VAL_RANGE_MAX; static YAP_Term gecode_INT_VALUES_MIN; static YAP_Term gecode_INT_VALUES_MAX; static inline IntValBranch gecode_IntValBranch_from_term(YAP_Term t) { if (YAP_IsAtomTerm(t)) { if ( t == gecode_INT_VAL_MIN) return INT_VAL_MIN(); if ( t == gecode_INT_VAL_MED) return INT_VAL_MED(); if ( t == gecode_INT_VAL_MAX) return INT_VAL_MAX(); if ( t == gecode_INT_VAL_SPLIT_MIN) return INT_VAL_SPLIT_MIN(); if ( t == gecode_INT_VAL_SPLIT_MAX) return INT_VAL_SPLIT_MAX(); if ( t == gecode_INT_VAL_RANGE_MIN) return INT_VAL_RANGE_MIN(); if ( t == gecode_INT_VAL_RANGE_MAX) return INT_VAL_RANGE_MAX(); if ( t == gecode_INT_VALUES_MIN) return INT_VALUES_MIN(); if ( t == gecode_INT_VALUES_MAX) return INT_VALUES_MAX(); } cerr << "unsupported INT VAL" << endl; exit(1); } static YAP_Term gecode_FLOAT_VAL_SPLIT_MIN; static YAP_Term gecode_FLOAT_VAL_SPLIT_MAX; static inline FloatValBranch gecode_FloatValBranch_from_term(YAP_Term t) { if (YAP_IsAtomTerm(t)) { if ( t == gecode_FLOAT_VAL_SPLIT_MIN) return FLOAT_VAL_SPLIT_MIN(); if ( t == gecode_FLOAT_VAL_SPLIT_MAX) return FLOAT_VAL_SPLIT_MAX(); } cerr << "unsupported FLOAT VAL" << endl; exit(1); } static inline FloatVal& gecode_FloatVal_from_term(YAP_Term t) { return * (FloatVal*) YAP_OpaqueObjectFromTerm(t); } static inline Symmetries& gecode_Symmetries_from_term(YAP_Term t) { return * (Symmetries*) YAP_OpaqueObjectFromTerm(t); } static inline IntBranchFilter& gecode_IntBranchFilter_from_term(YAP_Term t) { return * (IntBranchFilter*) YAP_OpaqueObjectFromTerm(t); } static inline BoolBranchFilter& gecode_BoolBranchFilter_from_term(YAP_Term t) { return * (BoolBranchFilter*) YAP_OpaqueObjectFromTerm(t); } static inline FloatBranchFilter& gecode_FloatBranchFilter_from_term(YAP_Term t) { return * (FloatBranchFilter*) YAP_OpaqueObjectFromTerm(t); } static inline SetVarValPrint& gecode_SetVarValPrint_from_term(YAP_Term t) { return * (SetVarValPrint*) YAP_OpaqueObjectFromTerm(t); } static inline IntVarValPrint& gecode_IntVarValPrint_from_term(YAP_Term t) { return * (IntVarValPrint*) YAP_OpaqueObjectFromTerm(t); } static inline BoolVarValPrint& gecode_BoolVarValPrint_from_term(YAP_Term t) { return * (BoolVarValPrint*) YAP_OpaqueObjectFromTerm(t); } static inline FloatVarValPrint& gecode_FloatVarValPrint_from_term(YAP_Term t) { return * (FloatVarValPrint*) YAP_OpaqueObjectFromTerm(t); } static YAP_opaque_tag_t gecode_engine_tag; static YAP_opaque_handler_t gecode_engine_handler; static RestartMode gecode_RestartMode_from_term(YAP_Term t); static YAP_Bool gecode_new_engine(void) { YAP_Term arg1 = YAP_ARG1; YAP_Term arg2 = YAP_ARG2; YAP_Term arg3 = YAP_ARG3; bool restart = YAP_IntOfTerm(YAP_ArgOfTerm(1, arg3)); double threads = YAP_FloatOfTerm(YAP_ArgOfTerm(2, arg3)); unsigned int c_d = YAP_IntOfTerm(YAP_ArgOfTerm(3, arg3)); unsigned int a_d = YAP_IntOfTerm(YAP_ArgOfTerm(4, arg3)); unsigned int nogoods_limit = YAP_IntOfTerm(YAP_ArgOfTerm(6, arg3)); bool clone = ( YAP_IntOfTerm(YAP_ArgOfTerm(7, arg3)) == 0 ? FALSE : TRUE ); RestartMode md; YAP_Term t = YAP_ArgOfTerm(5, arg3); if (YAP_IsAtomTerm(t)) { md = gecode_RestartMode_from_term(t); } else if (YAP_IsApplTerm(t)) { md = gecode_RestartMode_from_term(YAP_MkAtomTerm(YAP_NameOfFunctor(YAP_FunctorOfTerm(t)))); } else { cerr << "bad engine cutoff option" << endl; exit(1); } Search::Cutoff* cutoff; YAP_Term t_s, t_b; switch (md) { case RM_CONSTANT: YAP_Term t_a; if (YAP_ArityOfFunctor(YAP_FunctorOfTerm(t)) == 1 && YAP_IsIntTerm(t_a = YAP_ArgOfTerm(1,t))) { unsigned long int a = YAP_IntOfTerm(t_a); cutoff = Search::Cutoff::constant(a); } else { cerr << "bad parameter for constant" << endl; exit(1); } break; case RM_GEOMETRIC: if (YAP_ArityOfFunctor(YAP_FunctorOfTerm(t)) == 2 && YAP_IsIntTerm(t_s = YAP_ArgOfTerm(1,t)) && YAP_IsIntTerm(t_b = YAP_ArgOfTerm(2,t))) { unsigned long int s = YAP_IntOfTerm(t_s); unsigned long int b = YAP_IntOfTerm(t_b); cutoff = Search::Cutoff::geometric(s,b); } else { cerr << "bad parameter for geometric" << endl; exit(1); } break; case RM_LUBY: if (YAP_ArityOfFunctor(YAP_FunctorOfTerm(t)) == 1 && YAP_IsIntTerm(t_s = YAP_ArgOfTerm(1,t))) { unsigned long int s = YAP_IntOfTerm(t_s); cutoff = Search::Cutoff::luby(s); } else { cerr << "bad parameter for luby" << endl; exit(1); } break; case RM_LINEAR: if (YAP_ArityOfFunctor(YAP_FunctorOfTerm(t)) == 1 && YAP_IsIntTerm(t_s = YAP_ArgOfTerm(1,t))) { unsigned long int s = YAP_IntOfTerm(t_s); cutoff = Search::Cutoff::linear(s); } else { cerr << "bad parameter for linear" << endl; exit(1); } break; default: cutoff = NULL; } Search::Options opt; opt.threads = threads; opt.c_d = c_d; opt.a_d = a_d; opt.cutoff = cutoff; opt.nogoods_limit = nogoods_limit; opt.clone = clone; opt.stop = NULL; GenericSpace* space = gecode_Space_from_term(arg1); GenericEngine* engine = space->new_engine(restart,opt); YAP_Term y_engine = YAP_NewOpaqueObject(gecode_engine_tag, sizeof(GenericEngine*)); GenericEngine** ptr = (GenericEngine**) YAP_OpaqueObjectFromTerm(y_engine); *ptr = engine; return YAP_Unify(arg2, y_engine); } static inline GenericEngine* gecode_engine_from_term(YAP_Term t) { return * (GenericEngine**) YAP_OpaqueObjectFromTerm(t); } static YAP_Bool gecode_engine_fail_handler(void* p) { delete *(GenericEngine**)p; return TRUE; } static YAP_Bool gecode_engine_write_handler (FILE *stream, YAP_opaque_tag_t type, void *p, int flags) { fprintf(stream,"", p); return TRUE; } static YAP_Bool gecode_engine_search(void) { GenericEngine* engine = gecode_engine_from_term(YAP_ARG1); GenericSpace* space = engine->next(); if (space) { YAP_Term term = gecode_term_from_space(space); return YAP_Unify(YAP_ARG2, term); } else YAP_cut_fail(); } #ifdef DISJUNCTOR static YAP_Bool gecode_new_disjunctor(void) { YAP_Term result = YAP_ARG1; GenericSpace* space = gecode_Space_from_term(YAP_ARG2); YAP_Term term = YAP_NewOpaqueObject(gecode_disjunctor_tag, sizeof(YapDisjunctor)); new (YAP_OpaqueObjectFromTerm(term)) YapDisjunctor(space); return YAP_Unify(result, term); } static YAP_Bool gecode_disjunctor_write_handler (FILE *stream, YAP_opaque_tag_t type, void *p, int flags) { fprintf(stream,"", p); return TRUE; } static YAP_Bool gecode_new_clause(void) { YAP_Term result = YAP_ARG1; YapDisjunctor& disj = gecode_YapDisjunctor_from_term(YAP_ARG2); YAP_Term term = YAP_NewOpaqueObject(gecode_disjunctor_clause_tag, sizeof(Clause)); new (YAP_OpaqueObjectFromTerm(term)) Clause(*disj.home,disj.disj); return YAP_Unify(result, term); } static YAP_Bool gecode_clause_write_handler (FILE *stream_, YAP_opaque_tag_t type, void *p, int flags) { fprintf(stream,"", p); return TRUE; } static IntVar gecode_IntVar_from_term(GenericSpace*,YAP_Term); static BoolVar gecode_BoolVar_from_term(GenericSpace*,YAP_Term); static FloatVar gecode_FloatVar_from_term(GenericSpace*,YAP_Term); static SetVar gecode_SetVar_from_term(GenericSpace*,YAP_Term); static YAP_Bool gecode_clause_intvar_forward(void) { Clause& clause = gecode_Clause_from_term(YAP_ARG1); GenericSpace* outer = clause.generic_parent(); GenericSpace* inner = clause.generic_space(); IntVar outer_var = gecode_IntVar_from_term(outer, YAP_ARG2); IntVar inner_var = gecode_IntVar_from_term(inner, YAP_ARG3); clause.forward(outer_var,inner_var); return TRUE; } static YAP_Bool gecode_clause_boolvar_forward(void) { Clause& clause = gecode_Clause_from_term(YAP_ARG1); GenericSpace* outer = clause.generic_parent(); GenericSpace* inner = clause.generic_space(); BoolVar outer_var = gecode_BoolVar_from_term(outer, YAP_ARG2); BoolVar inner_var = gecode_BoolVar_from_term(inner, YAP_ARG3); clause.forward(outer_var,inner_var); return TRUE; } static YAP_Bool gecode_clause_setvar_forward(void) { Clause& clause = gecode_Clause_from_term(YAP_ARG1); GenericSpace* outer = clause.generic_parent(); GenericSpace* inner = clause.generic_space(); SetVar outer_var = gecode_SetVar_from_term(outer, YAP_ARG2); SetVar inner_var = gecode_SetVar_from_term(inner, YAP_ARG3); clause.forward(outer_var,inner_var); return TRUE; } #endif static YAP_Bool gecode_new_intvar_from_bounds(void) { YAP_Term ivar = YAP_ARG1; GenericSpace* space = gecode_Space_from_term(YAP_ARG2); int lo = YAP_IntOfTerm(YAP_ARG3); int hi = YAP_IntOfTerm(YAP_ARG4); int i = space->new_ivar(lo, hi); YAP_Term y_i = YAP_MkIntTerm(i); return YAP_Unify(ivar, y_i); } static YAP_Bool gecode_new_floatvar_from_bounds(void) { YAP_Term ivar = YAP_ARG1; GenericSpace* space = gecode_Space_from_term(YAP_ARG2); double lo = YAP_FloatOfTerm(YAP_ARG3); double hi = YAP_FloatOfTerm(YAP_ARG4); int i = space->new_fvar(lo, hi); YAP_Term y_i = YAP_MkIntTerm(i); return YAP_Unify(ivar, y_i); } static int gecode_list_length(YAP_Term l) { int n = 0; while (YAP_IsPairTerm(l)) { n += 1; l = YAP_TailOfTerm(l); } return n; } static IntSet gecode_IntSet_from_term(YAP_Term specs) { int n = gecode_list_length(specs); SPECARRAY(r,n); int i = 0; while (YAP_IsPairTerm(specs)) { YAP_Term head = YAP_HeadOfTerm(specs); specs = YAP_TailOfTerm(specs); SPECARRAYELEM(r,i,0) = YAP_IntOfTerm(YAP_ArgOfTerm(1, head)); SPECARRAYELEM(r,i,1) = YAP_IntOfTerm(YAP_ArgOfTerm(2, head)); i += 1; } return IntSet(SPECARRAYDEREF(r), n); } static YAP_Bool gecode_new_intvar_from_intset(void) { YAP_Term ivar = YAP_ARG1; GenericSpace* space = gecode_Space_from_term(YAP_ARG2); YAP_Term specs = YAP_ARG3; IntSet iset = gecode_IntSet_from_term(specs); int i = space->new_ivar(iset); return YAP_Unify(ivar, YAP_MkIntTerm(i)); } static YAP_Bool gecode_new_boolvar(void) { YAP_Term bvar = YAP_ARG1; GenericSpace* space = gecode_Space_from_term(YAP_ARG2); int i = space->new_bvar(); return YAP_Unify(bvar, YAP_MkIntTerm(i)); } static YAP_Bool gecode_new_setvar_1(void) { YAP_Term result = YAP_ARG1; GenericSpace* space = gecode_Space_from_term(YAP_ARG2); int GlbMin = YAP_IntOfTerm(YAP_ARG3); int GlbMax = YAP_IntOfTerm(YAP_ARG4); int LubMin = YAP_IntOfTerm(YAP_ARG5); int LubMax = YAP_IntOfTerm(YAP_ARG6); int CardMin= YAP_IntOfTerm(YAP_ARG7); int CardMax= YAP_IntOfTerm(YAP_ARG8); int idx = space->new_svar(GlbMin,GlbMax,LubMin,LubMax,CardMin,CardMax); return YAP_Unify(result, YAP_MkIntTerm(idx)); } static YAP_Bool gecode_new_setvar_2(void) { YAP_Term result = YAP_ARG1; GenericSpace* space = gecode_Space_from_term(YAP_ARG2); int GlbMin = YAP_IntOfTerm(YAP_ARG3); int GlbMax = YAP_IntOfTerm(YAP_ARG4); int LubMin = YAP_IntOfTerm(YAP_ARG5); int LubMax = YAP_IntOfTerm(YAP_ARG6); int CardMin= YAP_IntOfTerm(YAP_ARG7); int idx = space->new_svar(GlbMin,GlbMax,LubMin,LubMax,CardMin); return YAP_Unify(result, YAP_MkIntTerm(idx)); } static YAP_Bool gecode_new_setvar_3(void) { YAP_Term result = YAP_ARG1; GenericSpace* space = gecode_Space_from_term(YAP_ARG2); int GlbMin = YAP_IntOfTerm(YAP_ARG3); int GlbMax = YAP_IntOfTerm(YAP_ARG4); int LubMin = YAP_IntOfTerm(YAP_ARG5); int LubMax = YAP_IntOfTerm(YAP_ARG6); int idx = space->new_svar(GlbMin,GlbMax,LubMin,LubMax); return YAP_Unify(result, YAP_MkIntTerm(idx)); } static YAP_Bool gecode_new_setvar_4(void) { YAP_Term result = YAP_ARG1; GenericSpace* space = gecode_Space_from_term(YAP_ARG2); IntSet Glb = gecode_IntSet_from_term(YAP_ARG3); int LubMin = YAP_IntOfTerm(YAP_ARG4); int LubMax = YAP_IntOfTerm(YAP_ARG5); int CardMin = YAP_IntOfTerm(YAP_ARG6); int CardMax = YAP_IntOfTerm(YAP_ARG7); int idx = space->new_svar(Glb,LubMin,LubMax,CardMin,CardMax); return YAP_Unify(result, YAP_MkIntTerm(idx)); } static YAP_Bool gecode_new_setvar_5(void) { YAP_Term result = YAP_ARG1; GenericSpace* space = gecode_Space_from_term(YAP_ARG2); IntSet Glb = gecode_IntSet_from_term(YAP_ARG3); int LubMin = YAP_IntOfTerm(YAP_ARG4); int LubMax = YAP_IntOfTerm(YAP_ARG5); int CardMin = YAP_IntOfTerm(YAP_ARG6); int idx = space->new_svar(Glb,LubMin,LubMax,CardMin); return YAP_Unify(result, YAP_MkIntTerm(idx)); } static YAP_Bool gecode_new_setvar_6(void) { YAP_Term result = YAP_ARG1; GenericSpace* space = gecode_Space_from_term(YAP_ARG2); IntSet Glb = gecode_IntSet_from_term(YAP_ARG3); int LubMin = YAP_IntOfTerm(YAP_ARG4); int LubMax = YAP_IntOfTerm(YAP_ARG5); int idx = space->new_svar(Glb,LubMin,LubMax); return YAP_Unify(result, YAP_MkIntTerm(idx)); } static YAP_Bool gecode_new_setvar_7(void) { YAP_Term result = YAP_ARG1; GenericSpace* space = gecode_Space_from_term(YAP_ARG2); int GlbMin = YAP_IntOfTerm(YAP_ARG3); int GlbMax = YAP_IntOfTerm(YAP_ARG4); IntSet Lub = gecode_IntSet_from_term(YAP_ARG5); int CardMin = YAP_IntOfTerm(YAP_ARG6); int CardMax = YAP_IntOfTerm(YAP_ARG7); int idx = space->new_svar(GlbMin,GlbMax,Lub,CardMin,CardMax); return YAP_Unify(result, YAP_MkIntTerm(idx)); } static YAP_Bool gecode_new_setvar_8(void) { YAP_Term result = YAP_ARG1; GenericSpace* space = gecode_Space_from_term(YAP_ARG2); int GlbMin = YAP_IntOfTerm(YAP_ARG3); int GlbMax = YAP_IntOfTerm(YAP_ARG4); IntSet Lub = gecode_IntSet_from_term(YAP_ARG5); int CardMin = YAP_IntOfTerm(YAP_ARG6); int idx = space->new_svar(GlbMin,GlbMax,Lub,CardMin); return YAP_Unify(result, YAP_MkIntTerm(idx)); } static YAP_Bool gecode_new_setvar_9(void) { YAP_Term result = YAP_ARG1; GenericSpace* space = gecode_Space_from_term(YAP_ARG2); int GlbMin = YAP_IntOfTerm(YAP_ARG3); int GlbMax = YAP_IntOfTerm(YAP_ARG4); IntSet Lub = gecode_IntSet_from_term(YAP_ARG5); int idx = space->new_svar(GlbMin,GlbMax,Lub); return YAP_Unify(result, YAP_MkIntTerm(idx)); } static YAP_Bool gecode_new_setvar_10(void) { YAP_Term result = YAP_ARG1; GenericSpace* space = gecode_Space_from_term(YAP_ARG2); IntSet Glb = gecode_IntSet_from_term(YAP_ARG3); IntSet Lub = gecode_IntSet_from_term(YAP_ARG4); int CardMin = YAP_IntOfTerm(YAP_ARG5); int CardMax = YAP_IntOfTerm(YAP_ARG6); int idx = space->new_svar(Glb,Lub,CardMin,CardMax); return YAP_Unify(result, YAP_MkIntTerm(idx)); } static YAP_Bool gecode_new_setvar_11(void) { YAP_Term result = YAP_ARG1; GenericSpace* space = gecode_Space_from_term(YAP_ARG2); IntSet Glb = gecode_IntSet_from_term(YAP_ARG3); IntSet Lub = gecode_IntSet_from_term(YAP_ARG4); int CardMin = YAP_IntOfTerm(YAP_ARG5); int idx = space->new_svar(Glb,Lub,CardMin); return YAP_Unify(result, YAP_MkIntTerm(idx)); } static YAP_Bool gecode_new_setvar_12(void) { YAP_Term result = YAP_ARG1; GenericSpace* space = gecode_Space_from_term(YAP_ARG2); IntSet Glb = gecode_IntSet_from_term(YAP_ARG3); IntSet Lub = gecode_IntSet_from_term(YAP_ARG4); int idx = space->new_svar(Glb,Lub); return YAP_Unify(result, YAP_MkIntTerm(idx)); } static YAP_Bool gecode_space_minimize(void) { GenericSpace* space = gecode_Space_from_term(YAP_ARG1); int i = YAP_IntOfTerm(YAP_ARG2); space->minimize(i); return TRUE; } static YAP_Bool gecode_space_maximize(void) { GenericSpace* space = gecode_Space_from_term(YAP_ARG1); int i = YAP_IntOfTerm(YAP_ARG2); space->maximize(i); return TRUE; } static YAP_Bool gecode_space_minimize_ratio(void) { GenericSpace* space = gecode_Space_from_term(YAP_ARG1); int i = YAP_IntOfTerm(YAP_ARG2); int j = YAP_IntOfTerm(YAP_ARG3); space->minimize(i,j); return TRUE; } static YAP_Bool gecode_space_maximize_ratio(void) { GenericSpace* space = gecode_Space_from_term(YAP_ARG1); int i = YAP_IntOfTerm(YAP_ARG2); int j = YAP_IntOfTerm(YAP_ARG3); space->maximize(i,j); return TRUE; } static IntVar gecode_IntVar_from_term(GenericSpace* space, YAP_Term x) { int i = YAP_IntOfTerm(x); return space->get_ivar(i); } static BoolVar gecode_BoolVar_from_term(GenericSpace* space, YAP_Term x) { int i = YAP_IntOfTerm(x); return space->get_bvar(i); } static SetVar gecode_SetVar_from_term(GenericSpace* space, YAP_Term x) { int i = YAP_IntOfTerm(x); return space->get_svar(i); } static IntVarArgs gecode_IntVarArgs_from_term(GenericSpace* space, YAP_Term l) { int n = gecode_list_length(l); IntVarArgs v(n); int i = 0; while (YAP_IsPairTerm(l)) { int idx = YAP_IntOfTerm(YAP_HeadOfTerm(l)); v[i] = space->get_ivar(idx); l = YAP_TailOfTerm(l); i += 1; } return v; } static BoolVarArgs gecode_BoolVarArgs_from_term(GenericSpace* space, YAP_Term l) { int n = gecode_list_length(l); BoolVarArgs v(n); int i = 0; while (YAP_IsPairTerm(l)) { int idx = YAP_IntOfTerm(YAP_HeadOfTerm(l)); v[i] = space->get_bvar(idx); l = YAP_TailOfTerm(l); i += 1; } return v; } static FloatVar gecode_FloatVar_from_term(GenericSpace* space, YAP_Term x) { int i = YAP_IntOfTerm(x); return space->get_fvar(i); } static FloatVarArgs gecode_FloatVarArgs_from_term(GenericSpace* space, YAP_Term l) { int n = gecode_list_length(l); FloatVarArgs v(n); int i = 0; while (YAP_IsPairTerm(l)) { int idx = YAP_IntOfTerm(YAP_HeadOfTerm(l)); v[i] = space->get_fvar(idx); l = YAP_TailOfTerm(l); i += 1; } return v; } static FloatValArgs gecode_FloatValArgs_from_term(YAP_Term l) { int n = gecode_list_length(l); FloatValArgs v(n); int i = 0; while (YAP_IsPairTerm(l)) { YAP_Term t = YAP_HeadOfTerm(l); v[i] = * (FloatVal*) YAP_OpaqueObjectFromTerm(t); l = YAP_TailOfTerm(l); i += 1; } return v; } static SetVarArgs gecode_SetVarArgs_from_term(GenericSpace* space, YAP_Term l) { int n = gecode_list_length(l); SetVarArgs v(n); int i = 0; while (YAP_IsPairTerm(l)) { int idx = YAP_IntOfTerm(YAP_HeadOfTerm(l)); v[i] = space->get_svar(idx); l = YAP_TailOfTerm(l); i += 1; } return v; } static IntArgs gecode_IntArgs_from_term(YAP_Term l) { int n = gecode_list_length(l); IntArgs v(n); int i = 0; while (YAP_IsPairTerm(l)) { int idx = YAP_IntOfTerm(YAP_HeadOfTerm(l)); v[i] = idx; l = YAP_TailOfTerm(l); i += 1; } return v; } static IntSetArgs gecode_IntSetArgs_from_term(YAP_Term l) { int n = gecode_list_length(l); IntSetArgs v(n); int i = 0; while (YAP_IsPairTerm(l)) { IntSet s = gecode_IntSet_from_term(YAP_HeadOfTerm(l)); v[i] = s; l = YAP_TailOfTerm(l); i += 1; } return v; } static TaskType gecode_TaskType_from_term(YAP_Term); static TaskTypeArgs gecode_TaskTypeArgs_from_term(YAP_Term l) { int n = gecode_list_length(l); TaskTypeArgs v(n); int i = 0; while (YAP_IsPairTerm(l)) { TaskType tt = gecode_TaskType_from_term(YAP_HeadOfTerm(l)); v[i] = tt; l = YAP_TailOfTerm(l); i += 1; } return v; } static YAP_Term gecode_TRUE; static YAP_Term gecode_FALSE; static bool gecode_bool_from_term(YAP_Term X) { if (X==gecode_TRUE) return true; if (X==gecode_FALSE) return false; cerr << "this should never happen" << endl; exit(1); } static YAP_Bool gecode_space_use_keep_index(void) { YAP_Term arg1 = YAP_ARG1; YAP_Term arg2 = YAP_ARG2; GenericSpace* space = gecode_Space_from_term(arg1); return YAP_Unify(arg2,(space->use_keep_index() ?gecode_TRUE:gecode_FALSE)); } static YAP_Bool gecode_intvar_keep(void) { YAP_Term arg1 = YAP_ARG1; YAP_Term arg2 = YAP_ARG2; YAP_Term arg3 = YAP_ARG3; GenericSpace* space = gecode_Space_from_term(arg1); int idx = YAP_IntOfTerm(arg2); int kidx = space->keep_ivar(idx); return YAP_Unify(arg3,YAP_MkIntTerm(kidx)); } static YAP_Bool gecode_boolvar_keep(void) { YAP_Term arg1 = YAP_ARG1; YAP_Term arg2 = YAP_ARG2; YAP_Term arg3 = YAP_ARG3; GenericSpace* space = gecode_Space_from_term(arg1); int idx = YAP_IntOfTerm(arg2); int kidx = space->keep_bvar(idx); return YAP_Unify(arg3,YAP_MkIntTerm(kidx)); } static YAP_Bool gecode_setvar_keep(void) { YAP_Term arg1 = YAP_ARG1; YAP_Term arg2 = YAP_ARG2; YAP_Term arg3 = YAP_ARG3; GenericSpace* space = gecode_Space_from_term(arg1); int idx = YAP_IntOfTerm(arg2); int kidx = space->keep_svar(idx); return YAP_Unify(arg3,YAP_MkIntTerm(kidx)); } // INFO ON INTVARS static YAP_Bool gecode_intvar_assigned(void) { GenericSpace* space = gecode_Space_from_term(YAP_ARG1); IntVar x = gecode_IntVar_from_term(space, YAP_ARG2); return (x.assigned()) ? TRUE : FALSE; } static YAP_Bool gecode_intvar_min(void) { YAP_Term result = YAP_ARG1; GenericSpace* space = gecode_Space_from_term(YAP_ARG2); IntVar x = gecode_IntVar_from_term(space, YAP_ARG3); return YAP_Unify(result, YAP_MkIntTerm(x.min())); } static YAP_Bool gecode_intvar_max(void) { YAP_Term result = YAP_ARG1; GenericSpace* space = gecode_Space_from_term(YAP_ARG2); IntVar x = gecode_IntVar_from_term(space, YAP_ARG3); return YAP_Unify(result, YAP_MkIntTerm(x.max())); } static YAP_Bool gecode_intvar_med(void) { YAP_Term result = YAP_ARG1; GenericSpace* space = gecode_Space_from_term(YAP_ARG2); IntVar x = gecode_IntVar_from_term(space, YAP_ARG3); return YAP_Unify(result, YAP_MkIntTerm(x.med())); } static YAP_Bool gecode_intvar_val(void) { YAP_Term result = YAP_ARG1; GenericSpace* space = gecode_Space_from_term(YAP_ARG2); IntVar x = gecode_IntVar_from_term(space, YAP_ARG3); return YAP_Unify(result, YAP_MkIntTerm(x.val())); } static YAP_Bool gecode_intvar_size(void) { YAP_Term result = YAP_ARG1; GenericSpace* space = gecode_Space_from_term(YAP_ARG2); IntVar x = gecode_IntVar_from_term(space, YAP_ARG3); return YAP_Unify(result, YAP_MkIntTerm(x.size())); } static YAP_Bool gecode_intvar_width(void) { YAP_Term result = YAP_ARG1; GenericSpace* space = gecode_Space_from_term(YAP_ARG2); IntVar x = gecode_IntVar_from_term(space, YAP_ARG3); return YAP_Unify(result, YAP_MkIntTerm(x.width())); } static YAP_Bool gecode_intvar_regret_min(void) { YAP_Term result = YAP_ARG1; GenericSpace* space = gecode_Space_from_term(YAP_ARG2); IntVar x = gecode_IntVar_from_term(space, YAP_ARG3); return YAP_Unify(result, YAP_MkIntTerm(x.regret_min())); } static YAP_Bool gecode_intvar_regret_max(void) { YAP_Term result = YAP_ARG1; GenericSpace* space = gecode_Space_from_term(YAP_ARG2); IntVar x = gecode_IntVar_from_term(space, YAP_ARG3); return YAP_Unify(result, YAP_MkIntTerm(x.regret_max())); } static YAP_Functor gecode_COMMA2; static YAP_Bool gecode_intvar_ranges(void) { YAP_Term result = YAP_ARG1; GenericSpace* space = gecode_Space_from_term(YAP_ARG2); IntVar x = gecode_IntVar_from_term(space, YAP_ARG3); int n = 0; { IntVarRanges it(x); while (it()) { ++n; ++it; } } DYNARRAY(int,min,n); DYNARRAY(int,max,n); { IntVarRanges it(x); int i=0; while (it()) { min[i]=it.min(); max[i]=it.max(); ++it; ++i; } } YAP_Term lst = YAP_TermNil(); for (;n--;) { YAP_Term args[2]; args[0] = YAP_MkIntTerm(min[n]); args[1] = YAP_MkIntTerm(max[n]); YAP_Term range = YAP_MkApplTerm(gecode_COMMA2,2,args); lst = YAP_MkPairTerm(range,lst); } return YAP_Unify(result,lst); } static YAP_Bool gecode_intvar_values(void) { YAP_Term result = YAP_ARG1; GenericSpace* space = gecode_Space_from_term(YAP_ARG2); IntVar x = gecode_IntVar_from_term(space, YAP_ARG3); int n = x.size(); DYNARRAY(int,a,n); { IntVarValues it(x); int i=0; while (it()) { a[i]=it.val(); ++it; ++i; } } YAP_Term lst = YAP_TermNil(); for (;n--;) { lst = YAP_MkPairTerm(YAP_MkIntTerm(a[n]),lst); } return YAP_Unify(result,lst); } // INFO ON BOOLVARS static YAP_Bool gecode_boolvar_assigned(void) { GenericSpace* space = gecode_Space_from_term(YAP_ARG1); BoolVar x = gecode_BoolVar_from_term(space, YAP_ARG2); return (x.assigned()) ? TRUE : FALSE; } static YAP_Bool gecode_boolvar_min(void) { YAP_Term result = YAP_ARG1; GenericSpace* space = gecode_Space_from_term(YAP_ARG2); BoolVar x = gecode_BoolVar_from_term(space, YAP_ARG3); return YAP_Unify(result, YAP_MkIntTerm(x.min())); } static YAP_Bool gecode_boolvar_max(void) { YAP_Term result = YAP_ARG1; GenericSpace* space = gecode_Space_from_term(YAP_ARG2); BoolVar x = gecode_BoolVar_from_term(space, YAP_ARG3); return YAP_Unify(result, YAP_MkIntTerm(x.max())); } static YAP_Bool gecode_boolvar_med(void) { YAP_Term result = YAP_ARG1; GenericSpace* space = gecode_Space_from_term(YAP_ARG2); BoolVar x = gecode_BoolVar_from_term(space, YAP_ARG3); return YAP_Unify(result, YAP_MkIntTerm(x.med())); } static YAP_Bool gecode_boolvar_val(void) { YAP_Term result = YAP_ARG1; GenericSpace* space = gecode_Space_from_term(YAP_ARG2); BoolVar x = gecode_BoolVar_from_term(space, YAP_ARG3); return YAP_Unify(result, YAP_MkIntTerm(x.val())); } static YAP_Bool gecode_boolvar_size(void) { YAP_Term result = YAP_ARG1; GenericSpace* space = gecode_Space_from_term(YAP_ARG2); BoolVar x = gecode_BoolVar_from_term(space, YAP_ARG3); return YAP_Unify(result, YAP_MkIntTerm(x.size())); } static YAP_Bool gecode_boolvar_width(void) { YAP_Term result = YAP_ARG1; GenericSpace* space = gecode_Space_from_term(YAP_ARG2); BoolVar x = gecode_BoolVar_from_term(space, YAP_ARG3); return YAP_Unify(result, YAP_MkIntTerm(x.width())); } static YAP_Bool gecode_boolvar_regret_min(void) { YAP_Term result = YAP_ARG1; GenericSpace* space = gecode_Space_from_term(YAP_ARG2); BoolVar x = gecode_BoolVar_from_term(space, YAP_ARG3); return YAP_Unify(result, YAP_MkIntTerm(x.regret_min())); } static YAP_Bool gecode_boolvar_regret_max(void) { YAP_Term result = YAP_ARG1; GenericSpace* space = gecode_Space_from_term(YAP_ARG2); BoolVar x = gecode_BoolVar_from_term(space, YAP_ARG3); return YAP_Unify(result, YAP_MkIntTerm(x.regret_max())); } // INFO ON SETVARS static YAP_Bool gecode_setvar_assigned(void) { GenericSpace* space = gecode_Space_from_term(YAP_ARG1); SetVar x = gecode_SetVar_from_term(space, YAP_ARG2); return (x.assigned()) ? TRUE : FALSE; } static YAP_Bool gecode_setvar_glbSize(void) { YAP_Term result = YAP_ARG1; GenericSpace* space = gecode_Space_from_term(YAP_ARG2); SetVar x = gecode_SetVar_from_term(space, YAP_ARG3); return YAP_Unify(result, YAP_MkIntTerm(x.glbSize())); } static YAP_Bool gecode_setvar_lubSize(void) { YAP_Term result = YAP_ARG1; GenericSpace* space = gecode_Space_from_term(YAP_ARG2); SetVar x = gecode_SetVar_from_term(space, YAP_ARG3); return YAP_Unify(result, YAP_MkIntTerm(x.lubSize())); } static YAP_Bool gecode_setvar_unknownSize(void) { YAP_Term result = YAP_ARG1; GenericSpace* space = gecode_Space_from_term(YAP_ARG2); SetVar x = gecode_SetVar_from_term(space, YAP_ARG3); return YAP_Unify(result, YAP_MkIntTerm(x.unknownSize())); } static YAP_Bool gecode_setvar_cardMin(void) { YAP_Term result = YAP_ARG1; GenericSpace* space = gecode_Space_from_term(YAP_ARG2); SetVar x = gecode_SetVar_from_term(space, YAP_ARG3); return YAP_Unify(result, YAP_MkIntTerm(x.cardMin())); } static YAP_Bool gecode_setvar_cardMax(void) { YAP_Term result = YAP_ARG1; GenericSpace* space = gecode_Space_from_term(YAP_ARG2); SetVar x = gecode_SetVar_from_term(space, YAP_ARG3); return YAP_Unify(result, YAP_MkIntTerm(x.cardMax())); } static YAP_Bool gecode_setvar_lubMin(void) { YAP_Term result = YAP_ARG1; GenericSpace* space = gecode_Space_from_term(YAP_ARG2); SetVar x = gecode_SetVar_from_term(space, YAP_ARG3); return YAP_Unify(result, YAP_MkIntTerm(x.lubMin())); } static YAP_Bool gecode_setvar_lubMax(void) { YAP_Term result = YAP_ARG1; GenericSpace* space = gecode_Space_from_term(YAP_ARG2); SetVar x = gecode_SetVar_from_term(space, YAP_ARG3); return YAP_Unify(result, YAP_MkIntTerm(x.lubMax())); } static YAP_Bool gecode_setvar_glbMin(void) { YAP_Term result = YAP_ARG1; GenericSpace* space = gecode_Space_from_term(YAP_ARG2); SetVar x = gecode_SetVar_from_term(space, YAP_ARG3); return YAP_Unify(result, YAP_MkIntTerm(x.glbMin())); } static YAP_Bool gecode_setvar_glbMax(void) { YAP_Term result = YAP_ARG1; GenericSpace* space = gecode_Space_from_term(YAP_ARG2); SetVar x = gecode_SetVar_from_term(space, YAP_ARG3); return YAP_Unify(result, YAP_MkIntTerm(x.glbMax())); } static YAP_Bool gecode_setvar_glb_ranges(void) { YAP_Term result = YAP_ARG1; GenericSpace* space = gecode_Space_from_term(YAP_ARG2); SetVar x = gecode_SetVar_from_term(space, YAP_ARG3); int n = 0; { SetVarGlbRanges it(x); while (it()) { ++n; ++it; } } DYNARRAY(int,min,n); DYNARRAY(int,max,n); { SetVarGlbRanges it(x); int i=0; while (it()) { min[i]=it.min(); max[i]=it.max(); ++it; ++i; } } YAP_Term lst = YAP_TermNil(); for (;n--;) { YAP_Term args[2]; args[0] = YAP_MkIntTerm(min[n]); args[1] = YAP_MkIntTerm(max[n]); YAP_Term range = YAP_MkApplTerm(gecode_COMMA2,2,args); lst = YAP_MkPairTerm(range,lst); } return YAP_Unify(result,lst); } static YAP_Bool gecode_setvar_lub_ranges(void) { YAP_Term result = YAP_ARG1; GenericSpace* space = gecode_Space_from_term(YAP_ARG2); SetVar x = gecode_SetVar_from_term(space, YAP_ARG3); int n = 0; { SetVarLubRanges it(x); while (it()) { ++n; ++it; } } DYNARRAY(int,min,n); DYNARRAY(int,max,n); { SetVarLubRanges it(x); int i=0; while (it()) { min[i]=it.min(); max[i]=it.max(); ++it; ++i; } } YAP_Term lst = YAP_TermNil(); for (;n--;) { YAP_Term args[2]; args[0] = YAP_MkIntTerm(min[n]); args[1] = YAP_MkIntTerm(max[n]); YAP_Term range = YAP_MkApplTerm(gecode_COMMA2,2,args); lst = YAP_MkPairTerm(range,lst); } return YAP_Unify(result,lst); } static YAP_Bool gecode_setvar_unknown_ranges(void) { YAP_Term result = YAP_ARG1; GenericSpace* space = gecode_Space_from_term(YAP_ARG2); SetVar x = gecode_SetVar_from_term(space, YAP_ARG3); int n = 0; { SetVarUnknownRanges it(x); while (it()) { ++n; ++it; } } DYNARRAY(int,min,n); DYNARRAY(int,max,n); { SetVarUnknownRanges it(x); int i=0; while (it()) { min[i]=it.min(); max[i]=it.max(); ++it; ++i; } } YAP_Term lst = YAP_TermNil(); for (;n--;) { YAP_Term args[2]; args[0] = YAP_MkIntTerm(min[n]); args[1] = YAP_MkIntTerm(max[n]); YAP_Term range = YAP_MkApplTerm(gecode_COMMA2,2,args); lst = YAP_MkPairTerm(range,lst); } return YAP_Unify(result,lst); } static YAP_Bool gecode_setvar_glb_values(void) { YAP_Term result = YAP_ARG1; GenericSpace* space = gecode_Space_from_term(YAP_ARG2); SetVar x = gecode_SetVar_from_term(space, YAP_ARG3); DYNARRAY(YAP_Term,elems,x.glbSize()); SetVarGlbValues it(x); int n = 0; while (it()) { elems[n] = YAP_MkIntTerm(it.val()); ++it; ++n; } YAP_Term lst = YAP_TermNil(); for (;n--;) lst = YAP_MkPairTerm(elems[n],lst); return YAP_Unify(result,lst); } static YAP_Bool gecode_setvar_lub_values(void) { YAP_Term result = YAP_ARG1; GenericSpace* space = gecode_Space_from_term(YAP_ARG2); SetVar x = gecode_SetVar_from_term(space, YAP_ARG3); DYNARRAY(YAP_Term,elems,x.lubSize()); SetVarLubValues it(x); int n = 0; while (it()) { elems[n] = YAP_MkIntTerm(it.val()); ++it; ++n; } YAP_Term lst = YAP_TermNil(); for (;n--;) lst = YAP_MkPairTerm(elems[n],lst); return YAP_Unify(result,lst); } static YAP_Bool gecode_setvar_unknown_values(void) { YAP_Term result = YAP_ARG1; GenericSpace* space = gecode_Space_from_term(YAP_ARG2); SetVar x = gecode_SetVar_from_term(space, YAP_ARG3); DYNARRAY(YAP_Term,elems,x.unknownSize()); SetVarUnknownValues it(x); int n = 0; while (it()) { elems[n] = YAP_MkIntTerm(it.val()); ++it; ++n; } YAP_Term lst = YAP_TermNil(); for (;n--;) lst = YAP_MkPairTerm(elems[n],lst); return YAP_Unify(result,lst); } // INFO ON FLOATVARS static YAP_Bool gecode_floatvar_assigned(void) { GenericSpace* space = gecode_Space_from_term(YAP_ARG1); FloatVar x = gecode_FloatVar_from_term(space, YAP_ARG2); return (x.assigned()) ? TRUE : FALSE; } static YAP_Bool gecode_floatvar_min(void) { YAP_Term result = YAP_ARG1; GenericSpace* space = gecode_Space_from_term(YAP_ARG2); FloatVar x = gecode_FloatVar_from_term(space, YAP_ARG3); return YAP_Unify(result, YAP_MkFloatTerm(x.min())); } static YAP_Bool gecode_floatvar_max(void) { YAP_Term result = YAP_ARG1; GenericSpace* space = gecode_Space_from_term(YAP_ARG2); FloatVar x = gecode_FloatVar_from_term(space, YAP_ARG3); return YAP_Unify(result, YAP_MkFloatTerm(x.max())); } static YAP_Bool gecode_floatvar_med(void) { YAP_Term result = YAP_ARG1; GenericSpace* space = gecode_Space_from_term(YAP_ARG2); FloatVar x = gecode_FloatVar_from_term(space, YAP_ARG3); return YAP_Unify(result, YAP_MkFloatTerm(x.med())); } static YAP_Bool gecode_floatvar_size(void) { YAP_Term result = YAP_ARG1; GenericSpace* space = gecode_Space_from_term(YAP_ARG2); FloatVar x = gecode_FloatVar_from_term(space, YAP_ARG3); return YAP_Unify(result, YAP_MkFloatTerm(x.size())); } static inline Reify gecode_Reify_from_term(YAP_Term t) { return * (Reify*) YAP_OpaqueObjectFromTerm(t); } #define gecode_int_from_term YAP_IntOfTerm #include "gecode_yap_cc_forward_auto_generated.icc" #include "gecode_yap_cc_impl_auto_generated.icc" static YAP_opaque_tag_t gecode_reify_tag; static YAP_opaque_handler_t gecode_reify_handler; static YAP_Bool gecode_reify_write_handler (FILE *stream, YAP_opaque_tag_t type, void *p, int flags) { fprintf(stream,"", p); return TRUE; } static YAP_Term gecode_term_from_reify(Reify r) { YAP_Term term = YAP_NewOpaqueObject(gecode_reify_tag, sizeof(Reify)); Reify *ptr = (Reify*) YAP_OpaqueObjectFromTerm(term); *ptr = r; return term; } static YAP_Bool gecode_new_reify(void) { GenericSpace* space = gecode_Space_from_term(YAP_ARG1); BoolVar b = gecode_BoolVar_from_term(space, YAP_ARG2); ReifyMode flag = gecode_ReifyMode_from_term(YAP_ARG3); Reify r = Reify(b,flag); YAP_Term term = gecode_term_from_reify(r); return YAP_Unify(YAP_ARG4, term); } static YAP_opaque_tag_t gecode_tupleset_tag; static YAP_opaque_handler_t gecode_tupleset_handler; static YAP_Bool gecode_tupleset_fail_handler(void* p) { return TRUE; } static YAP_Bool gecode_tupleset_write_handler (FILE *stream, YAP_opaque_tag_t type, void *p, int flags) { fprintf(stream,"", p); return TRUE; } static YAP_Bool gecode_new_tupleset(void) { YAP_Term term = YAP_NewOpaqueObject(gecode_tupleset_tag, sizeof(TupleSet)); TupleSet *ts = new (YAP_OpaqueObjectFromTerm(term)) TupleSet; YAP_Term t = YAP_ARG1; while (YAP_IsPairTerm( t ) ) { YAP_Term l = YAP_HeadOfTerm(t); int n = gecode_list_length(l); int i = 0; IntArgs is(n); while (YAP_IsPairTerm( l ) ) { YAP_Term ll = YAP_HeadOfTerm(l); if (!YAP_IsIntTerm(ll)) { cerr << "non-integer on tuple set" << endl; exit(1); } is[i++] = YAP_IntOfTerm(ll); l = YAP_TailOfTerm(l); } ts->add(is); if (l != YAP_TermNil()) { cerr << "non-list on tuple set" << endl; exit(1); } t = YAP_TailOfTerm(t); } if (t != YAP_TermNil()) { cerr << "non-list on tuple set" << endl; exit(1); } ts->finalize(); return YAP_Unify(YAP_ARG2, term); } static YAP_opaque_tag_t gecode_dfa_tag; static YAP_opaque_handler_t gecode_dfa_handler; static YAP_Bool gecode_dfa_fail_handler(void* p) { return TRUE; } static YAP_Bool gecode_dfa_write_handler (FILE *stream, YAP_opaque_tag_t type, void *p, int flags) { fprintf(stream,"", p); return TRUE; } static YAP_Bool gecode_new_dfa(void) { YAP_Term term = YAP_NewOpaqueObject(gecode_dfa_tag, sizeof(DFA)); // DFA ts = new (YAP_OpaqueObjectFromTerm(term)) DFA; YAP_Term t2 = YAP_ARG2; int s0 = YAP_IntOfTerm(t2); YAP_Term t3 = YAP_ARG3; int n = gecode_list_length(t3), i=0; DFA::Transition t[1024]; if (n > 1024) cerr<< "DFA too long" << endl; while (YAP_IsPairTerm( t3 ) ) { YAP_Term tt = YAP_HeadOfTerm(t3); int is, sy, os; is = YAP_IntOfTerm(YAP_ArgOfTerm(1,tt)); sy = YAP_IntOfTerm(YAP_ArgOfTerm(2,tt)); os = YAP_IntOfTerm(YAP_ArgOfTerm(3,tt)); t[i++] = DFA::Transition(is, sy, os); t3 = YAP_TailOfTerm(t3); } if (t3 != YAP_TermNil()) { cerr << "non-list on DFA" << endl; exit(1); } YAP_Term t4 = YAP_ARG4; n = gecode_list_length(t4)+1; i=0; int s[n]; s[n-1] = -1; while (YAP_IsPairTerm( t4 ) ) { YAP_Term tt = YAP_HeadOfTerm(t4); s[i++] = YAP_IntOfTerm(tt); t4 = YAP_TailOfTerm(t4); } if (t4 != YAP_TermNil()) { cerr << "non-list on DFA" << endl; exit(1); } new (YAP_OpaqueObjectFromTerm(term)) DFA(s0, t, s); return YAP_Unify(YAP_ARG1, term); } void gecode_init(void) { { YAP_Atom X= YAP_LookupAtom("true"); gecode_TRUE = YAP_MkAtomTerm(X); YAP_AtomGetHold(X); } { YAP_Atom X= YAP_LookupAtom("false"); gecode_FALSE = YAP_MkAtomTerm(X); YAP_AtomGetHold(X); } { YAP_Atom X= YAP_LookupAtom(","); YAP_AtomGetHold(X); gecode_COMMA2 = YAP_MkFunctor(X,2); } { YAP_Atom X= YAP_LookupAtom("INT_VAR_NONE"); gecode_INT_VAR_NONE = YAP_MkAtomTerm(X); YAP_AtomGetHold(X); } { YAP_Atom X= YAP_LookupAtom("INT_VAR_DEGREE_MIN"); gecode_INT_VAR_DEGREE_MIN = YAP_MkAtomTerm(X); YAP_AtomGetHold(X); } { YAP_Atom X= YAP_LookupAtom("INT_VAR_DEGREE_MAX"); gecode_INT_VAR_DEGREE_MAX = YAP_MkAtomTerm(X); YAP_AtomGetHold(X); } { YAP_Atom X= YAP_LookupAtom("INT_VAR_MIN_MIN"); gecode_INT_VAR_MIN_MIN = YAP_MkAtomTerm(X); YAP_AtomGetHold(X); } { YAP_Atom X= YAP_LookupAtom("INT_VAR_MIN_MAX"); gecode_INT_VAR_MIN_MAX = YAP_MkAtomTerm(X); YAP_AtomGetHold(X); } { YAP_Atom X= YAP_LookupAtom("INT_VAR_MAX_MIN"); gecode_INT_VAR_MAX_MIN = YAP_MkAtomTerm(X); YAP_AtomGetHold(X); } { YAP_Atom X= YAP_LookupAtom("INT_VAR_MAX_MAX"); gecode_INT_VAR_MAX_MAX = YAP_MkAtomTerm(X); YAP_AtomGetHold(X); } { YAP_Atom X= YAP_LookupAtom("INT_VAR_SIZE_MIN"); gecode_INT_VAR_SIZE_MIN = YAP_MkAtomTerm(X); YAP_AtomGetHold(X); } { YAP_Atom X= YAP_LookupAtom("INT_VAR_SIZE_MAX"); gecode_INT_VAR_SIZE_MAX = YAP_MkAtomTerm(X); YAP_AtomGetHold(X); } { YAP_Atom X= YAP_LookupAtom("INT_VAR_DEGREE_SIZE_MIN"); gecode_INT_VAR_DEGREE_SIZE_MIN = YAP_MkAtomTerm(X); YAP_AtomGetHold(X); } { YAP_Atom X= YAP_LookupAtom("INT_VAR_DEGREE_SIZE_MAX"); gecode_INT_VAR_DEGREE_SIZE_MAX = YAP_MkAtomTerm(X); YAP_AtomGetHold(X); } { YAP_Atom X= YAP_LookupAtom("INT_VAR_REGRET_MIN_MIN"); gecode_INT_VAR_REGRET_MIN_MIN = YAP_MkAtomTerm(X); YAP_AtomGetHold(X); } { YAP_Atom X= YAP_LookupAtom("INT_VAR_REGRET_MIN_MAX"); gecode_INT_VAR_REGRET_MIN_MAX = YAP_MkAtomTerm(X); YAP_AtomGetHold(X); } { YAP_Atom X= YAP_LookupAtom("INT_VAR_REGRET_MAX_MIN"); gecode_INT_VAR_REGRET_MAX_MIN = YAP_MkAtomTerm(X); YAP_AtomGetHold(X); } { YAP_Atom X= YAP_LookupAtom("INT_VAR_REGRET_MAX_MAX"); gecode_INT_VAR_REGRET_MAX_MAX = YAP_MkAtomTerm(X); YAP_AtomGetHold(X); } { YAP_Atom X= YAP_LookupAtom("INT_VAL_MIN"); gecode_INT_VAL_MIN = YAP_MkAtomTerm(X); YAP_AtomGetHold(X); } { YAP_Atom X= YAP_LookupAtom("INT_VAL_MED"); gecode_INT_VAL_MED = YAP_MkAtomTerm(X); YAP_AtomGetHold(X); } { YAP_Atom X= YAP_LookupAtom("INT_VAL_MAX"); gecode_INT_VAL_MAX = YAP_MkAtomTerm(X); YAP_AtomGetHold(X); } { YAP_Atom X= YAP_LookupAtom("INT_VAL_SPLIT_MIN"); gecode_INT_VAL_SPLIT_MIN = YAP_MkAtomTerm(X); YAP_AtomGetHold(X); } { YAP_Atom X= YAP_LookupAtom("INT_VAL_SPLIT_MAX"); gecode_INT_VAL_SPLIT_MAX = YAP_MkAtomTerm(X); YAP_AtomGetHold(X); } { YAP_Atom X= YAP_LookupAtom("INT_VAL_RANGE_MIN"); gecode_INT_VAL_RANGE_MIN = YAP_MkAtomTerm(X); YAP_AtomGetHold(X); } { YAP_Atom X= YAP_LookupAtom("INT_VAL_RANGE_MAX"); gecode_INT_VAL_RANGE_MAX = YAP_MkAtomTerm(X); YAP_AtomGetHold(X); } { YAP_Atom X= YAP_LookupAtom("INT_VALUES_MIN"); gecode_INT_VALUES_MIN = YAP_MkAtomTerm(X); YAP_AtomGetHold(X); } { YAP_Atom X= YAP_LookupAtom("INT_VALUES_MAX"); gecode_INT_VALUES_MAX = YAP_MkAtomTerm(X); YAP_AtomGetHold(X); } { YAP_Atom X= YAP_LookupAtom("SET_VAR_NONE"); gecode_SET_VAR_NONE = YAP_MkAtomTerm(X); YAP_AtomGetHold(X); } { YAP_Atom X= YAP_LookupAtom("SET_VAR_DEGREE_MIN"); gecode_SET_VAR_DEGREE_MIN = YAP_MkAtomTerm(X); YAP_AtomGetHold(X); } { YAP_Atom X= YAP_LookupAtom("SET_VAR_DEGREE_MAX"); gecode_SET_VAR_DEGREE_MAX = YAP_MkAtomTerm(X); YAP_AtomGetHold(X); } { YAP_Atom X= YAP_LookupAtom("SET_VAR_MIN_MIN"); gecode_SET_VAR_MIN_MIN = YAP_MkAtomTerm(X); YAP_AtomGetHold(X); } { YAP_Atom X= YAP_LookupAtom("SET_VAR_MIN_MAX"); gecode_SET_VAR_MIN_MAX = YAP_MkAtomTerm(X); YAP_AtomGetHold(X); } { YAP_Atom X= YAP_LookupAtom("SET_VAR_MAX_MIN"); gecode_SET_VAR_MAX_MIN = YAP_MkAtomTerm(X); YAP_AtomGetHold(X); } { YAP_Atom X= YAP_LookupAtom("SET_VAR_MAX_MAX"); gecode_SET_VAR_MAX_MAX = YAP_MkAtomTerm(X); YAP_AtomGetHold(X); } { YAP_Atom X= YAP_LookupAtom("SET_VAR_SIZE_MIN"); gecode_SET_VAR_SIZE_MIN = YAP_MkAtomTerm(X); YAP_AtomGetHold(X); } { YAP_Atom X= YAP_LookupAtom("SET_VAR_SIZE_MAX"); gecode_SET_VAR_SIZE_MAX = YAP_MkAtomTerm(X); YAP_AtomGetHold(X); } { YAP_Atom X= YAP_LookupAtom("SET_VAR_DEGREE_SIZE_MIN"); gecode_SET_VAR_DEGREE_SIZE_MIN = YAP_MkAtomTerm(X); YAP_AtomGetHold(X); } { YAP_Atom X= YAP_LookupAtom("SET_VAR_DEGREE_SIZE_MAX"); gecode_SET_VAR_DEGREE_SIZE_MAX = YAP_MkAtomTerm(X); YAP_AtomGetHold(X); } { YAP_Atom X= YAP_LookupAtom("SET_VAL_MIN_INC"); gecode_SET_VAL_MIN_INC = YAP_MkAtomTerm(X); YAP_AtomGetHold(X); } { YAP_Atom X= YAP_LookupAtom("SET_VAL_MED_INC"); gecode_SET_VAL_MED_INC = YAP_MkAtomTerm(X); YAP_AtomGetHold(X); } { YAP_Atom X= YAP_LookupAtom("SET_VAL_MAX_INC"); gecode_SET_VAL_MAX_INC = YAP_MkAtomTerm(X); YAP_AtomGetHold(X); } { YAP_Atom X= YAP_LookupAtom("SET_VAL_MIN_EXC"); gecode_SET_VAL_MIN_EXC = YAP_MkAtomTerm(X); YAP_AtomGetHold(X); } { YAP_Atom X= YAP_LookupAtom("SET_VAL_MED_EXC"); gecode_SET_VAL_MED_EXC = YAP_MkAtomTerm(X); YAP_AtomGetHold(X); } { YAP_Atom X= YAP_LookupAtom("SET_VAL_MAX_EXC"); gecode_SET_VAL_MAX_EXC = YAP_MkAtomTerm(X); YAP_AtomGetHold(X); } { YAP_Atom X= YAP_LookupAtom("FLOAT_VAR_NONE"); gecode_FLOAT_VAR_NONE = YAP_MkAtomTerm(X); YAP_AtomGetHold(X); } { YAP_Atom X= YAP_LookupAtom("FLOAT_VAR_DEGREE_MIN"); gecode_FLOAT_VAR_DEGREE_MIN = YAP_MkAtomTerm(X); YAP_AtomGetHold(X); } { YAP_Atom X= YAP_LookupAtom("FLOAT_VAR_DEGREE_MAX"); gecode_FLOAT_VAR_DEGREE_MAX = YAP_MkAtomTerm(X); YAP_AtomGetHold(X); } { YAP_Atom X= YAP_LookupAtom("FLOAT_VAR_MIN_MIN"); gecode_FLOAT_VAR_MIN_MIN = YAP_MkAtomTerm(X); YAP_AtomGetHold(X); } { YAP_Atom X= YAP_LookupAtom("FLOAT_VAR_MIN_MAX"); gecode_FLOAT_VAR_MIN_MAX = YAP_MkAtomTerm(X); YAP_AtomGetHold(X); } { YAP_Atom X= YAP_LookupAtom("FLOAT_VAR_MAX_MIN"); gecode_FLOAT_VAR_MAX_MIN = YAP_MkAtomTerm(X); YAP_AtomGetHold(X); } { YAP_Atom X= YAP_LookupAtom("FLOAT_VAR_MAX_MAX"); gecode_FLOAT_VAR_MAX_MAX = YAP_MkAtomTerm(X); YAP_AtomGetHold(X); } { YAP_Atom X= YAP_LookupAtom("FLOAT_VAR_SIZE_MIN"); gecode_FLOAT_VAR_SIZE_MIN = YAP_MkAtomTerm(X); YAP_AtomGetHold(X); } { YAP_Atom X= YAP_LookupAtom("FLOAT_VAR_SIZE_MAX"); gecode_FLOAT_VAR_SIZE_MAX = YAP_MkAtomTerm(X); YAP_AtomGetHold(X); } { YAP_Atom X= YAP_LookupAtom("FLOAT_VAR_DEGREE_SIZE_MIN"); gecode_FLOAT_VAR_DEGREE_SIZE_MIN = YAP_MkAtomTerm(X); YAP_AtomGetHold(X); } { YAP_Atom X= YAP_LookupAtom("FLOAT_VAR_DEGREE_SIZE_MAX"); gecode_FLOAT_VAR_DEGREE_SIZE_MAX = YAP_MkAtomTerm(X); YAP_AtomGetHold(X); } { YAP_Atom X= YAP_LookupAtom("FLOAT_VAL_SPLIT_MIN"); gecode_FLOAT_VAL_SPLIT_MIN = YAP_MkAtomTerm(X); YAP_AtomGetHold(X); } { YAP_Atom X= YAP_LookupAtom("FLOAT_VAL_SPLIT_MAX"); gecode_FLOAT_VAL_SPLIT_MAX = YAP_MkAtomTerm(X); YAP_AtomGetHold(X); } #include "gecode_yap_cc_init_auto_generated.icc" // opaque spaces gecode_space_handler.fail_handler = gecode_space_fail_handler; gecode_space_handler.write_handler = gecode_space_write_handler; gecode_space_tag = YAP_NewOpaqueType(&gecode_space_handler); YAP_UserCPredicate("gecode_new_space", gecode_new_space, 1); // opaque engines gecode_engine_handler.fail_handler = gecode_engine_fail_handler; gecode_engine_handler.write_handler = gecode_engine_write_handler; gecode_engine_tag = YAP_NewOpaqueType(&gecode_engine_handler); YAP_UserCPredicate("gecode_new_engine", gecode_new_engine, 3); // opaque reifications gecode_reify_handler.fail_handler = NULL; gecode_reify_handler.write_handler = gecode_reify_write_handler; gecode_reify_tag = YAP_NewOpaqueType(&gecode_reify_handler); YAP_UserCPredicate("gecode_new_reify", gecode_new_reify, 4); // Opaque TupleSet gecode_tupleset_handler.fail_handler = gecode_tupleset_fail_handler; gecode_tupleset_handler.write_handler = gecode_tupleset_write_handler; gecode_tupleset_tag = YAP_NewOpaqueType(&gecode_tupleset_handler); YAP_UserCPredicate("gecode_new_tupleset", gecode_new_tupleset, 2); // Opaque DFA gecode_dfa_handler.fail_handler = gecode_dfa_fail_handler; gecode_dfa_handler.write_handler = gecode_dfa_write_handler; gecode_dfa_tag = YAP_NewOpaqueType(&gecode_dfa_handler); YAP_UserCPredicate("gecode_new_dfa", gecode_new_dfa, 4); #ifdef DISJUNCTOR // opaque disjunctors and clauses gecode_disjunctor_handler.write_handler = gecode_disjunctor_write_handler; gecode_disjunctor_tag = YAP_NewOpaqueType(&gecode_disjunctor_handler); gecode_disjunctor_clause_handler.write_handler = gecode_clause_write_handler; gecode_disjunctor_clause_tag = YAP_NewOpaqueType(&gecode_disjunctor_clause_handler); YAP_UserCPredicate("gecode_new_disjunctor", gecode_new_disjunctor, 2); YAP_UserCPredicate("gecode_new_clause", gecode_new_clause, 2); YAP_UserCPredicate("gecode_clause_intvar_forward", gecode_clause_intvar_forward, 3); YAP_UserCPredicate("gecode_clause_boolvar_forward", gecode_clause_boolvar_forward, 3); YAP_UserCPredicate("gecode_clause_setvar_forward", gecode_clause_setvar_forward, 3); #endif // backtracking search using an engine YAP_UserBackCutCPredicate("gecode_engine_search", gecode_engine_search, gecode_engine_search, NULL, 2, 0); // creating variables YAP_UserCPredicate("gecode_new_intvar_from_bounds", gecode_new_intvar_from_bounds, 4); YAP_UserCPredicate("gecode_new_intvar_from_intset", gecode_new_intvar_from_intset, 3); YAP_UserCPredicate("gecode_new_floatvar_from_bounds", gecode_new_floatvar_from_bounds, 4); YAP_UserCPredicate("gecode_new_boolvar", gecode_new_boolvar, 2); YAP_UserCPredicate("gecode_new_setvar_1", gecode_new_setvar_1, 8); YAP_UserCPredicate("gecode_new_setvar_2", gecode_new_setvar_2, 7); YAP_UserCPredicate("gecode_new_setvar_3", gecode_new_setvar_3, 6); YAP_UserCPredicate("gecode_new_setvar_4", gecode_new_setvar_4, 7); YAP_UserCPredicate("gecode_new_setvar_5", gecode_new_setvar_5, 6); YAP_UserCPredicate("gecode_new_setvar_6", gecode_new_setvar_6, 5); YAP_UserCPredicate("gecode_new_setvar_7", gecode_new_setvar_7, 7); YAP_UserCPredicate("gecode_new_setvar_8", gecode_new_setvar_8, 6); YAP_UserCPredicate("gecode_new_setvar_9", gecode_new_setvar_9, 5); YAP_UserCPredicate("gecode_new_setvar_10", gecode_new_setvar_10, 6); YAP_UserCPredicate("gecode_new_setvar_11", gecode_new_setvar_11, 5); YAP_UserCPredicate("gecode_new_setvar_12", gecode_new_setvar_12, 4); YAP_UserCPredicate("gecode_space_minimize", gecode_space_minimize, 2); YAP_UserCPredicate("gecode_space_maximize", gecode_space_maximize, 2); YAP_UserCPredicate("gecode_space_minimize_ratio", gecode_space_minimize_ratio, 3); YAP_UserCPredicate("gecode_space_maximize_ratio", gecode_space_maximize_ratio, 3); // INFO ON INTVARS YAP_UserCPredicate("gecode_intvar_assigned", gecode_intvar_assigned, 2); YAP_UserCPredicate("gecode_intvar_min", gecode_intvar_min, 3); YAP_UserCPredicate("gecode_intvar_max", gecode_intvar_max, 3); YAP_UserCPredicate("gecode_intvar_med", gecode_intvar_med, 3); YAP_UserCPredicate("gecode_intvar_val", gecode_intvar_val, 3); YAP_UserCPredicate("gecode_intvar_size", gecode_intvar_size, 3); YAP_UserCPredicate("gecode_intvar_width", gecode_intvar_width, 3); YAP_UserCPredicate("gecode_intvar_regret_min", gecode_intvar_regret_min, 3); YAP_UserCPredicate("gecode_intvar_regret_max", gecode_intvar_regret_max, 3); YAP_UserCPredicate("gecode_intvar_ranges", gecode_intvar_ranges, 3); YAP_UserCPredicate("gecode_intvar_values", gecode_intvar_values, 3); // INFO ON BOOLVARS YAP_UserCPredicate("gecode_boolvar_assigned", gecode_boolvar_assigned, 2); YAP_UserCPredicate("gecode_boolvar_min", gecode_boolvar_min, 3); YAP_UserCPredicate("gecode_boolvar_max", gecode_boolvar_max, 3); YAP_UserCPredicate("gecode_boolvar_med", gecode_boolvar_med, 3); YAP_UserCPredicate("gecode_boolvar_val", gecode_boolvar_val, 3); YAP_UserCPredicate("gecode_boolvar_size", gecode_boolvar_size, 3); YAP_UserCPredicate("gecode_boolvar_width", gecode_boolvar_width, 3); YAP_UserCPredicate("gecode_boolvar_regret_min", gecode_boolvar_regret_min, 3); YAP_UserCPredicate("gecode_boolvar_regret_max", gecode_boolvar_regret_max, 3); // INFO ON SETVARS YAP_UserCPredicate("gecode_setvar_assigned", gecode_setvar_assigned, 2); YAP_UserCPredicate("gecode_setvar_glbSize", gecode_setvar_glbSize, 3); YAP_UserCPredicate("gecode_setvar_lubSize", gecode_setvar_lubSize, 3); YAP_UserCPredicate("gecode_setvar_unknownSize", gecode_setvar_unknownSize, 3); YAP_UserCPredicate("gecode_setvar_cardMin", gecode_setvar_cardMin, 3); YAP_UserCPredicate("gecode_setvar_cardMax", gecode_setvar_cardMax, 3); YAP_UserCPredicate("gecode_setvar_lubMin", gecode_setvar_lubMin, 3); YAP_UserCPredicate("gecode_setvar_lubMax", gecode_setvar_lubMax, 3); YAP_UserCPredicate("gecode_setvar_glbMin", gecode_setvar_glbMin, 3); YAP_UserCPredicate("gecode_setvar_glbMax", gecode_setvar_glbMax, 3); YAP_UserCPredicate("gecode_setvar_glb_ranges", gecode_setvar_glb_ranges, 3); YAP_UserCPredicate("gecode_setvar_lub_ranges", gecode_setvar_lub_ranges, 3); YAP_UserCPredicate("gecode_setvar_unknown_ranges", gecode_setvar_unknown_ranges, 3); YAP_UserCPredicate("gecode_setvar_glb_values", gecode_setvar_glb_values, 3); YAP_UserCPredicate("gecode_setvar_lub_values", gecode_setvar_lub_values, 3); YAP_UserCPredicate("gecode_setvar_unknown_values", gecode_setvar_unknown_values, 3); YAP_UserCPredicate("gecode_space_use_keep_index", gecode_space_use_keep_index, 2); YAP_UserCPredicate("gecode_intvar_keep", gecode_intvar_keep, 3); YAP_UserCPredicate("gecode_boolvar_keep", gecode_boolvar_keep, 3); YAP_UserCPredicate("gecode_setvar_keep", gecode_setvar_keep, 3); // INFO ON FLOATVARS YAP_UserCPredicate("gecode_floatvar_assigned", gecode_floatvar_assigned, 2); YAP_UserCPredicate("gecode_floatvar_min", gecode_floatvar_min, 3); YAP_UserCPredicate("gecode_floatvar_max", gecode_floatvar_max, 3); YAP_UserCPredicate("gecode_floatvar_med", gecode_floatvar_med, 3); YAP_UserCPredicate("gecode_floatvar_size", gecode_floatvar_size, 3); } }